1 // SPDX-License-Identifier: GPL-2.0+
3 * drivers/usb/gadget/dwc2_udc_otg.c
4 * Designware DWC2 on-chip full/high speed USB OTG 2.0 device controllers
6 * Copyright (C) 2008 for Samsung Electronics
8 * BSP Support for Samsung's UDC driver
10 * git://git.kernel.org/pub/scm/linux/kernel/git/kki_ap/linux-2.6-samsung.git
12 * State machine bugfixes:
13 * Marek Szyprowski <m.szyprowski@samsung.com>
16 * Marek Szyprowski <m.szyprowski@samsung.com>
17 * Lukasz Majewski <l.majewski@samsumg.com>
23 #include <generic-phy.h>
27 #include <linux/errno.h>
28 #include <linux/list.h>
30 #include <linux/usb/ch9.h>
31 #include <linux/usb/otg.h>
32 #include <linux/usb/gadget.h>
34 #include <asm/byteorder.h>
35 #include <asm/unaligned.h>
38 #include <asm/mach-types.h>
40 #include <power/regulator.h>
42 #include "dwc2_udc_otg_regs.h"
43 #include "dwc2_udc_otg_priv.h"
45 /***********************************************************/
47 #define OTG_DMA_MODE 1
52 #define DEBUG_OUT_EP 0
55 #include <usb/dwc2_udc.h>
60 static char *state_names[] = {
63 "DATA_STATE_NEED_ZLP",
64 "WAIT_FOR_OUT_STATUS",
67 "WAIT_FOR_OUT_COMPLETE",
68 "WAIT_FOR_IN_COMPLETE",
69 "WAIT_FOR_NULL_COMPLETE",
72 #define DRIVER_VERSION "15 March 2009"
74 struct dwc2_udc *the_controller;
76 static const char driver_name[] = "dwc2-udc";
77 static const char ep0name[] = "ep0-control";
80 static unsigned int ep0_fifo_size = 64;
81 static unsigned int ep_fifo_size = 512;
82 static unsigned int ep_fifo_size2 = 1024;
83 static int reset_available = 1;
85 static struct usb_ctrlrequest *usb_ctrl;
86 static dma_addr_t usb_ctrl_dma_addr;
91 static int dwc2_ep_enable(struct usb_ep *ep,
92 const struct usb_endpoint_descriptor *);
93 static int dwc2_ep_disable(struct usb_ep *ep);
94 static struct usb_request *dwc2_alloc_request(struct usb_ep *ep,
96 static void dwc2_free_request(struct usb_ep *ep, struct usb_request *);
98 static int dwc2_queue(struct usb_ep *ep, struct usb_request *, gfp_t gfp_flags);
99 static int dwc2_dequeue(struct usb_ep *ep, struct usb_request *);
100 static int dwc2_fifo_status(struct usb_ep *ep);
101 static void dwc2_fifo_flush(struct usb_ep *ep);
102 static void dwc2_ep0_read(struct dwc2_udc *dev);
103 static void dwc2_ep0_kick(struct dwc2_udc *dev, struct dwc2_ep *ep);
104 static void dwc2_handle_ep0(struct dwc2_udc *dev);
105 static int dwc2_ep0_write(struct dwc2_udc *dev);
106 static int write_fifo_ep0(struct dwc2_ep *ep, struct dwc2_request *req);
107 static void done(struct dwc2_ep *ep, struct dwc2_request *req, int status);
108 static void stop_activity(struct dwc2_udc *dev,
109 struct usb_gadget_driver *driver);
110 static int udc_enable(struct dwc2_udc *dev);
111 static void udc_set_address(struct dwc2_udc *dev, unsigned char address);
112 static void reconfig_usbd(struct dwc2_udc *dev);
113 static void set_max_pktsize(struct dwc2_udc *dev, enum usb_device_speed speed);
114 static void nuke(struct dwc2_ep *ep, int status);
115 static int dwc2_udc_set_halt(struct usb_ep *_ep, int value);
116 static void dwc2_udc_set_nak(struct dwc2_ep *ep);
118 void set_udc_gadget_private_data(void *p)
120 debug_cond(DEBUG_SETUP != 0,
121 "%s: the_controller: 0x%p, p: 0x%p\n", __func__,
123 the_controller->gadget.dev.device_data = p;
126 void *get_udc_gadget_private_data(struct usb_gadget *gadget)
128 return gadget->dev.device_data;
131 static struct usb_ep_ops dwc2_ep_ops = {
132 .enable = dwc2_ep_enable,
133 .disable = dwc2_ep_disable,
135 .alloc_request = dwc2_alloc_request,
136 .free_request = dwc2_free_request,
139 .dequeue = dwc2_dequeue,
141 .set_halt = dwc2_udc_set_halt,
142 .fifo_status = dwc2_fifo_status,
143 .fifo_flush = dwc2_fifo_flush,
146 #define create_proc_files() do {} while (0)
147 #define remove_proc_files() do {} while (0)
149 /***********************************************************/
151 struct dwc2_usbotg_reg *reg;
153 bool dfu_usb_get_reset(void)
155 return !!(readl(®->gintsts) & INT_RESET);
158 __weak void otg_phy_init(struct dwc2_udc *dev) {}
159 __weak void otg_phy_off(struct dwc2_udc *dev) {}
161 /***********************************************************/
163 #include "dwc2_udc_otg_xfer_dma.c"
166 * udc_disable - disable USB device controller
168 static void udc_disable(struct dwc2_udc *dev)
170 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev);
172 udc_set_address(dev, 0);
174 dev->ep0state = WAIT_FOR_SETUP;
175 dev->gadget.speed = USB_SPEED_UNKNOWN;
176 dev->usb_address = 0;
182 * udc_reinit - initialize software state
184 static void udc_reinit(struct dwc2_udc *dev)
188 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev);
190 /* device/ep0 records init */
191 INIT_LIST_HEAD(&dev->gadget.ep_list);
192 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
193 dev->ep0state = WAIT_FOR_SETUP;
195 /* basic endpoint records init */
196 for (i = 0; i < DWC2_MAX_ENDPOINTS; i++) {
197 struct dwc2_ep *ep = &dev->ep[i];
200 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
204 INIT_LIST_HEAD(&ep->queue);
208 /* the rest was statically initialized, and is read-only */
211 #define BYTES2MAXP(x) (x / 8)
212 #define MAXP2BYTES(x) (x * 8)
214 /* until it's enabled, this UDC should be completely invisible
217 static int udc_enable(struct dwc2_udc *dev)
219 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev);
224 debug_cond(DEBUG_SETUP != 0,
225 "DWC2 USB 2.0 OTG Controller Core Initialized : 0x%x\n",
226 readl(®->gintmsk));
228 dev->gadget.speed = USB_SPEED_UNKNOWN;
233 #if !CONFIG_IS_ENABLED(DM_USB_GADGET)
235 Register entry point for the peripheral controller driver.
237 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
239 struct dwc2_udc *dev = the_controller;
241 unsigned long flags = 0;
243 debug_cond(DEBUG_SETUP != 0, "%s: %s\n", __func__, "no name");
246 || (driver->speed != USB_SPEED_FULL
247 && driver->speed != USB_SPEED_HIGH)
248 || !driver->bind || !driver->disconnect || !driver->setup)
255 spin_lock_irqsave(&dev->lock, flags);
256 /* first hook up the driver ... */
257 dev->driver = driver;
258 spin_unlock_irqrestore(&dev->lock, flags);
260 if (retval) { /* TODO */
261 printf("target device_add failed, error %d\n", retval);
265 retval = driver->bind(&dev->gadget);
267 debug_cond(DEBUG_SETUP != 0,
268 "%s: bind to driver --> error %d\n",
269 dev->gadget.name, retval);
276 debug_cond(DEBUG_SETUP != 0,
277 "Registered gadget driver %s\n", dev->gadget.name);
284 * Unregister entry point for the peripheral controller driver.
286 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
288 struct dwc2_udc *dev = the_controller;
289 unsigned long flags = 0;
293 if (!driver || driver != dev->driver)
296 spin_lock_irqsave(&dev->lock, flags);
298 stop_activity(dev, driver);
299 spin_unlock_irqrestore(&dev->lock, flags);
301 driver->unbind(&dev->gadget);
303 disable_irq(IRQ_OTG);
308 #else /* !CONFIG_IS_ENABLED(DM_USB_GADGET) */
310 static int dwc2_gadget_start(struct usb_gadget *g,
311 struct usb_gadget_driver *driver)
313 struct dwc2_udc *dev = the_controller;
315 debug_cond(DEBUG_SETUP != 0, "%s: %s\n", __func__, "no name");
318 (driver->speed != USB_SPEED_FULL &&
319 driver->speed != USB_SPEED_HIGH) ||
320 !driver->bind || !driver->disconnect || !driver->setup)
329 /* first hook up the driver ... */
330 dev->driver = driver;
332 debug_cond(DEBUG_SETUP != 0,
333 "Registered gadget driver %s\n", dev->gadget.name);
334 return udc_enable(dev);
337 static int dwc2_gadget_stop(struct usb_gadget *g)
339 struct dwc2_udc *dev = the_controller;
348 stop_activity(dev, dev->driver);
355 #endif /* !CONFIG_IS_ENABLED(DM_USB_GADGET) */
358 * done - retire a request; caller blocked irqs
360 static void done(struct dwc2_ep *ep, struct dwc2_request *req, int status)
362 unsigned int stopped = ep->stopped;
364 debug("%s: %s %p, req = %p, stopped = %d\n",
365 __func__, ep->ep.name, ep, &req->req, stopped);
367 list_del_init(&req->queue);
369 if (likely(req->req.status == -EINPROGRESS))
370 req->req.status = status;
372 status = req->req.status;
374 if (status && status != -ESHUTDOWN) {
375 debug("complete %s req %p stat %d len %u/%u\n",
376 ep->ep.name, &req->req, status,
377 req->req.actual, req->req.length);
380 /* don't modify queue heads during completion callback */
384 printf("calling complete callback\n");
386 int i, len = req->req.length;
388 printf("pkt[%d] = ", req->req.length);
391 for (i = 0; i < len; i++) {
392 printf("%02x", ((u8 *)req->req.buf)[i]);
399 spin_unlock(&ep->dev->lock);
400 req->req.complete(&ep->ep, &req->req);
401 spin_lock(&ep->dev->lock);
403 debug("callback completed\n");
405 ep->stopped = stopped;
409 * nuke - dequeue ALL requests
411 static void nuke(struct dwc2_ep *ep, int status)
413 struct dwc2_request *req;
415 debug("%s: %s %p\n", __func__, ep->ep.name, ep);
417 /* called with irqs blocked */
418 while (!list_empty(&ep->queue)) {
419 req = list_entry(ep->queue.next, struct dwc2_request, queue);
420 done(ep, req, status);
424 static void stop_activity(struct dwc2_udc *dev,
425 struct usb_gadget_driver *driver)
429 /* don't disconnect drivers more than once */
430 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
432 dev->gadget.speed = USB_SPEED_UNKNOWN;
434 /* prevent new request submissions, kill any outstanding requests */
435 for (i = 0; i < DWC2_MAX_ENDPOINTS; i++) {
436 struct dwc2_ep *ep = &dev->ep[i];
438 nuke(ep, -ESHUTDOWN);
441 /* report disconnect; the driver is already quiesced */
443 spin_unlock(&dev->lock);
444 driver->disconnect(&dev->gadget);
445 spin_lock(&dev->lock);
448 /* re-init driver-visible data structures */
452 static void reconfig_usbd(struct dwc2_udc *dev)
454 /* 2. Soft-reset OTG Core and then unreset again. */
456 unsigned int uTemp = writel(CORE_SOFT_RESET, ®->grstctl);
457 uint32_t dflt_gusbcfg;
458 uint32_t rx_fifo_sz, tx_fifo_sz, np_tx_fifo_sz;
461 debug("Reseting OTG controller\n");
464 0<<15 /* PHY Low Power Clock sel*/
465 |1<<14 /* Non-Periodic TxFIFO Rewind Enable*/
466 |0x5<<10 /* Turnaround time*/
467 |0<<9 | 0<<8 /* [0:HNP disable,1:HNP enable][ 0:SRP disable*/
468 /* 1:SRP enable] H1= 1,1*/
469 |0<<7 /* Ulpi DDR sel*/
470 |0<<6 /* 0: high speed utmi+, 1: full speed serial*/
471 |0<<4 /* 0: utmi+, 1:ulpi*/
472 #ifdef CONFIG_USB_GADGET_DWC2_OTG_PHY_BUS_WIDTH_8
473 |0<<3 /* phy i/f 0:8bit, 1:16bit*/
475 |1<<3 /* phy i/f 0:8bit, 1:16bit*/
477 |0x7<<0; /* HS/FS Timeout**/
479 if (dev->pdata->usb_gusbcfg)
480 dflt_gusbcfg = dev->pdata->usb_gusbcfg;
482 writel(dflt_gusbcfg, ®->gusbcfg);
484 /* 3. Put the OTG device core in the disconnected state.*/
485 uTemp = readl(®->dctl);
486 uTemp |= SOFT_DISCONNECT;
487 writel(uTemp, ®->dctl);
491 /* 4. Make the OTG device core exit from the disconnected state.*/
492 uTemp = readl(®->dctl);
493 uTemp = uTemp & ~SOFT_DISCONNECT;
494 writel(uTemp, ®->dctl);
496 /* 5. Configure OTG Core to initial settings of device mode.*/
497 /* [][1: full speed(30Mhz) 0:high speed]*/
498 writel(EP_MISS_CNT(1) | DEV_SPEED_HIGH_SPEED_20, ®->dcfg);
502 /* 6. Unmask the core interrupts*/
503 writel(GINTMSK_INIT, ®->gintmsk);
505 /* 7. Set NAK bit of EP0, EP1, EP2*/
506 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->out_endp[EP0_CON].doepctl);
507 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->in_endp[EP0_CON].diepctl);
509 for (i = 1; i < DWC2_MAX_ENDPOINTS; i++) {
510 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->out_endp[i].doepctl);
511 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->in_endp[i].diepctl);
514 /* 8. Unmask EPO interrupts*/
515 writel(((1 << EP0_CON) << DAINT_OUT_BIT)
516 | (1 << EP0_CON), ®->daintmsk);
518 /* 9. Unmask device OUT EP common interrupts*/
519 writel(DOEPMSK_INIT, ®->doepmsk);
521 /* 10. Unmask device IN EP common interrupts*/
522 writel(DIEPMSK_INIT, ®->diepmsk);
524 rx_fifo_sz = RX_FIFO_SIZE;
525 np_tx_fifo_sz = NPTX_FIFO_SIZE;
526 tx_fifo_sz = PTX_FIFO_SIZE;
528 if (dev->pdata->rx_fifo_sz)
529 rx_fifo_sz = dev->pdata->rx_fifo_sz;
530 if (dev->pdata->np_tx_fifo_sz)
531 np_tx_fifo_sz = dev->pdata->np_tx_fifo_sz;
532 if (dev->pdata->tx_fifo_sz)
533 tx_fifo_sz = dev->pdata->tx_fifo_sz;
535 /* 11. Set Rx FIFO Size (in 32-bit words) */
536 writel(rx_fifo_sz, ®->grxfsiz);
538 /* 12. Set Non Periodic Tx FIFO Size */
539 writel((np_tx_fifo_sz << 16) | rx_fifo_sz,
542 /* retrieve the number of IN Endpoints (excluding ep0) */
543 max_hw_ep = (readl(®->ghwcfg4) & GHWCFG4_NUM_IN_EPS_MASK) >>
544 GHWCFG4_NUM_IN_EPS_SHIFT;
546 for (i = 0; i < max_hw_ep; i++)
547 writel((rx_fifo_sz + np_tx_fifo_sz + (tx_fifo_sz * i)) |
548 tx_fifo_sz << 16, ®->dieptxf[i]);
550 /* Flush the RX FIFO */
551 writel(RX_FIFO_FLUSH, ®->grstctl);
552 while (readl(®->grstctl) & RX_FIFO_FLUSH)
553 debug("%s: waiting for DWC2_UDC_OTG_GRSTCTL\n", __func__);
555 /* Flush all the Tx FIFO's */
556 writel(TX_FIFO_FLUSH_ALL, ®->grstctl);
557 writel(TX_FIFO_FLUSH_ALL | TX_FIFO_FLUSH, ®->grstctl);
558 while (readl(®->grstctl) & TX_FIFO_FLUSH)
559 debug("%s: waiting for DWC2_UDC_OTG_GRSTCTL\n", __func__);
561 /* 13. Clear NAK bit of EP0, EP1, EP2*/
563 /* EP0: Control OUT */
564 writel(DEPCTL_EPDIS | DEPCTL_CNAK,
565 ®->out_endp[EP0_CON].doepctl);
567 /* 14. Initialize OTG Link Core.*/
568 writel(GAHBCFG_INIT, ®->gahbcfg);
571 static void set_max_pktsize(struct dwc2_udc *dev, enum usb_device_speed speed)
573 unsigned int ep_ctrl;
576 if (speed == USB_SPEED_HIGH) {
579 ep_fifo_size2 = 1024;
580 dev->gadget.speed = USB_SPEED_HIGH;
585 dev->gadget.speed = USB_SPEED_FULL;
588 dev->ep[0].ep.maxpacket = ep0_fifo_size;
589 for (i = 1; i < DWC2_MAX_ENDPOINTS; i++)
590 dev->ep[i].ep.maxpacket = ep_fifo_size;
592 /* EP0 - Control IN (64 bytes)*/
593 ep_ctrl = readl(®->in_endp[EP0_CON].diepctl);
594 writel(ep_ctrl|(0<<0), ®->in_endp[EP0_CON].diepctl);
596 /* EP0 - Control OUT (64 bytes)*/
597 ep_ctrl = readl(®->out_endp[EP0_CON].doepctl);
598 writel(ep_ctrl|(0<<0), ®->out_endp[EP0_CON].doepctl);
601 static int dwc2_ep_enable(struct usb_ep *_ep,
602 const struct usb_endpoint_descriptor *desc)
605 struct dwc2_udc *dev;
606 unsigned long flags = 0;
608 debug("%s: %p\n", __func__, _ep);
610 ep = container_of(_ep, struct dwc2_ep, ep);
611 if (!_ep || !desc || ep->desc || _ep->name == ep0name
612 || desc->bDescriptorType != USB_DT_ENDPOINT
613 || ep->bEndpointAddress != desc->bEndpointAddress
614 || ep_maxpacket(ep) <
615 le16_to_cpu(get_unaligned(&desc->wMaxPacketSize))) {
617 debug("%s: bad ep or descriptor\n", __func__);
621 /* xfer types must match, except that interrupt ~= bulk */
622 if (ep->bmAttributes != desc->bmAttributes
623 && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
624 && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
626 debug("%s: %s type mismatch\n", __func__, _ep->name);
630 /* hardware _could_ do smaller, but driver doesn't */
631 if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK &&
632 le16_to_cpu(get_unaligned(&desc->wMaxPacketSize)) >
633 ep_maxpacket(ep)) || !get_unaligned(&desc->wMaxPacketSize)) {
635 debug("%s: bad %s maxpacket\n", __func__, _ep->name);
640 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
642 debug("%s: bogus device state\n", __func__);
649 ep->ep.maxpacket = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
651 /* Reset halt state */
652 dwc2_udc_set_nak(ep);
653 dwc2_udc_set_halt(_ep, 0);
655 spin_lock_irqsave(&ep->dev->lock, flags);
656 dwc2_udc_ep_activate(ep);
657 spin_unlock_irqrestore(&ep->dev->lock, flags);
659 debug("%s: enabled %s, stopped = %d, maxpacket = %d\n",
660 __func__, _ep->name, ep->stopped, ep->ep.maxpacket);
667 static int dwc2_ep_disable(struct usb_ep *_ep)
670 unsigned long flags = 0;
672 debug("%s: %p\n", __func__, _ep);
674 ep = container_of(_ep, struct dwc2_ep, ep);
675 if (!_ep || !ep->desc) {
676 debug("%s: %s not enabled\n", __func__,
677 _ep ? ep->ep.name : NULL);
681 spin_lock_irqsave(&ep->dev->lock, flags);
683 /* Nuke all pending requests */
684 nuke(ep, -ESHUTDOWN);
689 spin_unlock_irqrestore(&ep->dev->lock, flags);
691 debug("%s: disabled %s\n", __func__, _ep->name);
695 static struct usb_request *dwc2_alloc_request(struct usb_ep *ep,
698 struct dwc2_request *req;
700 debug("%s: %s %p\n", __func__, ep->name, ep);
702 req = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*req));
706 memset(req, 0, sizeof *req);
707 INIT_LIST_HEAD(&req->queue);
712 static void dwc2_free_request(struct usb_ep *ep, struct usb_request *_req)
714 struct dwc2_request *req;
716 debug("%s: %p\n", __func__, ep);
718 req = container_of(_req, struct dwc2_request, req);
719 WARN_ON(!list_empty(&req->queue));
723 /* dequeue JUST ONE request */
724 static int dwc2_dequeue(struct usb_ep *_ep, struct usb_request *_req)
727 struct dwc2_request *req;
728 unsigned long flags = 0;
730 debug("%s: %p\n", __func__, _ep);
732 ep = container_of(_ep, struct dwc2_ep, ep);
733 if (!_ep || ep->ep.name == ep0name)
736 spin_lock_irqsave(&ep->dev->lock, flags);
738 /* make sure it's actually queued on this endpoint */
739 list_for_each_entry(req, &ep->queue, queue) {
740 if (&req->req == _req)
743 if (&req->req != _req) {
744 spin_unlock_irqrestore(&ep->dev->lock, flags);
748 done(ep, req, -ECONNRESET);
750 spin_unlock_irqrestore(&ep->dev->lock, flags);
755 * Return bytes in EP FIFO
757 static int dwc2_fifo_status(struct usb_ep *_ep)
762 ep = container_of(_ep, struct dwc2_ep, ep);
764 debug("%s: bad ep\n", __func__);
768 debug("%s: %d\n", __func__, ep_index(ep));
770 /* LPD can't report unclaimed bytes from IN fifos */
780 static void dwc2_fifo_flush(struct usb_ep *_ep)
784 ep = container_of(_ep, struct dwc2_ep, ep);
785 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
786 debug("%s: bad ep\n", __func__);
790 debug("%s: %d\n", __func__, ep_index(ep));
793 static const struct usb_gadget_ops dwc2_udc_ops = {
794 /* current versions must always be self-powered */
795 #if CONFIG_IS_ENABLED(DM_USB_GADGET)
796 .udc_start = dwc2_gadget_start,
797 .udc_stop = dwc2_gadget_stop,
801 static struct dwc2_udc memory = {
804 .ops = &dwc2_udc_ops,
805 .ep0 = &memory.ep[0].ep,
809 /* control endpoint */
814 .maxpacket = EP0_FIFO_SIZE,
818 .bEndpointAddress = 0,
821 .ep_type = ep_control,
824 /* first group of endpoints */
827 .name = "ep1in-bulk",
829 .maxpacket = EP_FIFO_SIZE,
833 .bEndpointAddress = USB_DIR_IN | 1,
834 .bmAttributes = USB_ENDPOINT_XFER_BULK,
836 .ep_type = ep_bulk_out,
842 .name = "ep2out-bulk",
844 .maxpacket = EP_FIFO_SIZE,
848 .bEndpointAddress = USB_DIR_OUT | 2,
849 .bmAttributes = USB_ENDPOINT_XFER_BULK,
851 .ep_type = ep_bulk_in,
859 .maxpacket = EP_FIFO_SIZE,
863 .bEndpointAddress = USB_DIR_IN | 3,
864 .bmAttributes = USB_ENDPOINT_XFER_INT,
866 .ep_type = ep_interrupt,
872 * probe - binds to the platform device
875 int dwc2_udc_probe(struct dwc2_plat_otg_data *pdata)
877 struct dwc2_udc *dev = &memory;
880 debug("%s: %p\n", __func__, pdata);
884 reg = (struct dwc2_usbotg_reg *)pdata->regs_otg;
886 dev->gadget.is_dualspeed = 1; /* Hack only*/
887 dev->gadget.is_otg = 0;
888 dev->gadget.is_a_peripheral = 0;
889 dev->gadget.b_hnp_enable = 0;
890 dev->gadget.a_hnp_support = 0;
891 dev->gadget.a_alt_hnp_support = 0;
893 the_controller = dev;
895 usb_ctrl = memalign(CONFIG_SYS_CACHELINE_SIZE,
896 ROUND(sizeof(struct usb_ctrlrequest),
897 CONFIG_SYS_CACHELINE_SIZE));
899 pr_err("No memory available for UDC!\n");
903 usb_ctrl_dma_addr = (dma_addr_t) usb_ctrl;
910 int dwc2_udc_handle_interrupt(void)
912 u32 intr_status = readl(®->gintsts);
913 u32 gintmsk = readl(®->gintmsk);
915 if (intr_status & gintmsk)
916 return dwc2_udc_irq(1, (void *)the_controller);
921 #if !CONFIG_IS_ENABLED(DM_USB_GADGET)
923 int usb_gadget_handle_interrupts(int index)
925 return dwc2_udc_handle_interrupt();
928 #else /* CONFIG_IS_ENABLED(DM_USB_GADGET) */
930 struct dwc2_priv_data {
931 struct clk_bulk clks;
932 struct reset_ctl_bulk resets;
937 int dm_usb_gadget_handle_interrupts(struct udevice *dev)
939 return dwc2_udc_handle_interrupt();
942 int dwc2_phy_setup(struct udevice *dev, struct phy **array, int *num_phys)
945 struct phy *usb_phys;
947 /* Return if no phy declared */
948 if (!dev_read_prop(dev, "phys", NULL))
951 count = dev_count_phandle_with_args(dev, "phys", "#phy-cells");
955 usb_phys = devm_kcalloc(dev, count, sizeof(struct phy),
960 for (i = 0; i < count; i++) {
961 ret = generic_phy_get_by_index(dev, i, &usb_phys[i]);
962 if (ret && ret != -ENOENT) {
963 dev_err(dev, "Failed to get USB PHY%d for %s\n",
969 for (i = 0; i < count; i++) {
970 ret = generic_phy_init(&usb_phys[i]);
972 dev_err(dev, "Can't init USB PHY%d for %s\n",
978 for (i = 0; i < count; i++) {
979 ret = generic_phy_power_on(&usb_phys[i]);
981 dev_err(dev, "Can't power USB PHY%d for %s\n",
983 goto phys_poweron_err;
993 for (i = count - 1; i >= 0; i--)
994 generic_phy_power_off(&usb_phys[i]);
996 for (i = 0; i < count; i++)
997 generic_phy_exit(&usb_phys[i]);
1003 generic_phy_exit(&usb_phys[i]);
1008 void dwc2_phy_shutdown(struct udevice *dev, struct phy *usb_phys, int num_phys)
1012 for (i = 0; i < num_phys; i++) {
1013 if (!generic_phy_valid(&usb_phys[i]))
1016 ret = generic_phy_power_off(&usb_phys[i]);
1017 ret |= generic_phy_exit(&usb_phys[i]);
1019 dev_err(dev, "Can't shutdown USB PHY%d for %s\n",
1025 static int dwc2_udc_otg_ofdata_to_platdata(struct udevice *dev)
1027 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev);
1028 int node = dev_of_offset(dev);
1030 if (usb_get_dr_mode(node) != USB_DR_MODE_PERIPHERAL) {
1031 dev_dbg(dev, "Invalid mode\n");
1035 platdata->regs_otg = dev_read_addr(dev);
1037 platdata->rx_fifo_sz = dev_read_u32_default(dev, "g-rx-fifo-size", 0);
1038 platdata->np_tx_fifo_sz = dev_read_u32_default(dev,
1039 "g-np-tx-fifo-size", 0);
1040 platdata->tx_fifo_sz = dev_read_u32_default(dev, "g-tx-fifo-size", 0);
1042 platdata->force_b_session_valid =
1043 dev_read_bool(dev, "force-b-session-valid");
1048 static int dwc2_udc_otg_reset_init(struct udevice *dev,
1049 struct reset_ctl_bulk *resets)
1053 ret = reset_get_bulk(dev, resets);
1054 if (ret == -ENOTSUPP)
1060 ret = reset_assert_bulk(resets);
1064 ret = reset_deassert_bulk(resets);
1067 reset_release_bulk(resets);
1074 static int dwc2_udc_otg_clk_init(struct udevice *dev,
1075 struct clk_bulk *clks)
1079 ret = clk_get_bulk(dev, clks);
1086 ret = clk_enable_bulk(clks);
1088 clk_release_bulk(clks);
1095 static int dwc2_udc_otg_probe(struct udevice *dev)
1097 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev);
1098 struct dwc2_priv_data *priv = dev_get_priv(dev);
1099 struct dwc2_usbotg_reg *usbotg_reg =
1100 (struct dwc2_usbotg_reg *)platdata->regs_otg;
1103 ret = dwc2_udc_otg_clk_init(dev, &priv->clks);
1107 ret = dwc2_udc_otg_reset_init(dev, &priv->resets);
1111 ret = dwc2_phy_setup(dev, &priv->phys, &priv->num_phys);
1115 if (platdata->force_b_session_valid)
1116 /* Override B session bits : value and enable */
1117 setbits_le32(&usbotg_reg->gotgctl, B_VALOEN | B_VALOVAL);
1119 ret = dwc2_udc_probe(platdata);
1123 the_controller->driver = 0;
1125 ret = usb_add_gadget_udc((struct device *)dev, &the_controller->gadget);
1130 static int dwc2_udc_otg_remove(struct udevice *dev)
1132 struct dwc2_priv_data *priv = dev_get_priv(dev);
1134 usb_del_gadget_udc(&the_controller->gadget);
1136 reset_release_bulk(&priv->resets);
1138 clk_release_bulk(&priv->clks);
1140 dwc2_phy_shutdown(dev, priv->phys, priv->num_phys);
1142 return dm_scan_fdt_dev(dev);
1145 static const struct udevice_id dwc2_udc_otg_ids[] = {
1146 { .compatible = "snps,dwc2" },
1149 U_BOOT_DRIVER(dwc2_udc_otg) = {
1150 .name = "dwc2-udc-otg",
1151 .id = UCLASS_USB_GADGET_GENERIC,
1152 .of_match = dwc2_udc_otg_ids,
1153 .ofdata_to_platdata = dwc2_udc_otg_ofdata_to_platdata,
1154 .probe = dwc2_udc_otg_probe,
1155 .remove = dwc2_udc_otg_remove,
1156 .platdata_auto_alloc_size = sizeof(struct dwc2_plat_otg_data),
1157 .priv_auto_alloc_size = sizeof(struct dwc2_priv_data),
1160 int dwc2_udc_B_session_valid(struct udevice *dev)
1162 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev);
1163 struct dwc2_usbotg_reg *usbotg_reg =
1164 (struct dwc2_usbotg_reg *)platdata->regs_otg;
1166 return readl(&usbotg_reg->gotgctl) & B_SESSION_VALID;
1168 #endif /* CONFIG_IS_ENABLED(DM_USB_GADGET) */