Lines Matching defs:musb
65 __releases(ep->musb->lock)
66 __acquires(ep->musb->lock)
69 struct musb *musb;
77 musb = req->musb;
80 spin_unlock(&musb->lock);
83 dma_unmap_single(musb->controller,
92 dma_sync_single_for_cpu(musb->controller,
109 spin_lock(&musb->lock);
122 void __iomem *epio = ep->musb->endpoints[ep->current_epnum].regs;
127 struct dma_controller *c = ep->musb->dma_controller;
169 static inline int max_ep_writesize(struct musb *musb, struct musb_ep *ep)
171 if (can_bulk_split(musb, ep->type))
219 static void txstate(struct musb *musb, struct musb_request *req)
223 void __iomem *epio = musb->endpoints[epnum].regs;
240 fifo_count = min(max_ep_writesize(musb, musb_ep),
261 struct dma_controller *c = musb->dma_controller;
376 void musb_g_tx(struct musb *musb, u8 epnum)
380 u8 __iomem *mbase = musb->mregs;
381 struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_in;
382 void __iomem *epio = musb->endpoints[epnum].regs;
474 txstate(musb, to_musb_request(request));
514 static void rxstate(struct musb *musb, struct musb_request *req)
519 void __iomem *epio = musb->endpoints[epnum].regs;
523 struct musb_hw_ep *hw_ep = &musb->endpoints[epnum];
545 struct dma_controller *c = musb->dma_controller;
580 c = musb->dma_controller;
656 struct dma_controller *c = musb->dma_controller;
694 void musb_g_rx(struct musb *musb, u8 epnum)
698 void __iomem *mbase = musb->mregs;
700 void __iomem *epio = musb->endpoints[epnum].regs;
702 struct musb_hw_ep *hw_ep = &musb->endpoints[epnum];
789 rxstate(musb, to_musb_request(request));
806 struct musb *musb;
819 musb = musb_ep->musb;
820 mbase = musb->mregs;
823 spin_lock_irqsave(&musb->lock, flags);
863 * buffering has problem if musb RTL revision number < 2.0.
865 if (musb->hwvers < MUSB_HWVERS_2000)
901 if (musb->hwvers < MUSB_HWVERS_2000)
927 if (is_dma_capable() && musb->dma_controller) {
928 struct dma_controller *c = musb->dma_controller;
951 schedule_work(&musb->irq_work);
954 spin_unlock_irqrestore(&musb->lock, flags);
964 struct musb *musb;
971 musb = musb_ep->musb;
973 epio = musb->endpoints[epnum].regs;
975 spin_lock_irqsave(&musb->lock, flags);
976 musb_ep_select(musb->mregs, epnum);
980 u16 int_txe = musb_readw(musb->mregs, MUSB_INTRTXE);
982 musb_writew(musb->mregs, MUSB_INTRTXE, int_txe);
985 u16 int_rxe = musb_readw(musb->mregs, MUSB_INTRRXE);
987 musb_writew(musb->mregs, MUSB_INTRRXE, int_rxe);
996 schedule_work(&musb->irq_work);
998 spin_unlock_irqrestore(&(musb->lock), flags);
1046 void musb_ep_restart(struct musb *musb, struct musb_request *req)
1052 musb_ep_select(musb->mregs, req->epnum);
1054 txstate(musb, req);
1056 rxstate(musb, req);
1064 struct musb *musb;
1074 musb = musb_ep->musb;
1077 request->musb = musb;
1093 musb->controller,
1101 dma_sync_single_for_device(musb->controller,
1114 spin_lock_irqsave(&musb->lock, lockflags);
1129 musb_ep_restart(musb, request);
1132 spin_unlock_irqrestore(&musb->lock, lockflags);
1142 struct musb *musb = musb_ep->musb;
1147 spin_lock_irqsave(&musb->lock, flags);
1165 struct dma_controller *c = musb->dma_controller;
1167 musb_ep_select(musb->mregs, musb_ep->current_epnum);
1182 spin_unlock_irqrestore(&musb->lock, flags);
1196 struct musb *musb = musb_ep->musb;
1197 void __iomem *epio = musb->endpoints[epnum].regs;
1206 mbase = musb->mregs;
1208 spin_lock_irqsave(&musb->lock, flags);
1266 musb_ep_restart(musb, request);
1270 spin_unlock_irqrestore(&musb->lock, flags);
1296 struct musb *musb = musb_ep->musb;
1298 void __iomem *mbase = musb->mregs;
1301 spin_lock_irqsave(&musb->lock, flags);
1306 spin_unlock_irqrestore(&musb->lock, flags);
1314 struct musb *musb = musb_ep->musb;
1316 void __iomem *epio = musb->endpoints[epnum].regs;
1321 mbase = musb->mregs;
1323 spin_lock_irqsave(&musb->lock, flags);
1347 spin_unlock_irqrestore(&musb->lock, flags);
1367 struct musb *musb = gadget_to_musb(gadget);
1369 return (int)musb_readw(musb->mregs, MUSB_FRAME);
1374 struct musb *musb = gadget_to_musb(gadget);
1375 void __iomem *mregs = musb->mregs;
1381 spin_lock_irqsave(&musb->lock, flags);
1383 switch (musb->xceiv->state) {
1389 if (musb->may_wakeup && musb->is_suspended)
1413 musb_platform_try_idle(musb,
1419 DBG(2, "Unhandled wake: %s\n", otg_state_string(musb));
1436 spin_unlock_irqrestore(&musb->lock, flags);
1443 struct musb *musb = gadget_to_musb(gadget);
1445 musb->is_self_powered = !!is_selfpowered;
1449 static void musb_pullup(struct musb *musb, int is_on)
1453 power = musb_readb(musb->mregs, MUSB_POWER);
1461 musb->gadget_driver->function, is_on ? "on" : "off");
1462 musb_writeb(musb->mregs, MUSB_POWER, power);
1468 struct musb *musb = gadget_to_musb(gadget);
1470 if (!musb->xceiv->set_power)
1472 return otg_set_power(musb->xceiv, mA);
1477 struct musb *musb = gadget_to_musb(gadget);
1485 spin_lock_irqsave(&musb->lock, flags);
1486 if (is_on != musb->softconnect) {
1487 musb->softconnect = is_on;
1488 musb_pullup(musb, is_on);
1490 spin_unlock_irqrestore(&musb->lock, flags);
1511 static struct musb *the_gadget;
1521 init_peripheral_ep(struct musb *musb, struct musb_ep *ep, u8 epnum, int is_in)
1523 struct musb_hw_ep *hw_ep = musb->endpoints + epnum;
1528 ep->musb = musb;
1542 musb->g.ep0 = &ep->end_point;
1549 list_add_tail(&ep->end_point.ep_list, &musb->g.ep_list);
1557 static inline void __init musb_g_init_endpoints(struct musb *musb)
1564 INIT_LIST_HEAD(&(musb->g.ep_list));
1566 for (epnum = 0, hw_ep = musb->endpoints;
1567 epnum < musb->nr_endpoints;
1570 init_peripheral_ep(musb, &hw_ep->ep_in, epnum, 0);
1574 init_peripheral_ep(musb, &hw_ep->ep_in,
1579 init_peripheral_ep(musb, &hw_ep->ep_out,
1590 int __init musb_gadget_setup(struct musb *musb)
1595 * musb peripherals at the same time, only the bus lock
1600 the_gadget = musb;
1602 musb->g.ops = &musb_gadget_operations;
1603 musb->g.is_dualspeed = 1;
1604 musb->g.speed = USB_SPEED_UNKNOWN;
1607 dev_set_name(&musb->g.dev, "gadget");
1608 musb->g.dev.parent = musb->controller;
1609 musb->g.dev.dma_mask = musb->controller->dma_mask;
1610 musb->g.dev.release = musb_gadget_release;
1611 musb->g.name = musb_driver_name;
1613 if (is_otg_enabled(musb))
1614 musb->g.is_otg = 1;
1616 musb_g_init_endpoints(musb);
1618 musb->is_active = 0;
1619 musb_platform_try_idle(musb, 0);
1621 status = device_register(&musb->g.dev);
1627 void musb_gadget_cleanup(struct musb *musb)
1629 if (musb != the_gadget)
1632 device_unregister(&musb->g.dev);
1651 struct musb *musb = the_gadget;
1660 if (!musb) {
1666 spin_lock_irqsave(&musb->lock, flags);
1668 if (musb->gadget_driver) {
1671 musb->gadget_driver->driver.name);
1674 musb->gadget_driver = driver;
1675 musb->g.dev.driver = &driver->driver;
1677 musb->softconnect = 1;
1681 spin_unlock_irqrestore(&musb->lock, flags);
1684 retval = driver->bind(&musb->g);
1688 musb->gadget_driver = NULL;
1689 musb->g.dev.driver = NULL;
1692 spin_lock_irqsave(&musb->lock, flags);
1694 otg_set_peripheral(musb->xceiv, &musb->g);
1695 musb->xceiv->state = OTG_STATE_B_IDLE;
1696 musb->is_active = 1;
1699 if (!is_otg_enabled(musb))
1700 musb_start(musb);
1702 otg_set_peripheral(musb->xceiv, &musb->g);
1704 spin_unlock_irqrestore(&musb->lock, flags);
1706 if (is_otg_enabled(musb)) {
1713 retval = usb_add_hcd(musb_to_hcd(musb), -1, 0);
1716 spin_lock_irqsave(&musb->lock, flags);
1717 otg_set_peripheral(musb->xceiv, NULL);
1718 musb->gadget_driver = NULL;
1719 musb->g.dev.driver = NULL;
1720 spin_unlock_irqrestore(&musb->lock, flags);
1729 static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
1735 if (musb->g.speed == USB_SPEED_UNKNOWN)
1738 musb->g.speed = USB_SPEED_UNKNOWN;
1741 if (musb->softconnect) {
1742 musb->softconnect = 0;
1743 musb_pullup(musb, 0);
1745 musb_stop(musb);
1751 for (i = 0, hw_ep = musb->endpoints;
1752 i < musb->nr_endpoints;
1754 musb_ep_select(musb->mregs, i);
1765 spin_unlock(&musb->lock);
1766 driver->disconnect(&musb->g);
1767 spin_lock(&musb->lock);
1781 struct musb *musb = the_gadget;
1783 if (!driver || !driver->unbind || !musb)
1790 spin_lock_irqsave(&musb->lock, flags);
1793 musb_hnp_stop(musb);
1796 if (musb->gadget_driver == driver) {
1798 (void) musb_gadget_vbus_draw(&musb->g, 0);
1800 musb->xceiv->state = OTG_STATE_UNDEFINED;
1801 stop_activity(musb, driver);
1802 otg_set_peripheral(musb->xceiv, NULL);
1805 spin_unlock_irqrestore(&musb->lock, flags);
1806 driver->unbind(&musb->g);
1807 spin_lock_irqsave(&musb->lock, flags);
1809 musb->gadget_driver = NULL;
1810 musb->g.dev.driver = NULL;
1812 musb->is_active = 0;
1813 musb_platform_try_idle(musb, 0);
1816 spin_unlock_irqrestore(&musb->lock, flags);
1818 if (is_otg_enabled(musb) && retval == 0) {
1819 usb_remove_hcd(musb_to_hcd(musb));
1831 void musb_g_resume(struct musb *musb)
1833 musb->is_suspended = 0;
1834 switch (musb->xceiv->state) {
1839 musb->is_active = 1;
1840 if (musb->gadget_driver && musb->gadget_driver->resume) {
1841 spin_unlock(&musb->lock);
1842 musb->gadget_driver->resume(&musb->g);
1843 spin_lock(&musb->lock);
1848 otg_state_string(musb));
1853 void musb_g_suspend(struct musb *musb)
1857 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
1860 switch (musb->xceiv->state) {
1863 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
1866 musb->is_suspended = 1;
1867 if (musb->gadget_driver && musb->gadget_driver->suspend) {
1868 spin_unlock(&musb->lock);
1869 musb->gadget_driver->suspend(&musb->g);
1870 spin_lock(&musb->lock);
1878 otg_state_string(musb));
1883 void musb_g_wakeup(struct musb *musb)
1885 musb_gadget_wakeup(&musb->g);
1889 void musb_g_disconnect(struct musb *musb)
1891 void __iomem *mregs = musb->mregs;
1900 (void) musb_gadget_vbus_draw(&musb->g, 0);
1902 musb->g.speed = USB_SPEED_UNKNOWN;
1903 if (musb->gadget_driver && musb->gadget_driver->disconnect) {
1904 spin_unlock(&musb->lock);
1905 musb->gadget_driver->disconnect(&musb->g);
1906 spin_lock(&musb->lock);
1909 switch (musb->xceiv->state) {
1913 otg_state_string(musb));
1914 musb->xceiv->state = OTG_STATE_A_IDLE;
1915 MUSB_HST_MODE(musb);
1918 musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
1919 MUSB_HST_MODE(musb);
1926 musb->xceiv->state = OTG_STATE_B_IDLE;
1932 musb->is_active = 0;
1935 void musb_g_reset(struct musb *musb)
1936 __releases(musb->lock)
1937 __acquires(musb->lock)
1939 void __iomem *mbase = musb->mregs;
1947 musb->gadget_driver
1948 ? musb->gadget_driver->driver.name
1953 if (musb->g.speed != USB_SPEED_UNKNOWN)
1954 musb_g_disconnect(musb);
1963 musb->g.speed = (power & MUSB_POWER_HSMODE)
1967 musb->is_active = 1;
1968 musb->is_suspended = 0;
1969 MUSB_DEV_MODE(musb);
1970 musb->address = 0;
1971 musb->ep0_state = MUSB_EP0_STAGE_SETUP;
1973 musb->may_wakeup = 0;
1974 musb->g.b_hnp_enable = 0;
1975 musb->g.a_alt_hnp_support = 0;
1976 musb->g.a_hnp_support = 0;
1982 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
1983 musb->g.is_a_peripheral = 0;
1984 } else if (is_otg_enabled(musb)) {
1985 musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
1986 musb->g.is_a_peripheral = 1;
1991 (void) musb_gadget_vbus_draw(&musb->g,
1992 is_otg_enabled(musb) ? 8 : 100);