Lines Matching defs:udc
40 ((ep)->udc->ep0_dir) : ((ep)->direction))
58 static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver);
69 static void ep0_reset(struct mv_udc *udc)
77 ep = &udc->eps[i];
78 ep->udc = udc;
81 ep->dqh = &udc->ep_dqh[i];
90 epctrlx = readl(&udc->op_regs->epctrlx[0]);
102 writel(epctrlx, &udc->op_regs->epctrlx[0]);
107 static void ep0_stall(struct mv_udc *udc)
112 epctrlx = readl(&udc->op_regs->epctrlx[0]);
114 writel(epctrlx, &udc->op_regs->epctrlx[0]);
117 udc->ep0_state = WAIT_FOR_SETUP;
118 udc->ep0_dir = EP_DIR_OUT;
121 static int process_ep_req(struct mv_udc *udc, int index,
132 curr_dqh = &udc->ep_dqh[index];
140 dev_dbg(&udc->dev->dev, "%s, dTD not completed\n",
141 udc->eps[index].name);
154 dev_dbg(&udc->dev->dev,
162 dev_info(&udc->dev->dev,
189 while (readl(&udc->op_regs->epstatus) & bit_pos)
207 __releases(&ep->udc->lock)
208 __acquires(&ep->udc->lock)
210 struct mv_udc *udc = NULL;
215 udc = (struct mv_udc *)ep->udc;
231 dma_pool_free(udc->dtd_pool, curr_td, curr_td->td_dma);
234 usb_gadget_unmap_request(&udc->gadget, &req->req, ep_dir(ep));
237 dev_info(&udc->dev->dev, "complete %s req %p stat %d len %u/%u",
243 spin_unlock(&ep->udc->lock);
247 spin_lock(&ep->udc->lock);
253 struct mv_udc *udc;
260 udc = ep->udc;
262 dqh = &(udc->ep_dqh[ep->ep_num * 2 + direction]);
274 if (readl(&udc->op_regs->epprime) & bit_pos)
280 usbcmd = readl(&udc->op_regs->usbcmd);
282 writel(usbcmd, &udc->op_regs->usbcmd);
285 epstatus = readl(&udc->op_regs->epstatus) & bit_pos;
294 if (readl(&udc->op_regs->usbcmd)
300 dev_err(&udc->dev->dev,
309 usbcmd = readl(&udc->op_regs->usbcmd);
311 writel(usbcmd, &udc->op_regs->usbcmd);
328 writel(bit_pos, &udc->op_regs->epprime);
338 struct mv_udc *udc;
353 udc = req->ep->udc;
359 dtd = dma_pool_alloc(udc->dtd_pool, GFP_ATOMIC, dma);
437 struct mv_udc *udc;
447 udc = ep->udc;
453 if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
466 if ((readl(&udc->op_regs->epprime) & bit_pos)
467 || (readl(&udc->op_regs->epstatus) & bit_pos)) {
468 dev_info(&udc->dev->dev,
472 (unsigned)readl(&udc->op_regs->epprime),
473 (unsigned)readl(&udc->op_regs->epstatus),
499 spin_lock_irqsave(&udc->lock, flags);
514 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
526 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
532 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
536 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
539 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
543 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
546 spin_unlock_irqrestore(&udc->lock, flags);
555 struct mv_udc *udc;
565 udc = ep->udc;
570 spin_lock_irqsave(&udc->lock, flags);
578 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
582 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
590 spin_unlock_irqrestore(&udc->lock, flags);
622 struct mv_udc *udc;
634 udc = ep->udc;
649 dev_err(&udc->dev->dev,
651 (unsigned)readl(&udc->op_regs->epstatus),
656 writel(bit_pos, &udc->op_regs->epflush);
660 while (readl(&udc->op_regs->epflush)) {
666 dev_err(&udc->dev->dev,
669 (unsigned)readl(&udc->op_regs->epflush),
677 } while (readl(&udc->op_regs->epstatus) & bit_pos);
686 struct mv_udc *udc = ep->udc;
693 dev_err(&udc->dev->dev, "%s, bad params", __func__);
697 dev_err(&udc->dev->dev, "%s, bad ep", __func__);
701 udc = ep->udc;
702 if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
708 retval = usb_gadget_map_request(&udc->gadget, _req, ep_dir(ep));
716 spin_lock_irqsave(&udc->lock, flags);
722 spin_unlock_irqrestore(&udc->lock, flags);
723 dev_err(&udc->dev->dev, "Failed to queue dtd\n");
727 spin_unlock_irqrestore(&udc->lock, flags);
728 dev_err(&udc->dev->dev, "Failed to dma_pool_alloc\n");
735 udc->ep0_state = DATA_STATE_XMIT;
739 spin_unlock_irqrestore(&udc->lock, flags);
744 usb_gadget_unmap_request(&udc->gadget, _req, ep_dir(ep));
767 writel(bit_pos, &ep->udc->op_regs->epprime);
775 struct mv_udc *udc = ep->udc;
783 spin_lock_irqsave(&ep->udc->lock, flags);
788 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
793 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
843 epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
848 writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
851 spin_unlock_irqrestore(&ep->udc->lock, flags);
855 static void ep_set_stall(struct mv_udc *udc, u8 ep_num, u8 direction, int stall)
859 epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
875 writel(epctrlx, &udc->op_regs->epctrlx[ep_num]);
878 static int ep_is_stall(struct mv_udc *udc, u8 ep_num, u8 direction)
882 epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
895 struct mv_udc *udc;
898 udc = ep->udc;
918 spin_lock_irqsave(&ep->udc->lock, flags);
919 ep_set_stall(udc, ep->ep_num, ep_dir(ep), halt);
924 spin_unlock_irqrestore(&ep->udc->lock, flags);
927 udc->ep0_state = WAIT_FOR_SETUP;
928 udc->ep0_dir = EP_DIR_OUT;
959 static int udc_clock_enable(struct mv_udc *udc)
961 return clk_prepare_enable(udc->clk);
964 static void udc_clock_disable(struct mv_udc *udc)
966 clk_disable_unprepare(udc->clk);
969 static void udc_stop(struct mv_udc *udc)
974 tmp = readl(&udc->op_regs->usbintr);
977 writel(tmp, &udc->op_regs->usbintr);
979 udc->stopped = 1;
982 tmp = readl(&udc->op_regs->usbcmd);
984 writel(tmp, &udc->op_regs->usbcmd);
987 static void udc_start(struct mv_udc *udc)
995 writel(usbintr, &udc->op_regs->usbintr);
997 udc->stopped = 0;
1000 writel(USBCMD_RUN_STOP, &udc->op_regs->usbcmd);
1003 static int udc_reset(struct mv_udc *udc)
1009 tmp = readl(&udc->op_regs->usbcmd);
1011 writel(tmp, &udc->op_regs->usbcmd);
1014 writel(USBCMD_CTRL_RESET, &udc->op_regs->usbcmd);
1018 while (readl(&udc->op_regs->usbcmd) & USBCMD_CTRL_RESET) {
1020 dev_err(&udc->dev->dev,
1029 tmp = readl(&udc->op_regs->usbmode);
1035 writel(tmp, &udc->op_regs->usbmode);
1037 writel(0x0, &udc->op_regs->epsetupstat);
1040 writel(udc->ep_dqh_dma & USB_EP_LIST_ADDRESS_MASK,
1041 &udc->op_regs->eplistaddr);
1043 portsc = readl(&udc->op_regs->portsc[0]);
1044 if (readl(&udc->cap_regs->hcsparams) & HCSPARAMS_PPC)
1047 if (udc->force_fs)
1052 writel(portsc, &udc->op_regs->portsc[0]);
1054 tmp = readl(&udc->op_regs->epctrlx[0]);
1056 writel(tmp, &udc->op_regs->epctrlx[0]);
1061 static int mv_udc_enable_internal(struct mv_udc *udc)
1065 if (udc->active)
1068 dev_dbg(&udc->dev->dev, "enable udc\n");
1069 retval = udc_clock_enable(udc);
1073 if (udc->pdata->phy_init) {
1074 retval = udc->pdata->phy_init(udc->phy_regs);
1076 dev_err(&udc->dev->dev,
1078 udc_clock_disable(udc);
1082 udc->active = 1;
1087 static int mv_udc_enable(struct mv_udc *udc)
1089 if (udc->clock_gating)
1090 return mv_udc_enable_internal(udc);
1095 static void mv_udc_disable_internal(struct mv_udc *udc)
1097 if (udc->active) {
1098 dev_dbg(&udc->dev->dev, "disable udc\n");
1099 if (udc->pdata->phy_deinit)
1100 udc->pdata->phy_deinit(udc->phy_regs);
1101 udc_clock_disable(udc);
1102 udc->active = 0;
1106 static void mv_udc_disable(struct mv_udc *udc)
1108 if (udc->clock_gating)
1109 mv_udc_disable_internal(udc);
1114 struct mv_udc *udc;
1120 udc = container_of(gadget, struct mv_udc, gadget);
1122 retval = readl(&udc->op_regs->frindex) & USB_FRINDEX_MASKS;
1130 struct mv_udc *udc = container_of(gadget, struct mv_udc, gadget);
1134 if (!udc->remote_wakeup)
1137 portsc = readl(&udc->op_regs->portsc);
1143 writel(portsc, &udc->op_regs->portsc[0]);
1149 struct mv_udc *udc;
1153 udc = container_of(gadget, struct mv_udc, gadget);
1154 spin_lock_irqsave(&udc->lock, flags);
1156 udc->vbus_active = (is_active != 0);
1158 dev_dbg(&udc->dev->dev, "%s: softconnect %d, vbus_active %d\n",
1159 __func__, udc->softconnect, udc->vbus_active);
1161 if (udc->driver && udc->softconnect && udc->vbus_active) {
1162 retval = mv_udc_enable(udc);
1165 udc_reset(udc);
1166 ep0_reset(udc);
1167 udc_start(udc);
1169 } else if (udc->driver && udc->softconnect) {
1170 if (!udc->active)
1174 stop_activity(udc, udc->driver);
1175 udc_stop(udc);
1176 mv_udc_disable(udc);
1180 spin_unlock_irqrestore(&udc->lock, flags);
1186 struct mv_udc *udc;
1190 udc = container_of(gadget, struct mv_udc, gadget);
1191 spin_lock_irqsave(&udc->lock, flags);
1193 udc->softconnect = (is_on != 0);
1195 dev_dbg(&udc->dev->dev, "%s: softconnect %d, vbus_active %d\n",
1196 __func__, udc->softconnect, udc->vbus_active);
1198 if (udc->driver && udc->softconnect && udc->vbus_active) {
1199 retval = mv_udc_enable(udc);
1202 udc_reset(udc);
1203 ep0_reset(udc);
1204 udc_start(udc);
1206 } else if (udc->driver && udc->vbus_active) {
1208 stop_activity(udc, udc->driver);
1209 udc_stop(udc);
1210 mv_udc_disable(udc);
1213 spin_unlock_irqrestore(&udc->lock, flags);
1237 static int eps_init(struct mv_udc *udc)
1244 ep = &udc->eps[0];
1245 ep->udc = udc;
1262 for (i = 2; i < udc->max_eps * 2; i++) {
1263 ep = &udc->eps[i];
1273 ep->udc = udc;
1287 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
1289 ep->dqh = &udc->ep_dqh[i];
1311 static void gadget_reset(struct mv_udc *udc, struct usb_gadget_driver *driver)
1315 nuke(&udc->eps[0], -ESHUTDOWN);
1317 list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
1323 spin_unlock(&udc->lock);
1324 usb_gadget_udc_reset(&udc->gadget, driver);
1325 spin_lock(&udc->lock);
1329 static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver)
1333 nuke(&udc->eps[0], -ESHUTDOWN);
1335 list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
1341 spin_unlock(&udc->lock);
1342 driver->disconnect(&udc->gadget);
1343 spin_lock(&udc->lock);
1350 struct mv_udc *udc;
1354 udc = container_of(gadget, struct mv_udc, gadget);
1356 if (udc->driver)
1359 spin_lock_irqsave(&udc->lock, flags);
1362 udc->driver = driver;
1364 udc->usb_state = USB_STATE_ATTACHED;
1365 udc->ep0_state = WAIT_FOR_SETUP;
1366 udc->ep0_dir = EP_DIR_OUT;
1368 spin_unlock_irqrestore(&udc->lock, flags);
1370 if (udc->transceiver) {
1371 retval = otg_set_peripheral(udc->transceiver->otg,
1372 &udc->gadget);
1374 dev_err(&udc->dev->dev,
1376 udc->driver = NULL;
1382 if (udc->qwork)
1383 queue_work(udc->qwork, &udc->vbus_work);
1390 struct mv_udc *udc;
1393 udc = container_of(gadget, struct mv_udc, gadget);
1395 spin_lock_irqsave(&udc->lock, flags);
1397 mv_udc_enable(udc);
1398 udc_stop(udc);
1401 udc->gadget.speed = USB_SPEED_UNKNOWN;
1402 stop_activity(udc, NULL);
1403 mv_udc_disable(udc);
1405 spin_unlock_irqrestore(&udc->lock, flags);
1408 udc->driver = NULL;
1413 static void mv_set_ptc(struct mv_udc *udc, u32 mode)
1417 portsc = readl(&udc->op_regs->portsc[0]);
1419 writel(portsc, &udc->op_regs->portsc[0]);
1426 struct mv_udc *udc;
1429 udc = mvep->udc;
1431 dev_info(&udc->dev->dev, "switch to test mode %d\n", req->test_mode);
1433 spin_lock_irqsave(&udc->lock, flags);
1435 mv_set_ptc(udc, req->test_mode);
1438 spin_unlock_irqrestore(&udc->lock, flags);
1442 udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty)
1448 ep = &udc->eps[0];
1449 udc->ep0_dir = direction;
1450 udc->ep0_state = WAIT_FOR_OUT_STATUS;
1452 req = udc->status_req;
1464 if (udc->test_mode) {
1466 req->test_mode = udc->test_mode;
1467 udc->test_mode = 0;
1473 req->req.dma = dma_map_single(ep->udc->gadget.dev.parent,
1483 dev_err(&udc->dev->dev,
1489 dev_err(&udc->dev->dev,
1498 usb_gadget_unmap_request(&udc->gadget, &req->req, ep_dir(ep));
1503 static void mv_udc_testmode(struct mv_udc *udc, u16 index)
1506 udc->test_mode = index;
1507 if (udc_prime_status(udc, EP_DIR_IN, 0, true))
1508 ep0_stall(udc);
1510 dev_err(&udc->dev->dev,
1514 static void ch9setaddress(struct mv_udc *udc, struct usb_ctrlrequest *setup)
1516 udc->dev_addr = (u8)setup->wValue;
1519 udc->usb_state = USB_STATE_ADDRESS;
1521 if (udc_prime_status(udc, EP_DIR_IN, 0, true))
1522 ep0_stall(udc);
1525 static void ch9getstatus(struct mv_udc *udc, u8 ep_num,
1537 status |= udc->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP;
1549 status = ep_is_stall(udc, ep_num, direction)
1553 retval = udc_prime_status(udc, EP_DIR_IN, status, false);
1555 ep0_stall(udc);
1557 udc->ep0_state = DATA_STATE_XMIT;
1560 static void ch9clearfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
1570 udc->remote_wakeup = 0;
1583 || ep_num > udc->max_eps)
1585 ep = &udc->eps[ep_num * 2 + direction];
1588 spin_unlock(&udc->lock);
1589 ep_set_stall(udc, ep_num, direction, 0);
1590 spin_lock(&udc->lock);
1598 if (udc_prime_status(udc, EP_DIR_IN, 0, true))
1599 ep0_stall(udc);
1604 static void ch9setfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
1613 udc->remote_wakeup = 1;
1617 || udc->gadget.speed != USB_SPEED_HIGH)
1618 ep0_stall(udc);
1620 if (udc->usb_state != USB_STATE_CONFIGURED
1621 && udc->usb_state != USB_STATE_ADDRESS
1622 && udc->usb_state != USB_STATE_DEFAULT)
1623 ep0_stall(udc);
1625 mv_udc_testmode(udc, (setup->wIndex >> 8));
1638 || ep_num > udc->max_eps)
1640 spin_unlock(&udc->lock);
1641 ep_set_stall(udc, ep_num, direction, 1);
1642 spin_lock(&udc->lock);
1650 if (udc_prime_status(udc, EP_DIR_IN, 0, true))
1651 ep0_stall(udc);
1656 static void handle_setup_packet(struct mv_udc *udc, u8 ep_num,
1658 __releases(&ep->udc->lock)
1659 __acquires(&ep->udc->lock)
1663 nuke(&udc->eps[ep_num * 2 + EP_DIR_OUT], -ESHUTDOWN);
1665 dev_dbg(&udc->dev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
1672 ch9getstatus(udc, ep_num, setup);
1676 ch9setaddress(udc, setup);
1680 ch9clearfeature(udc, setup);
1684 ch9setfeature(udc, setup);
1697 /* DATA phase from gadget, STATUS phase from udc */
1698 udc->ep0_dir = (setup->bRequestType & USB_DIR_IN)
1700 spin_unlock(&udc->lock);
1701 if (udc->driver->setup(&udc->gadget,
1702 &udc->local_setup_buff) < 0)
1703 ep0_stall(udc);
1704 spin_lock(&udc->lock);
1705 udc->ep0_state = (setup->bRequestType & USB_DIR_IN)
1709 udc->ep0_dir = EP_DIR_IN;
1710 spin_unlock(&udc->lock);
1711 if (udc->driver->setup(&udc->gadget,
1712 &udc->local_setup_buff) < 0)
1713 ep0_stall(udc);
1714 spin_lock(&udc->lock);
1715 udc->ep0_state = WAIT_FOR_OUT_STATUS;
1721 static void ep0_req_complete(struct mv_udc *udc,
1726 if (udc->usb_state == USB_STATE_ADDRESS) {
1728 new_addr = (u32)udc->dev_addr;
1730 &udc->op_regs->deviceaddr);
1735 switch (udc->ep0_state) {
1738 if (udc_prime_status(udc, EP_DIR_OUT, 0, true))
1739 ep0_stall(udc);
1743 if (udc_prime_status(udc, EP_DIR_IN, 0 , true))
1744 ep0_stall(udc);
1747 udc->ep0_state = WAIT_FOR_SETUP;
1750 dev_err(&udc->dev->dev, "unexpect ep0 packets\n");
1753 ep0_stall(udc);
1758 static void get_setup_data(struct mv_udc *udc, u8 ep_num, u8 *buffer_ptr)
1763 dqh = &udc->ep_dqh[ep_num * 2 + EP_DIR_OUT];
1766 writel((1 << ep_num), &udc->op_regs->epsetupstat);
1771 temp = readl(&udc->op_regs->usbcmd);
1772 writel(temp | USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
1776 } while (!(readl(&udc->op_regs->usbcmd) & USBCMD_SETUP_TRIPWIRE_SET));
1779 temp = readl(&udc->op_regs->usbcmd);
1780 writel(temp & ~USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
1783 static void irq_process_tr_complete(struct mv_udc *udc)
1797 tmp = readl(&udc->op_regs->epsetupstat);
1800 for (i = 0; i < udc->max_eps; i++) {
1802 get_setup_data(udc, i,
1803 (u8 *)(&udc->local_setup_buff));
1804 handle_setup_packet(udc, i,
1805 &udc->local_setup_buff);
1815 tmp = readl(&udc->op_regs->epcomplete);
1820 writel(tmp, &udc->op_regs->epcomplete);
1822 for (i = 0; i < udc->max_eps * 2; i++) {
1832 curr_ep = &udc->eps[0];
1834 curr_ep = &udc->eps[i];
1838 status = process_ep_req(udc, i, curr_req);
1847 ep0_req_complete(udc, curr_ep, curr_req);
1856 static void irq_process_reset(struct mv_udc *udc)
1861 udc->ep0_dir = EP_DIR_OUT;
1862 udc->ep0_state = WAIT_FOR_SETUP;
1863 udc->remote_wakeup = 0; /* default to 0 on reset */
1866 tmp = readl(&udc->op_regs->deviceaddr);
1868 writel(tmp, &udc->op_regs->deviceaddr);
1871 tmp = readl(&udc->op_regs->epsetupstat);
1872 writel(tmp, &udc->op_regs->epsetupstat);
1875 tmp = readl(&udc->op_regs->epcomplete);
1876 writel(tmp, &udc->op_regs->epcomplete);
1880 while (readl(&udc->op_regs->epprime) & 0xFFFFFFFF) {
1882 dev_err(&udc->dev->dev,
1884 readl(&udc->op_regs->epprime));
1892 writel((u32)~0, &udc->op_regs->epflush);
1894 if (readl(&udc->op_regs->portsc[0]) & PORTSCX_PORT_RESET) {
1895 dev_info(&udc->dev->dev, "usb bus reset\n");
1896 udc->usb_state = USB_STATE_DEFAULT;
1898 gadget_reset(udc, udc->driver);
1900 dev_info(&udc->dev->dev, "USB reset portsc 0x%x\n",
1901 readl(&udc->op_regs->portsc));
1907 udc_reset(udc);
1910 stop_activity(udc, udc->driver);
1913 ep0_reset(udc);
1916 udc_start(udc);
1918 udc->usb_state = USB_STATE_ATTACHED;
1922 static void handle_bus_resume(struct mv_udc *udc)
1924 udc->usb_state = udc->resume_state;
1925 udc->resume_state = 0;
1928 if (udc->driver) {
1929 if (udc->driver->resume) {
1930 spin_unlock(&udc->lock);
1931 udc->driver->resume(&udc->gadget);
1932 spin_lock(&udc->lock);
1937 static void irq_process_suspend(struct mv_udc *udc)
1939 udc->resume_state = udc->usb_state;
1940 udc->usb_state = USB_STATE_SUSPENDED;
1942 if (udc->driver->suspend) {
1943 spin_unlock(&udc->lock);
1944 udc->driver->suspend(&udc->gadget);
1945 spin_lock(&udc->lock);
1949 static void irq_process_port_change(struct mv_udc *udc)
1953 portsc = readl(&udc->op_regs->portsc[0]);
1959 udc->gadget.speed = USB_SPEED_HIGH;
1962 udc->gadget.speed = USB_SPEED_FULL;
1965 udc->gadget.speed = USB_SPEED_LOW;
1968 udc->gadget.speed = USB_SPEED_UNKNOWN;
1974 udc->resume_state = udc->usb_state;
1975 udc->usb_state = USB_STATE_SUSPENDED;
1976 if (udc->driver->suspend) {
1977 spin_unlock(&udc->lock);
1978 udc->driver->suspend(&udc->gadget);
1979 spin_lock(&udc->lock);
1984 && udc->usb_state == USB_STATE_SUSPENDED) {
1985 handle_bus_resume(udc);
1988 if (!udc->resume_state)
1989 udc->usb_state = USB_STATE_DEFAULT;
1992 static void irq_process_error(struct mv_udc *udc)
1995 udc->errors++;
2000 struct mv_udc *udc = (struct mv_udc *)dev;
2004 if (udc->stopped)
2007 spin_lock(&udc->lock);
2009 status = readl(&udc->op_regs->usbsts);
2010 intr = readl(&udc->op_regs->usbintr);
2014 spin_unlock(&udc->lock);
2019 writel(status, &udc->op_regs->usbsts);
2022 irq_process_error(udc);
2025 irq_process_reset(udc);
2028 irq_process_port_change(udc);
2031 irq_process_tr_complete(udc);
2034 irq_process_suspend(udc);
2036 spin_unlock(&udc->lock);
2043 struct mv_udc *udc = (struct mv_udc *)dev;
2046 if (udc->qwork)
2047 queue_work(udc->qwork, &udc->vbus_work);
2054 struct mv_udc *udc;
2057 udc = container_of(work, struct mv_udc, vbus_work);
2058 if (!udc->pdata->vbus)
2061 vbus = udc->pdata->vbus->poll();
2062 dev_info(&udc->dev->dev, "vbus is %d\n", vbus);
2065 mv_udc_vbus_session(&udc->gadget, 1);
2067 mv_udc_vbus_session(&udc->gadget, 0);
2073 struct mv_udc *udc;
2075 udc = dev_get_drvdata(_dev);
2077 complete(udc->done);
2082 struct mv_udc *udc;
2084 udc = platform_get_drvdata(pdev);
2086 usb_del_gadget_udc(&udc->gadget);
2088 if (udc->qwork)
2089 destroy_workqueue(udc->qwork);
2092 dma_pool_destroy(udc->dtd_pool);
2094 if (udc->ep_dqh)
2095 dma_free_coherent(&pdev->dev, udc->ep_dqh_size,
2096 udc->ep_dqh, udc->ep_dqh_dma);
2098 mv_udc_disable(udc);
2101 wait_for_completion(udc->done);
2107 struct mv_udc *udc;
2117 udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL);
2118 if (udc == NULL)
2121 udc->done = &release_done;
2122 udc->pdata = dev_get_platdata(&pdev->dev);
2123 spin_lock_init(&udc->lock);
2125 udc->dev = pdev;
2128 udc->transceiver = devm_usb_get_phy(&pdev->dev,
2130 if (IS_ERR(udc->transceiver)) {
2131 retval = PTR_ERR(udc->transceiver);
2136 udc->transceiver = NULL;
2141 /* udc only have one sysclk. */
2142 udc->clk = devm_clk_get(&pdev->dev, NULL);
2143 if (IS_ERR(udc->clk))
2144 return PTR_ERR(udc->clk);
2146 r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "capregs");
2152 udc->cap_regs = (struct mv_cap_regs __iomem *)
2154 if (udc->cap_regs == NULL) {
2159 r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "phyregs");
2165 udc->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
2166 if (udc->phy_regs == NULL) {
2172 retval = mv_udc_enable_internal(udc);
2176 udc->op_regs =
2177 (struct mv_op_regs __iomem *)((unsigned long)udc->cap_regs
2178 + (readl(&udc->cap_regs->caplength_hciversion)
2180 udc->max_eps = readl(&udc->cap_regs->dccparams) & DCCPARAMS_DEN_MASK;
2184 * usb gadget before loading kernel. So first stop udc here.
2186 udc_stop(udc);
2187 writel(0xFFFFFFFF, &udc->op_regs->usbsts);
2189 size = udc->max_eps * sizeof(struct mv_dqh) *2;
2191 udc->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
2192 &udc->ep_dqh_dma, GFP_KERNEL);
2194 if (udc->ep_dqh == NULL) {
2199 udc->ep_dqh_size = size;
2202 udc->dtd_pool = dma_pool_create("mv_dtd",
2208 if (!udc->dtd_pool) {
2213 size = udc->max_eps * sizeof(struct mv_ep) *2;
2214 udc->eps = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
2215 if (udc->eps == NULL) {
2221 udc->status_req = devm_kzalloc(&pdev->dev, sizeof(struct mv_req),
2223 if (!udc->status_req) {
2227 INIT_LIST_HEAD(&udc->status_req->queue);
2230 udc->status_req->req.buf = devm_kzalloc(&pdev->dev, 8, GFP_KERNEL);
2231 if (!udc->status_req->req.buf) {
2235 udc->status_req->req.dma = DMA_ADDR_INVALID;
2237 udc->resume_state = USB_STATE_NOTATTACHED;
2238 udc->usb_state = USB_STATE_POWERED;
2239 udc->ep0_dir = EP_DIR_OUT;
2240 udc->remote_wakeup = 0;
2242 r = platform_get_resource(udc->dev, IORESOURCE_IRQ, 0);
2248 udc->irq = r->start;
2249 if (devm_request_irq(&pdev->dev, udc->irq, mv_udc_irq,
2250 IRQF_SHARED, driver_name, udc)) {
2252 udc->irq);
2258 udc->gadget.ops = &mv_ops; /* usb_gadget_ops */
2259 udc->gadget.ep0 = &udc->eps[0].ep; /* gadget ep0 */
2260 INIT_LIST_HEAD(&udc->gadget.ep_list); /* ep_list */
2261 udc->gadget.speed = USB_SPEED_UNKNOWN; /* speed */
2262 udc->gadget.max_speed = USB_SPEED_HIGH; /* support dual speed */
2265 udc->gadget.name = driver_name; /* gadget name */
2267 eps_init(udc);
2270 if (udc->transceiver)
2271 udc->clock_gating = 1;
2273 udc->clock_gating = 1;
2276 mv_udc_vbus_irq, IRQF_ONESHOT, "vbus", udc);
2281 udc->clock_gating = 0;
2284 udc->qwork = create_singlethread_workqueue("mv_udc_queue");
2285 if (!udc->qwork) {
2291 INIT_WORK(&udc->vbus_work, mv_udc_vbus_work);
2299 if (udc->clock_gating)
2300 mv_udc_disable_internal(udc);
2302 udc->vbus_active = 1;
2304 retval = usb_add_gadget_udc_release(&pdev->dev, &udc->gadget,
2309 platform_set_drvdata(pdev, udc);
2311 udc->clock_gating ? "with" : "without");
2316 if (udc->qwork)
2317 destroy_workqueue(udc->qwork);
2319 dma_pool_destroy(udc->dtd_pool);
2321 dma_free_coherent(&pdev->dev, udc->ep_dqh_size,
2322 udc->ep_dqh, udc->ep_dqh_dma);
2324 mv_udc_disable_internal(udc);
2332 struct mv_udc *udc;
2334 udc = dev_get_drvdata(dev);
2337 if (udc->transceiver)
2340 if (udc->pdata->vbus && udc->pdata->vbus->poll)
2341 if (udc->pdata->vbus->poll() == VBUS_HIGH) {
2342 dev_info(&udc->dev->dev, "USB cable is connected!\n");
2347 * only cable is unplugged, udc can suspend.
2350 if (!udc->clock_gating) {
2351 udc_stop(udc);
2353 spin_lock_irq(&udc->lock);
2355 stop_activity(udc, udc->driver);
2356 spin_unlock_irq(&udc->lock);
2358 mv_udc_disable_internal(udc);
2366 struct mv_udc *udc;
2369 udc = dev_get_drvdata(dev);
2372 if (udc->transceiver)
2375 if (!udc->clock_gating) {
2376 retval = mv_udc_enable_internal(udc);
2380 if (udc->driver && udc->softconnect) {
2381 udc_reset(udc);
2382 ep0_reset(udc);
2383 udc_start(udc);
2398 struct mv_udc *udc;
2401 udc = platform_get_drvdata(pdev);
2403 mv_udc_enable(udc);
2404 mode = readl(&udc->op_regs->usbmode);
2406 writel(mode, &udc->op_regs->usbmode);
2407 mv_udc_disable(udc);
2415 .name = "mv-udc",
2423 MODULE_ALIAS("platform:mv-udc");