Lines Matching refs:dev
97 dev_dbg(ep->dev->dev, "%s: 0x%p, %d bytes data%s:\n", str, req, buflen,
103 static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
106 dev_vdbg(dev->dev, "REQ: %02x.%02x v%04x i%04x l%04x\n",
114 static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
183 struct gr_udc *dev = seq->private;
184 u32 control = gr_read32(&dev->regs->control);
185 u32 status = gr_read32(&dev->regs->status);
189 usb_state_string(dev->gadget.state));
193 seq_printf(seq, "ep0state = %s\n", gr_ep0state_string(dev->ep0state));
194 seq_printf(seq, "irq_enabled = %d\n", dev->irq_enabled);
195 seq_printf(seq, "remote_wakeup = %d\n", dev->remote_wakeup);
196 seq_printf(seq, "test_mode = %d\n", dev->test_mode);
199 list_for_each_entry(ep, &dev->ep_list, ep_list)
206 static void gr_dfs_create(struct gr_udc *dev)
211 root = debugfs_create_dir(dev_name(dev->dev), usb_debug_root);
212 debugfs_create_file(name, 0444, root, dev, &gr_dfs_fops);
215 static void gr_dfs_delete(struct gr_udc *dev)
217 debugfs_lookup_and_remove(dev_name(dev->dev), usb_debug_root);
222 static void gr_dfs_create(struct gr_udc *dev) {}
223 static void gr_dfs_delete(struct gr_udc *dev) {}
236 dma_desc = dma_pool_zalloc(ep->dev->desc_pool, gfp_flags, &paddr);
238 dev_err(ep->dev->dev, "Could not allocate from DMA pool\n");
247 static inline void gr_free_dma_desc(struct gr_udc *dev,
250 dma_pool_free(dev->desc_pool, desc, (dma_addr_t)desc->paddr);
254 static void gr_free_dma_desc_chain(struct gr_udc *dev, struct gr_request *req)
266 gr_free_dma_desc(dev, desc);
274 static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req);
280 * Must be called with dev->lock held and irqs disabled.
284 __releases(&dev->lock)
285 __acquires(&dev->lock)
287 struct gr_udc *dev;
296 dev = ep->dev;
297 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
298 gr_free_dma_desc_chain(dev, req);
314 dev_dbg(ep->dev->dev, "Overflow for ep %s\n",
330 if (req == dev->ep0reqo && !status) {
332 gr_ep0_setup(dev, req);
334 dev_err(dev->dev,
337 spin_unlock(&dev->lock);
341 spin_lock(&dev->lock);
362 * Must be called with dev->lock held and with !ep->stopped.
404 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
419 * Must be called with dev->lock held.
508 gr_free_dma_desc_chain(ep->dev, req);
570 gr_free_dma_desc_chain(ep->dev, req);
575 /* Must be called with dev->lock held */
578 struct gr_udc *dev = ep->dev;
582 dev_err(dev->dev, "No ep descriptor for %s\n", ep->ep.name);
587 dev_err(dev->dev,
593 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
594 dev_err(dev->dev, "-ESHUTDOWN");
599 if (dev->ep0state == GR_EP0_SUSPEND) {
600 dev_err(dev->dev, "-EBUSY");
605 ret = usb_gadget_map_request(&dev->gadget, &req->req, ep->is_in);
607 dev_err(dev->dev, "usb_gadget_map_request");
632 * Must be called with dev->lock held.
649 * Must be called with dev->lock held and irqs disabled.
668 * Must be called with dev->lock held.
684 * Must be called with dev->lock held.
686 static void gr_control_stall(struct gr_udc *dev)
690 epctrl = gr_read32(&dev->epo[0].regs->epctrl);
691 gr_write32(&dev->epo[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
692 epctrl = gr_read32(&dev->epi[0].regs->epctrl);
693 gr_write32(&dev->epi[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
695 dev->ep0state = GR_EP0_STALL;
701 * Must be called with dev->lock held.
718 gr_control_stall(ep->dev);
719 dev_dbg(ep->dev->dev, "EP: stall ep0\n");
725 dev_dbg(ep->dev->dev, "EP: %s halt %s\n",
748 /* Must be called with dev->lock held */
749 static inline void gr_set_ep0state(struct gr_udc *dev, enum gr_ep0state value)
751 if (dev->ep0state != value)
752 dev_vdbg(dev->dev, "STATE: ep0state=%s\n",
754 dev->ep0state = value;
760 * Must be called with dev->lock held.
762 static void gr_disable_interrupts_and_pullup(struct gr_udc *dev)
764 gr_write32(&dev->regs->control, 0);
766 dev->irq_enabled = 0;
772 * Must be called with dev->lock held and irqs disabled.
774 static void gr_stop_activity(struct gr_udc *dev)
778 list_for_each_entry(ep, &dev->ep_list, ep_list)
781 gr_disable_interrupts_and_pullup(dev);
783 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
784 usb_gadget_set_state(&dev->gadget, USB_STATE_NOTATTACHED);
794 struct gr_udc *dev;
798 dev = ep->dev;
800 spin_lock(&dev->lock);
802 control = gr_read32(&dev->regs->control);
803 control |= GR_CONTROL_TM | (dev->test_mode << GR_CONTROL_TS_POS);
804 gr_write32(&dev->regs->control, control);
806 spin_unlock(&dev->lock);
817 * Must be called with dev->lock held.
819 static int gr_ep0_respond(struct gr_udc *dev, u8 *buf, int length,
823 u8 *reqbuf = dev->ep0reqi->req.buf;
829 dev->ep0reqi->req.length = length;
830 dev->ep0reqi->req.complete = complete;
832 status = gr_queue_int(&dev->epi[0], dev->ep0reqi, GFP_ATOMIC);
834 dev_err(dev->dev,
843 * Must be called with dev->lock held.
845 static inline int gr_ep0_respond_u16(struct gr_udc *dev, u16 response)
849 return gr_ep0_respond(dev, (u8 *)&le_response, 2,
856 * Must be called with dev->lock held.
858 static inline int gr_ep0_respond_empty(struct gr_udc *dev)
860 return gr_ep0_respond(dev, NULL, 0, gr_ep0_dummy_complete);
868 * Must be called with dev->lock held.
870 static void gr_set_address(struct gr_udc *dev, u8 address)
874 control = gr_read32(&dev->regs->control) & ~GR_CONTROL_UA_MASK;
877 gr_write32(&dev->regs->control, control);
884 * Must be called with dev->lock held.
886 static int gr_device_request(struct gr_udc *dev, u8 type, u8 request,
894 dev_dbg(dev->dev, "STATUS: address %d\n", value & 0xff);
895 gr_set_address(dev, value & 0xff);
897 usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
899 usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
900 return gr_ep0_respond_empty(dev);
904 response = 0x0001 | (dev->remote_wakeup ? 0x0002 : 0);
905 return gr_ep0_respond_u16(dev, response);
911 dev->remote_wakeup = 1;
912 return gr_ep0_respond_empty(dev);
918 dev->test_mode = test;
919 return gr_ep0_respond(dev, NULL, 0,
929 dev->remote_wakeup = 0;
930 return gr_ep0_respond_empty(dev);
942 * Must be called with dev->lock held.
944 static int gr_interface_request(struct gr_udc *dev, u8 type, u8 request,
947 if (dev->gadget.state != USB_STATE_CONFIGURED)
958 return gr_ep0_respond_u16(dev, 0x0000);
976 * Must be called with dev->lock held.
978 static int gr_endpoint_request(struct gr_udc *dev, u8 type, u8 request,
987 if ((is_in && epnum >= dev->nepi) || (!is_in && epnum >= dev->nepo))
990 if (dev->gadget.state != USB_STATE_CONFIGURED && epnum != 0)
993 ep = (is_in ? &dev->epi[epnum] : &dev->epo[epnum]);
998 return gr_ep0_respond_u16(dev, halted ? 0x0001 : 0);
1005 status = gr_ep0_respond_empty(dev);
1017 status = gr_ep0_respond_empty(dev);
1026 /* Must be called with dev->lock held */
1027 static void gr_ep0out_requeue(struct gr_udc *dev)
1029 int ret = gr_queue_int(&dev->epo[0], dev->ep0reqo, GFP_ATOMIC);
1032 dev_err(dev->dev, "Could not queue ep0out setup request: %d\n",
1039 * Must be called with dev->lock held and irqs disabled
1041 static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req)
1042 __releases(&dev->lock)
1043 __acquires(&dev->lock)
1059 if (dev->ep0state == GR_EP0_STALL) {
1060 gr_set_ep0state(dev, GR_EP0_SETUP);
1065 if (dev->ep0state == GR_EP0_ISTATUS) {
1066 gr_set_ep0state(dev, GR_EP0_SETUP);
1068 dev_dbg(dev->dev,
1073 } else if (dev->ep0state != GR_EP0_SETUP) {
1074 dev_info(dev->dev,
1076 gr_ep0state_string(dev->ep0state));
1077 gr_control_stall(dev);
1078 gr_set_ep0state(dev, GR_EP0_SETUP);
1081 dev_dbg(dev->dev, "Unexpected ZLP at state %s\n",
1082 gr_ep0state_string(dev->ep0state));
1096 gr_dbgprint_devreq(dev, type, request, value, index, length);
1101 gr_set_ep0state(dev, GR_EP0_IDATA);
1103 gr_set_ep0state(dev, GR_EP0_ODATA);
1110 status = gr_device_request(dev, type, request,
1114 status = gr_endpoint_request(dev, type, request,
1118 status = gr_interface_request(dev, type, request,
1125 spin_unlock(&dev->lock);
1127 dev_vdbg(dev->dev, "DELEGATE\n");
1128 status = dev->driver->setup(&dev->gadget, &u.ctrl);
1130 spin_lock(&dev->lock);
1135 dev_vdbg(dev->dev, "STALL\n");
1136 gr_control_stall(dev);
1142 dev_dbg(dev->dev, "STATUS: deconfigured\n");
1143 usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
1146 dev_dbg(dev->dev, "STATUS: configured: %d\n", value);
1147 usb_gadget_set_state(&dev->gadget,
1153 if (dev->ep0state == GR_EP0_ODATA)
1154 gr_set_ep0state(dev, GR_EP0_OSTATUS);
1155 else if (dev->ep0state == GR_EP0_IDATA)
1156 gr_set_ep0state(dev, GR_EP0_ISTATUS);
1158 gr_set_ep0state(dev, GR_EP0_SETUP);
1161 gr_ep0out_requeue(dev);
1167 /* Must be called with dev->lock held and irqs disabled */
1168 static void gr_vbus_connected(struct gr_udc *dev, u32 status)
1172 dev->gadget.speed = GR_SPEED(status);
1173 usb_gadget_set_state(&dev->gadget, USB_STATE_POWERED);
1178 gr_write32(&dev->regs->control, control);
1181 /* Must be called with dev->lock held */
1182 static void gr_enable_vbus_detect(struct gr_udc *dev)
1186 dev->irq_enabled = 1;
1188 gr_write32(&dev->regs->control, GR_CONTROL_VI);
1191 status = gr_read32(&dev->regs->status);
1193 gr_vbus_connected(dev, status);
1196 /* Must be called with dev->lock held and irqs disabled */
1197 static void gr_vbus_disconnected(struct gr_udc *dev)
1199 gr_stop_activity(dev);
1202 if (dev->driver && dev->driver->disconnect) {
1203 spin_unlock(&dev->lock);
1205 dev->driver->disconnect(&dev->gadget);
1207 spin_lock(&dev->lock);
1210 gr_enable_vbus_detect(dev);
1213 /* Must be called with dev->lock held and irqs disabled */
1214 static void gr_udc_usbreset(struct gr_udc *dev, u32 status)
1216 gr_set_address(dev, 0);
1217 gr_set_ep0state(dev, GR_EP0_SETUP);
1218 usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
1219 dev->gadget.speed = GR_SPEED(status);
1221 gr_ep_nuke(&dev->epo[0]);
1222 gr_ep_nuke(&dev->epi[0]);
1223 dev->epo[0].stopped = 0;
1224 dev->epi[0].stopped = 0;
1225 gr_ep0out_requeue(dev);
1234 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
1259 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
1267 struct gr_udc *dev = ep->dev;
1286 if ((ep == &dev->epo[0]) && (dev->ep0state == GR_EP0_OSTATUS)) {
1291 * ep0_setup that can change dev->ep0state.
1293 gr_ep0_respond_empty(dev);
1294 gr_set_ep0state(dev, GR_EP0_SETUP);
1313 * Must be called with dev->lock held and irqs disabled.
1315 static int gr_handle_state_changes(struct gr_udc *dev)
1317 u32 status = gr_read32(&dev->regs->status);
1319 int powstate = !(dev->gadget.state == USB_STATE_NOTATTACHED ||
1320 dev->gadget.state == USB_STATE_ATTACHED);
1324 dev_dbg(dev->dev, "STATUS: vbus valid detected\n");
1325 gr_vbus_connected(dev, status);
1331 dev_dbg(dev->dev, "STATUS: vbus invalid detected\n");
1332 gr_vbus_disconnected(dev);
1338 dev_dbg(dev->dev, "STATUS: USB reset - speed is %s\n",
1340 gr_write32(&dev->regs->status, GR_STATUS_UR);
1341 gr_udc_usbreset(dev, status);
1346 if (dev->gadget.speed != GR_SPEED(status)) {
1347 dev_dbg(dev->dev, "STATUS: USB Speed change to %s\n",
1349 dev->gadget.speed = GR_SPEED(status);
1354 if ((dev->ep0state != GR_EP0_SUSPEND) && !(status & GR_STATUS_SU)) {
1355 dev_dbg(dev->dev, "STATUS: USB suspend\n");
1356 gr_set_ep0state(dev, GR_EP0_SUSPEND);
1357 dev->suspended_from = dev->gadget.state;
1358 usb_gadget_set_state(&dev->gadget, USB_STATE_SUSPENDED);
1360 if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
1361 dev->driver && dev->driver->suspend) {
1362 spin_unlock(&dev->lock);
1364 dev->driver->suspend(&dev->gadget);
1366 spin_lock(&dev->lock);
1372 if ((dev->ep0state == GR_EP0_SUSPEND) && (status & GR_STATUS_SU)) {
1373 dev_dbg(dev->dev, "STATUS: USB resume\n");
1374 if (dev->suspended_from == USB_STATE_POWERED)
1375 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
1377 gr_set_ep0state(dev, GR_EP0_SETUP);
1378 usb_gadget_set_state(&dev->gadget, dev->suspended_from);
1380 if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
1381 dev->driver && dev->driver->resume) {
1382 spin_unlock(&dev->lock);
1384 dev->driver->resume(&dev->gadget);
1386 spin_lock(&dev->lock);
1397 struct gr_udc *dev = _dev;
1403 spin_lock_irqsave(&dev->lock, flags);
1405 if (!dev->irq_enabled)
1413 for (i = 0; i < dev->nepi; i++) {
1414 ep = &dev->epi[i];
1420 for (i = 0; i < dev->nepo; i++) {
1421 ep = &dev->epo[i];
1427 handled = gr_handle_state_changes(dev) || handled;
1434 list_for_each_entry(ep, &dev->ep_list, ep_list) {
1436 dev_err(dev->dev,
1445 spin_unlock_irqrestore(&dev->lock, flags);
1453 struct gr_udc *dev = _dev;
1455 if (!dev->irq_enabled)
1468 struct gr_udc *dev;
1480 dev = ep->dev;
1483 if (ep == &dev->epo[0] || ep == &dev->epi[0])
1486 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
1499 if ((!ep->is_in && ep->num >= dev->nepo) ||
1500 (ep->is_in && ep->num >= dev->nepi))
1512 dev_err(dev->dev, "Unknown transfer type for %s\n",
1525 dev_err(dev->dev,
1530 dev_err(dev->dev,
1534 dev_err(dev->dev, "Hw buffer size %d < max payload %d * %d\n",
1538 dev_err(dev->dev, "Max payload cannot be set to 0\n");
1541 dev_err(dev->dev, "Requested max payload %d > limit %d\n",
1546 spin_lock(&ep->dev->lock);
1549 spin_unlock(&ep->dev->lock);
1591 spin_unlock(&ep->dev->lock);
1593 dev_dbg(ep->dev->dev, "EP: %s enabled - %s with %d bytes/buffer\n",
1602 struct gr_udc *dev;
1609 dev = ep->dev;
1612 if (ep == &dev->epo[0] || ep == &dev->epi[0])
1615 if (dev->ep0state == GR_EP0_SUSPEND)
1618 dev_dbg(ep->dev->dev, "EP: disable %s\n", ep->ep.name);
1620 spin_lock_irqsave(&dev->lock, flags);
1626 spin_unlock_irqrestore(&dev->lock, flags);
1656 struct gr_udc *dev;
1664 dev = ep->dev;
1666 spin_lock(&ep->dev->lock);
1674 if ((ep == &dev->epi[0]) && (dev->ep0state == GR_EP0_ODATA)) {
1675 ep = &dev->epo[0];
1676 ep->ep.driver_data = dev->epi[0].ep.driver_data;
1684 spin_unlock(&ep->dev->lock);
1694 struct gr_udc *dev;
1701 dev = ep->dev;
1702 if (!dev->driver)
1706 if (dev->ep0state == GR_EP0_SUSPEND)
1709 spin_lock_irqsave(&dev->lock, flags);
1738 spin_unlock_irqrestore(&dev->lock, flags);
1753 spin_lock(&ep->dev->lock);
1764 spin_unlock(&ep->dev->lock);
1815 dev_vdbg(ep->dev->dev, "EP: flush fifo %s\n", ep->ep.name);
1817 spin_lock(&ep->dev->lock);
1823 spin_unlock(&ep->dev->lock);
1847 struct gr_udc *dev;
1851 dev = container_of(_gadget, struct gr_udc, gadget);
1852 return gr_read32(&dev->regs->status) & GR_STATUS_FN_MASK;
1857 struct gr_udc *dev;
1861 dev = container_of(_gadget, struct gr_udc, gadget);
1864 if (!dev->remote_wakeup)
1867 spin_lock(&dev->lock);
1869 gr_write32(&dev->regs->control,
1870 gr_read32(&dev->regs->control) | GR_CONTROL_RW);
1872 spin_unlock(&dev->lock);
1879 struct gr_udc *dev;
1884 dev = container_of(_gadget, struct gr_udc, gadget);
1886 spin_lock(&dev->lock);
1888 control = gr_read32(&dev->regs->control);
1893 gr_write32(&dev->regs->control, control);
1895 spin_unlock(&dev->lock);
1903 struct gr_udc *dev = to_gr_udc(gadget);
1905 spin_lock(&dev->lock);
1908 dev->driver = driver;
1911 gr_enable_vbus_detect(dev);
1913 spin_unlock(&dev->lock);
1920 struct gr_udc *dev = to_gr_udc(gadget);
1923 spin_lock_irqsave(&dev->lock, flags);
1925 dev->driver = NULL;
1926 gr_stop_activity(dev);
1928 spin_unlock_irqrestore(&dev->lock, flags);
1957 /* Must be called with dev->lock held */
1958 static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit)
1966 ep = &dev->epi[num];
1968 ep->regs = &dev->regs->epi[num];
1970 ep = &dev->epo[num];
1972 ep->regs = &dev->regs->epo[num];
1978 ep->dev = dev;
1987 buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_ATOMIC);
1998 dev->ep0reqi = req; /* Complete gets set as used */
2000 dev->ep0reqo = req; /* Completion treated separately */
2008 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
2014 list_add_tail(&ep->ep_list, &dev->ep_list);
2021 ep->tailbuf = dma_alloc_coherent(dev->dev, ep->ep.maxpacket_limit,
2029 /* Must be called with dev->lock held */
2030 static int gr_udc_init(struct gr_udc *dev)
2032 struct device_node *np = dev->dev->of_node;
2039 gr_set_address(dev, 0);
2041 INIT_LIST_HEAD(&dev->gadget.ep_list);
2042 dev->gadget.speed = USB_SPEED_UNKNOWN;
2043 dev->gadget.ep0 = &dev->epi[0].ep;
2045 INIT_LIST_HEAD(&dev->ep_list);
2046 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
2048 for (i = 0; i < dev->nepo; i++) {
2051 ret = gr_ep_init(dev, i, 0, bufsize);
2056 for (i = 0; i < dev->nepi; i++) {
2059 ret = gr_ep_init(dev, i, 1, bufsize);
2065 dev->remote_wakeup = 0;
2070 gr_write32(&dev->epo[0].regs->epctrl, epctrl_val);
2071 gr_write32(&dev->epi[0].regs->epctrl, epctrl_val | GR_EPCTRL_PI);
2072 gr_write32(&dev->epo[0].regs->dmactrl, dmactrl_val);
2073 gr_write32(&dev->epi[0].regs->dmactrl, dmactrl_val);
2078 static void gr_ep_remove(struct gr_udc *dev, int num, int is_in)
2083 ep = &dev->epi[num];
2085 ep = &dev->epo[num];
2088 dma_free_coherent(dev->dev, ep->ep.maxpacket_limit,
2094 struct gr_udc *dev = platform_get_drvdata(pdev);
2097 if (dev->added)
2098 usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
2099 if (dev->driver)
2102 gr_dfs_delete(dev);
2103 dma_pool_destroy(dev->desc_pool);
2106 gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
2107 gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
2109 for (i = 0; i < dev->nepo; i++)
2110 gr_ep_remove(dev, i, 0);
2111 for (i = 0; i < dev->nepi; i++)
2112 gr_ep_remove(dev, i, 1);
2116 static int gr_request_irq(struct gr_udc *dev, int irq)
2118 return devm_request_threaded_irq(dev->dev, irq, gr_irq, gr_irq_handler,
2119 IRQF_SHARED, driver_name, dev);
2124 struct gr_udc *dev;
2129 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
2130 if (!dev)
2132 dev->dev = &pdev->dev;
2138 dev->irq = platform_get_irq(pdev, 0);
2139 if (dev->irq < 0)
2140 return dev->irq;
2143 dev->irqi = platform_get_irq(pdev, 1);
2144 if (dev->irqi > 0) {
2145 dev->irqo = platform_get_irq(pdev, 2);
2146 if (dev->irqo < 0)
2147 return dev->irqo;
2149 dev->irqi = 0;
2152 dev->gadget.name = driver_name;
2153 dev->gadget.max_speed = USB_SPEED_HIGH;
2154 dev->gadget.ops = &gr_ops;
2156 spin_lock_init(&dev->lock);
2157 dev->regs = regs;
2159 platform_set_drvdata(pdev, dev);
2162 status = gr_read32(&dev->regs->status);
2163 dev->nepi = ((status & GR_STATUS_NEPI_MASK) >> GR_STATUS_NEPI_POS) + 1;
2164 dev->nepo = ((status & GR_STATUS_NEPO_MASK) >> GR_STATUS_NEPO_POS) + 1;
2167 dev_err(dev->dev, "Slave mode cores are not supported\n");
2174 dev->desc_pool = dma_pool_create("desc_pool", dev->dev,
2176 if (!dev->desc_pool) {
2177 dev_err(dev->dev, "Could not allocate DMA pool");
2182 retval = usb_add_gadget_udc(dev->dev, &dev->gadget);
2184 dev_err(dev->dev, "Could not add gadget udc");
2187 dev->added = 1;
2189 spin_lock(&dev->lock);
2191 retval = gr_udc_init(dev);
2193 spin_unlock(&dev->lock);
2198 gr_disable_interrupts_and_pullup(dev);
2200 spin_unlock(&dev->lock);
2202 gr_dfs_create(dev);
2204 retval = gr_request_irq(dev, dev->irq);
2206 dev_err(dev->dev, "Failed to request irq %d\n", dev->irq);
2210 if (dev->irqi) {
2211 retval = gr_request_irq(dev, dev->irqi);
2213 dev_err(dev->dev, "Failed to request irqi %d\n",
2214 dev->irqi);
2217 retval = gr_request_irq(dev, dev->irqo);
2219 dev_err(dev->dev, "Failed to request irqo %d\n",
2220 dev->irqo);
2225 if (dev->irqi)
2226 dev_info(dev->dev, "regs: %p, irqs %d, %d, %d\n", dev->regs,
2227 dev->irq, dev->irqi, dev->irqo);
2229 dev_info(dev->dev, "regs: %p, irq %d\n", dev->regs, dev->irq);