1 /* 2 * drivers/usb/gadget/dwc2_udc_otg.c 3 * Designware DWC2 on-chip full/high speed USB OTG 2.0 device controllers 4 * 5 * Copyright (C) 2008 for Samsung Electronics 6 * 7 * BSP Support for Samsung's UDC driver 8 * available at: 9 * git://git.kernel.org/pub/scm/linux/kernel/git/kki_ap/linux-2.6-samsung.git 10 * 11 * State machine bugfixes: 12 * Marek Szyprowski <m.szyprowski@samsung.com> 13 * 14 * Ported to u-boot: 15 * Marek Szyprowski <m.szyprowski@samsung.com> 16 * Lukasz Majewski <l.majewski@samsumg.com> 17 * 18 * SPDX-License-Identifier: GPL-2.0+ 19 */ 20 #undef DEBUG 21 #include <common.h> 22 #include <clk.h> 23 #include <dm.h> 24 #include <generic-phy.h> 25 #include <malloc.h> 26 #include <reset.h> 27 28 #include <linux/errno.h> 29 #include <linux/list.h> 30 31 #include <linux/usb/ch9.h> 32 #include <linux/usb/otg.h> 33 #include <linux/usb/gadget.h> 34 35 #include <asm/byteorder.h> 36 #include <asm/unaligned.h> 37 #include <asm/io.h> 38 39 #include <asm/mach-types.h> 40 41 #include <power/regulator.h> 42 43 #include "dwc2_udc_otg_regs.h" 44 #include "dwc2_udc_otg_priv.h" 45 46 /***********************************************************/ 47 48 #define OTG_DMA_MODE 1 49 50 #define DEBUG_SETUP 0 51 #define DEBUG_EP0 0 52 #define DEBUG_ISR 0 53 #define DEBUG_OUT_EP 0 54 #define DEBUG_IN_EP 0 55 56 #include <usb/dwc2_udc.h> 57 58 #define EP0_CON 0 59 #define EP_MASK 0xF 60 61 static char *state_names[] = { 62 "WAIT_FOR_SETUP", 63 "DATA_STATE_XMIT", 64 "DATA_STATE_NEED_ZLP", 65 "WAIT_FOR_OUT_STATUS", 66 "DATA_STATE_RECV", 67 "WAIT_FOR_COMPLETE", 68 "WAIT_FOR_OUT_COMPLETE", 69 "WAIT_FOR_IN_COMPLETE", 70 "WAIT_FOR_NULL_COMPLETE", 71 }; 72 73 #define DRIVER_VERSION "15 March 2009" 74 75 struct dwc2_udc *the_controller; 76 77 static const char driver_name[] = "dwc2-udc"; 78 static const char ep0name[] = "ep0-control"; 79 80 /* Max packet size*/ 81 static unsigned int ep0_fifo_size = 64; 82 static unsigned int ep_fifo_size = 512; 83 static unsigned int ep_fifo_size2 = 1024; 84 static int reset_available = 1; 85 86 static struct usb_ctrlrequest *usb_ctrl; 87 static dma_addr_t usb_ctrl_dma_addr; 88 89 /* 90 Local declarations. 91 */ 92 static int dwc2_ep_enable(struct usb_ep *ep, 93 const struct usb_endpoint_descriptor *); 94 static int dwc2_ep_disable(struct usb_ep *ep); 95 static struct usb_request *dwc2_alloc_request(struct usb_ep *ep, 96 gfp_t gfp_flags); 97 static void dwc2_free_request(struct usb_ep *ep, struct usb_request *); 98 99 static int dwc2_queue(struct usb_ep *ep, struct usb_request *, gfp_t gfp_flags); 100 static int dwc2_dequeue(struct usb_ep *ep, struct usb_request *); 101 static int dwc2_fifo_status(struct usb_ep *ep); 102 static void dwc2_fifo_flush(struct usb_ep *ep); 103 static void dwc2_ep0_read(struct dwc2_udc *dev); 104 static void dwc2_ep0_kick(struct dwc2_udc *dev, struct dwc2_ep *ep); 105 static void dwc2_handle_ep0(struct dwc2_udc *dev); 106 static int dwc2_ep0_write(struct dwc2_udc *dev); 107 static int write_fifo_ep0(struct dwc2_ep *ep, struct dwc2_request *req); 108 static void done(struct dwc2_ep *ep, struct dwc2_request *req, int status); 109 static void stop_activity(struct dwc2_udc *dev, 110 struct usb_gadget_driver *driver); 111 static int udc_enable(struct dwc2_udc *dev); 112 static void udc_set_address(struct dwc2_udc *dev, unsigned char address); 113 static void reconfig_usbd(struct dwc2_udc *dev); 114 static void set_max_pktsize(struct dwc2_udc *dev, enum usb_device_speed speed); 115 static void nuke(struct dwc2_ep *ep, int status); 116 static int dwc2_udc_set_halt(struct usb_ep *_ep, int value); 117 static void dwc2_udc_set_nak(struct dwc2_ep *ep); 118 119 void set_udc_gadget_private_data(void *p) 120 { 121 debug_cond(DEBUG_SETUP != 0, 122 "%s: the_controller: 0x%p, p: 0x%p\n", __func__, 123 the_controller, p); 124 the_controller->gadget.dev.device_data = p; 125 } 126 127 void *get_udc_gadget_private_data(struct usb_gadget *gadget) 128 { 129 return gadget->dev.device_data; 130 } 131 132 static struct usb_ep_ops dwc2_ep_ops = { 133 .enable = dwc2_ep_enable, 134 .disable = dwc2_ep_disable, 135 136 .alloc_request = dwc2_alloc_request, 137 .free_request = dwc2_free_request, 138 139 .queue = dwc2_queue, 140 .dequeue = dwc2_dequeue, 141 142 .set_halt = dwc2_udc_set_halt, 143 .fifo_status = dwc2_fifo_status, 144 .fifo_flush = dwc2_fifo_flush, 145 }; 146 147 #define create_proc_files() do {} while (0) 148 #define remove_proc_files() do {} while (0) 149 150 /***********************************************************/ 151 152 struct dwc2_usbotg_reg *reg; 153 154 bool dfu_usb_get_reset(void) 155 { 156 return !!(readl(®->gintsts) & INT_RESET); 157 } 158 159 __weak void otg_phy_init(struct dwc2_udc *dev) {} 160 __weak void otg_phy_off(struct dwc2_udc *dev) {} 161 162 /***********************************************************/ 163 164 #include "dwc2_udc_otg_xfer_dma.c" 165 166 /* 167 * udc_disable - disable USB device controller 168 */ 169 static void udc_disable(struct dwc2_udc *dev) 170 { 171 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev); 172 173 udc_set_address(dev, 0); 174 175 dev->ep0state = WAIT_FOR_SETUP; 176 dev->gadget.speed = USB_SPEED_UNKNOWN; 177 dev->usb_address = 0; 178 dev->connected = 0; 179 180 otg_phy_off(dev); 181 } 182 183 /* 184 * udc_reinit - initialize software state 185 */ 186 static void udc_reinit(struct dwc2_udc *dev) 187 { 188 unsigned int i; 189 190 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev); 191 192 /* device/ep0 records init */ 193 INIT_LIST_HEAD(&dev->gadget.ep_list); 194 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 195 dev->ep0state = WAIT_FOR_SETUP; 196 197 /* basic endpoint records init */ 198 for (i = 0; i < DWC2_MAX_ENDPOINTS; i++) { 199 struct dwc2_ep *ep = &dev->ep[i]; 200 201 if (i != 0) 202 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list); 203 204 ep->desc = 0; 205 ep->stopped = 0; 206 INIT_LIST_HEAD(&ep->queue); 207 ep->pio_irqs = 0; 208 } 209 210 /* the rest was statically initialized, and is read-only */ 211 } 212 213 #define BYTES2MAXP(x) (x / 8) 214 #define MAXP2BYTES(x) (x * 8) 215 216 /* until it's enabled, this UDC should be completely invisible 217 * to any USB host. 218 */ 219 static int udc_enable(struct dwc2_udc *dev) 220 { 221 debug_cond(DEBUG_SETUP != 0, "%s: %p\n", __func__, dev); 222 223 otg_phy_init(dev); 224 reconfig_usbd(dev); 225 226 debug_cond(DEBUG_SETUP != 0, 227 "DWC2 USB 2.0 OTG Controller Core Initialized : 0x%x\n", 228 readl(®->gintmsk)); 229 230 dev->gadget.speed = USB_SPEED_UNKNOWN; 231 232 return 0; 233 } 234 235 #if !CONFIG_IS_ENABLED(DM_USB_GADGET) 236 /* 237 Register entry point for the peripheral controller driver. 238 */ 239 int usb_gadget_register_driver(struct usb_gadget_driver *driver) 240 { 241 struct dwc2_udc *dev = the_controller; 242 int retval = 0; 243 unsigned long flags = 0; 244 245 debug_cond(DEBUG_SETUP != 0, "%s: %s\n", __func__, "no name"); 246 247 if (!driver 248 || (driver->speed != USB_SPEED_FULL 249 && driver->speed != USB_SPEED_HIGH) 250 || !driver->bind || !driver->disconnect || !driver->setup) 251 return -EINVAL; 252 if (!dev) 253 return -ENODEV; 254 if (dev->driver) 255 return -EBUSY; 256 257 spin_lock_irqsave(&dev->lock, flags); 258 /* first hook up the driver ... */ 259 dev->driver = driver; 260 spin_unlock_irqrestore(&dev->lock, flags); 261 262 if (retval) { /* TODO */ 263 printf("target device_add failed, error %d\n", retval); 264 return retval; 265 } 266 267 retval = driver->bind(&dev->gadget); 268 if (retval) { 269 debug_cond(DEBUG_SETUP != 0, 270 "%s: bind to driver --> error %d\n", 271 dev->gadget.name, retval); 272 dev->driver = 0; 273 return retval; 274 } 275 276 enable_irq(IRQ_OTG); 277 278 debug_cond(DEBUG_SETUP != 0, 279 "Registered gadget driver %s\n", dev->gadget.name); 280 udc_enable(dev); 281 282 return 0; 283 } 284 285 /* 286 * Unregister entry point for the peripheral controller driver. 287 */ 288 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 289 { 290 struct dwc2_udc *dev = the_controller; 291 unsigned long flags = 0; 292 293 if (!dev) 294 return -ENODEV; 295 if (!driver || driver != dev->driver) 296 return -EINVAL; 297 298 spin_lock_irqsave(&dev->lock, flags); 299 dev->driver = 0; 300 stop_activity(dev, driver); 301 spin_unlock_irqrestore(&dev->lock, flags); 302 303 driver->unbind(&dev->gadget); 304 305 disable_irq(IRQ_OTG); 306 307 udc_disable(dev); 308 return 0; 309 } 310 #else /* !CONFIG_IS_ENABLED(DM_USB_GADGET) */ 311 312 static int dwc2_gadget_start(struct usb_gadget *g, 313 struct usb_gadget_driver *driver) 314 { 315 struct dwc2_udc *dev = the_controller; 316 317 debug_cond(DEBUG_SETUP != 0, "%s: %s\n", __func__, "no name"); 318 319 if (!driver || 320 (driver->speed != USB_SPEED_FULL && 321 driver->speed != USB_SPEED_HIGH) || 322 !driver->bind || !driver->disconnect || !driver->setup) 323 return -EINVAL; 324 325 if (!dev) 326 return -ENODEV; 327 328 if (dev->driver) 329 return -EBUSY; 330 331 /* first hook up the driver ... */ 332 dev->driver = driver; 333 334 debug_cond(DEBUG_SETUP != 0, 335 "Registered gadget driver %s\n", dev->gadget.name); 336 return udc_enable(dev); 337 } 338 339 static int dwc2_gadget_stop(struct usb_gadget *g) 340 { 341 struct dwc2_udc *dev = the_controller; 342 343 if (!dev) 344 return -ENODEV; 345 346 if (!dev->driver) 347 return -EINVAL; 348 349 dev->driver = 0; 350 stop_activity(dev, dev->driver); 351 352 udc_disable(dev); 353 354 return 0; 355 } 356 357 #endif /* !CONFIG_IS_ENABLED(DM_USB_GADGET) */ 358 359 /* 360 * done - retire a request; caller blocked irqs 361 */ 362 static void done(struct dwc2_ep *ep, struct dwc2_request *req, int status) 363 { 364 unsigned int stopped = ep->stopped; 365 366 debug("%s: %s %p, req = %p, stopped = %d\n", 367 __func__, ep->ep.name, ep, &req->req, stopped); 368 369 list_del_init(&req->queue); 370 371 if (likely(req->req.status == -EINPROGRESS)) 372 req->req.status = status; 373 else 374 status = req->req.status; 375 376 if (status && status != -ESHUTDOWN) { 377 debug("complete %s req %p stat %d len %u/%u\n", 378 ep->ep.name, &req->req, status, 379 req->req.actual, req->req.length); 380 } 381 382 /* don't modify queue heads during completion callback */ 383 ep->stopped = 1; 384 385 #ifdef DEBUG 386 printf("calling complete callback\n"); 387 { 388 int i, len = req->req.length; 389 390 printf("pkt[%d] = ", req->req.length); 391 if (len > 64) 392 len = 64; 393 for (i = 0; i < len; i++) { 394 printf("%02x", ((u8 *)req->req.buf)[i]); 395 if ((i & 7) == 7) 396 printf(" "); 397 } 398 printf("\n"); 399 } 400 #endif 401 spin_unlock(&ep->dev->lock); 402 req->req.complete(&ep->ep, &req->req); 403 spin_lock(&ep->dev->lock); 404 405 debug("callback completed\n"); 406 407 ep->stopped = stopped; 408 } 409 410 /* 411 * nuke - dequeue ALL requests 412 */ 413 static void nuke(struct dwc2_ep *ep, int status) 414 { 415 struct dwc2_request *req; 416 417 debug("%s: %s %p\n", __func__, ep->ep.name, ep); 418 419 /* called with irqs blocked */ 420 while (!list_empty(&ep->queue)) { 421 req = list_entry(ep->queue.next, struct dwc2_request, queue); 422 done(ep, req, status); 423 } 424 } 425 426 static void stop_activity(struct dwc2_udc *dev, 427 struct usb_gadget_driver *driver) 428 { 429 int i; 430 431 /* don't disconnect drivers more than once */ 432 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 433 driver = 0; 434 dev->gadget.speed = USB_SPEED_UNKNOWN; 435 436 /* prevent new request submissions, kill any outstanding requests */ 437 for (i = 0; i < DWC2_MAX_ENDPOINTS; i++) { 438 struct dwc2_ep *ep = &dev->ep[i]; 439 ep->stopped = 1; 440 nuke(ep, -ESHUTDOWN); 441 } 442 443 /* report disconnect; the driver is already quiesced */ 444 if (driver) { 445 spin_unlock(&dev->lock); 446 driver->disconnect(&dev->gadget); 447 spin_lock(&dev->lock); 448 } 449 450 /* re-init driver-visible data structures */ 451 udc_reinit(dev); 452 } 453 454 static void reconfig_usbd(struct dwc2_udc *dev) 455 { 456 /* 2. Soft-reset OTG Core and then unreset again. */ 457 int i; 458 unsigned int uTemp = writel(CORE_SOFT_RESET, ®->grstctl); 459 uint32_t dflt_gusbcfg; 460 uint32_t rx_fifo_sz, tx_fifo_sz, np_tx_fifo_sz; 461 462 debug("Reseting OTG controller\n"); 463 464 dflt_gusbcfg = 465 0<<15 /* PHY Low Power Clock sel*/ 466 |1<<14 /* Non-Periodic TxFIFO Rewind Enable*/ 467 |0x5<<10 /* Turnaround time*/ 468 |0<<9 | 0<<8 /* [0:HNP disable,1:HNP enable][ 0:SRP disable*/ 469 /* 1:SRP enable] H1= 1,1*/ 470 |0<<7 /* Ulpi DDR sel*/ 471 |0<<6 /* 0: high speed utmi+, 1: full speed serial*/ 472 |0<<4 /* 0: utmi+, 1:ulpi*/ 473 #ifdef CONFIG_USB_GADGET_DWC2_OTG_PHY_BUS_WIDTH_8 474 |0<<3 /* phy i/f 0:8bit, 1:16bit*/ 475 #else 476 |1<<3 /* phy i/f 0:8bit, 1:16bit*/ 477 #endif 478 |0x7<<0; /* HS/FS Timeout**/ 479 480 if (dev->pdata->usb_gusbcfg) 481 dflt_gusbcfg = dev->pdata->usb_gusbcfg; 482 483 writel(dflt_gusbcfg, ®->gusbcfg); 484 485 /* 3. Put the OTG device core in the disconnected state.*/ 486 uTemp = readl(®->dctl); 487 uTemp |= SOFT_DISCONNECT; 488 writel(uTemp, ®->dctl); 489 490 udelay(20); 491 492 /* 4. Make the OTG device core exit from the disconnected state.*/ 493 uTemp = readl(®->dctl); 494 uTemp = uTemp & ~SOFT_DISCONNECT; 495 writel(uTemp, ®->dctl); 496 497 /* 5. Configure OTG Core to initial settings of device mode.*/ 498 /* [][1: full speed(30Mhz) 0:high speed]*/ 499 writel(EP_MISS_CNT(1) | DEV_SPEED_HIGH_SPEED_20, ®->dcfg); 500 501 mdelay(1); 502 503 /* 6. Unmask the core interrupts*/ 504 writel(GINTMSK_INIT, ®->gintmsk); 505 506 /* 7. Set NAK bit of EP0, EP1, EP2*/ 507 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->out_endp[EP0_CON].doepctl); 508 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->in_endp[EP0_CON].diepctl); 509 510 for (i = 1; i < DWC2_MAX_ENDPOINTS; i++) { 511 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->out_endp[i].doepctl); 512 writel(DEPCTL_EPDIS|DEPCTL_SNAK, ®->in_endp[i].diepctl); 513 } 514 515 /* 8. Unmask EPO interrupts*/ 516 writel(((1 << EP0_CON) << DAINT_OUT_BIT) 517 | (1 << EP0_CON), ®->daintmsk); 518 519 /* 9. Unmask device OUT EP common interrupts*/ 520 writel(DOEPMSK_INIT, ®->doepmsk); 521 522 /* 10. Unmask device IN EP common interrupts*/ 523 writel(DIEPMSK_INIT, ®->diepmsk); 524 525 rx_fifo_sz = RX_FIFO_SIZE; 526 np_tx_fifo_sz = NPTX_FIFO_SIZE; 527 tx_fifo_sz = PTX_FIFO_SIZE; 528 529 if (dev->pdata->rx_fifo_sz) 530 rx_fifo_sz = dev->pdata->rx_fifo_sz; 531 if (dev->pdata->np_tx_fifo_sz) 532 np_tx_fifo_sz = dev->pdata->np_tx_fifo_sz; 533 if (dev->pdata->tx_fifo_sz) 534 tx_fifo_sz = dev->pdata->tx_fifo_sz; 535 536 /* 11. Set Rx FIFO Size (in 32-bit words) */ 537 writel(rx_fifo_sz, ®->grxfsiz); 538 539 /* 12. Set Non Periodic Tx FIFO Size */ 540 writel((np_tx_fifo_sz << 16) | rx_fifo_sz, 541 ®->gnptxfsiz); 542 543 for (i = 1; i < DWC2_MAX_HW_ENDPOINTS; i++) 544 writel((rx_fifo_sz + np_tx_fifo_sz + tx_fifo_sz*(i-1)) | 545 tx_fifo_sz << 16, ®->dieptxf[i-1]); 546 547 /* Flush the RX FIFO */ 548 writel(RX_FIFO_FLUSH, ®->grstctl); 549 while (readl(®->grstctl) & RX_FIFO_FLUSH) 550 debug("%s: waiting for DWC2_UDC_OTG_GRSTCTL\n", __func__); 551 552 /* Flush all the Tx FIFO's */ 553 writel(TX_FIFO_FLUSH_ALL, ®->grstctl); 554 writel(TX_FIFO_FLUSH_ALL | TX_FIFO_FLUSH, ®->grstctl); 555 while (readl(®->grstctl) & TX_FIFO_FLUSH) 556 debug("%s: waiting for DWC2_UDC_OTG_GRSTCTL\n", __func__); 557 558 /* 13. Clear NAK bit of EP0, EP1, EP2*/ 559 /* For Slave mode*/ 560 /* EP0: Control OUT */ 561 writel(DEPCTL_EPDIS | DEPCTL_CNAK, 562 ®->out_endp[EP0_CON].doepctl); 563 564 /* 14. Initialize OTG Link Core.*/ 565 writel(GAHBCFG_INIT, ®->gahbcfg); 566 } 567 568 static void set_max_pktsize(struct dwc2_udc *dev, enum usb_device_speed speed) 569 { 570 unsigned int ep_ctrl; 571 int i; 572 573 if (speed == USB_SPEED_HIGH) { 574 ep0_fifo_size = 64; 575 ep_fifo_size = 512; 576 ep_fifo_size2 = 1024; 577 dev->gadget.speed = USB_SPEED_HIGH; 578 } else { 579 ep0_fifo_size = 64; 580 ep_fifo_size = 64; 581 ep_fifo_size2 = 64; 582 dev->gadget.speed = USB_SPEED_FULL; 583 } 584 585 dev->ep[0].ep.maxpacket = ep0_fifo_size; 586 for (i = 1; i < DWC2_MAX_ENDPOINTS; i++) 587 dev->ep[i].ep.maxpacket = ep_fifo_size; 588 589 /* EP0 - Control IN (64 bytes)*/ 590 ep_ctrl = readl(®->in_endp[EP0_CON].diepctl); 591 writel(ep_ctrl|(0<<0), ®->in_endp[EP0_CON].diepctl); 592 593 /* EP0 - Control OUT (64 bytes)*/ 594 ep_ctrl = readl(®->out_endp[EP0_CON].doepctl); 595 writel(ep_ctrl|(0<<0), ®->out_endp[EP0_CON].doepctl); 596 } 597 598 static int dwc2_ep_enable(struct usb_ep *_ep, 599 const struct usb_endpoint_descriptor *desc) 600 { 601 struct dwc2_ep *ep; 602 struct dwc2_udc *dev; 603 unsigned long flags = 0; 604 605 debug("%s: %p\n", __func__, _ep); 606 607 ep = container_of(_ep, struct dwc2_ep, ep); 608 if (!_ep || !desc || ep->desc || _ep->name == ep0name 609 || desc->bDescriptorType != USB_DT_ENDPOINT 610 || ep->bEndpointAddress != desc->bEndpointAddress 611 || ep_maxpacket(ep) < 612 le16_to_cpu(get_unaligned(&desc->wMaxPacketSize))) { 613 614 debug("%s: bad ep or descriptor\n", __func__); 615 return -EINVAL; 616 } 617 618 /* xfer types must match, except that interrupt ~= bulk */ 619 if (ep->bmAttributes != desc->bmAttributes 620 && ep->bmAttributes != USB_ENDPOINT_XFER_BULK 621 && desc->bmAttributes != USB_ENDPOINT_XFER_INT) { 622 623 debug("%s: %s type mismatch\n", __func__, _ep->name); 624 return -EINVAL; 625 } 626 627 /* hardware _could_ do smaller, but driver doesn't */ 628 if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK && 629 le16_to_cpu(get_unaligned(&desc->wMaxPacketSize)) > 630 ep_maxpacket(ep)) || !get_unaligned(&desc->wMaxPacketSize)) { 631 632 debug("%s: bad %s maxpacket\n", __func__, _ep->name); 633 return -ERANGE; 634 } 635 636 dev = ep->dev; 637 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) { 638 639 debug("%s: bogus device state\n", __func__); 640 return -ESHUTDOWN; 641 } 642 643 ep->stopped = 0; 644 ep->desc = desc; 645 ep->pio_irqs = 0; 646 ep->ep.maxpacket = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize)); 647 648 /* Reset halt state */ 649 dwc2_udc_set_nak(ep); 650 dwc2_udc_set_halt(_ep, 0); 651 652 spin_lock_irqsave(&ep->dev->lock, flags); 653 dwc2_udc_ep_activate(ep); 654 spin_unlock_irqrestore(&ep->dev->lock, flags); 655 656 debug("%s: enabled %s, stopped = %d, maxpacket = %d\n", 657 __func__, _ep->name, ep->stopped, ep->ep.maxpacket); 658 return 0; 659 } 660 661 /* 662 * Disable EP 663 */ 664 static int dwc2_ep_disable(struct usb_ep *_ep) 665 { 666 struct dwc2_ep *ep; 667 unsigned long flags = 0; 668 669 debug("%s: %p\n", __func__, _ep); 670 671 ep = container_of(_ep, struct dwc2_ep, ep); 672 if (!_ep || !ep->desc) { 673 debug("%s: %s not enabled\n", __func__, 674 _ep ? ep->ep.name : NULL); 675 return -EINVAL; 676 } 677 678 spin_lock_irqsave(&ep->dev->lock, flags); 679 680 /* Nuke all pending requests */ 681 nuke(ep, -ESHUTDOWN); 682 683 ep->desc = 0; 684 ep->stopped = 1; 685 686 spin_unlock_irqrestore(&ep->dev->lock, flags); 687 688 debug("%s: disabled %s\n", __func__, _ep->name); 689 return 0; 690 } 691 692 static struct usb_request *dwc2_alloc_request(struct usb_ep *ep, 693 gfp_t gfp_flags) 694 { 695 struct dwc2_request *req; 696 697 debug("%s: %s %p\n", __func__, ep->name, ep); 698 699 req = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*req)); 700 if (!req) 701 return 0; 702 703 memset(req, 0, sizeof *req); 704 INIT_LIST_HEAD(&req->queue); 705 706 return &req->req; 707 } 708 709 static void dwc2_free_request(struct usb_ep *ep, struct usb_request *_req) 710 { 711 struct dwc2_request *req; 712 713 debug("%s: %p\n", __func__, ep); 714 715 req = container_of(_req, struct dwc2_request, req); 716 WARN_ON(!list_empty(&req->queue)); 717 kfree(req); 718 } 719 720 /* dequeue JUST ONE request */ 721 static int dwc2_dequeue(struct usb_ep *_ep, struct usb_request *_req) 722 { 723 struct dwc2_ep *ep; 724 struct dwc2_request *req; 725 unsigned long flags = 0; 726 727 debug("%s: %p\n", __func__, _ep); 728 729 ep = container_of(_ep, struct dwc2_ep, ep); 730 if (!_ep || ep->ep.name == ep0name) 731 return -EINVAL; 732 733 spin_lock_irqsave(&ep->dev->lock, flags); 734 735 /* make sure it's actually queued on this endpoint */ 736 list_for_each_entry(req, &ep->queue, queue) { 737 if (&req->req == _req) 738 break; 739 } 740 if (&req->req != _req) { 741 spin_unlock_irqrestore(&ep->dev->lock, flags); 742 return -EINVAL; 743 } 744 745 done(ep, req, -ECONNRESET); 746 747 spin_unlock_irqrestore(&ep->dev->lock, flags); 748 return 0; 749 } 750 751 /* 752 * Return bytes in EP FIFO 753 */ 754 static int dwc2_fifo_status(struct usb_ep *_ep) 755 { 756 int count = 0; 757 struct dwc2_ep *ep; 758 759 ep = container_of(_ep, struct dwc2_ep, ep); 760 if (!_ep) { 761 debug("%s: bad ep\n", __func__); 762 return -ENODEV; 763 } 764 765 debug("%s: %d\n", __func__, ep_index(ep)); 766 767 /* LPD can't report unclaimed bytes from IN fifos */ 768 if (ep_is_in(ep)) 769 return -EOPNOTSUPP; 770 771 return count; 772 } 773 774 /* 775 * Flush EP FIFO 776 */ 777 static void dwc2_fifo_flush(struct usb_ep *_ep) 778 { 779 struct dwc2_ep *ep; 780 781 ep = container_of(_ep, struct dwc2_ep, ep); 782 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) { 783 debug("%s: bad ep\n", __func__); 784 return; 785 } 786 787 debug("%s: %d\n", __func__, ep_index(ep)); 788 } 789 790 static const struct usb_gadget_ops dwc2_udc_ops = { 791 /* current versions must always be self-powered */ 792 #if CONFIG_IS_ENABLED(DM_USB_GADGET) 793 .udc_start = dwc2_gadget_start, 794 .udc_stop = dwc2_gadget_stop, 795 #endif 796 }; 797 798 static struct dwc2_udc memory = { 799 .usb_address = 0, 800 .gadget = { 801 .ops = &dwc2_udc_ops, 802 .ep0 = &memory.ep[0].ep, 803 .name = driver_name, 804 }, 805 806 /* control endpoint */ 807 .ep[0] = { 808 .ep = { 809 .name = ep0name, 810 .ops = &dwc2_ep_ops, 811 .maxpacket = EP0_FIFO_SIZE, 812 }, 813 .dev = &memory, 814 815 .bEndpointAddress = 0, 816 .bmAttributes = 0, 817 818 .ep_type = ep_control, 819 }, 820 821 /* first group of endpoints */ 822 .ep[1] = { 823 .ep = { 824 .name = "ep1in-bulk", 825 .ops = &dwc2_ep_ops, 826 .maxpacket = EP_FIFO_SIZE, 827 }, 828 .dev = &memory, 829 830 .bEndpointAddress = USB_DIR_IN | 1, 831 .bmAttributes = USB_ENDPOINT_XFER_BULK, 832 833 .ep_type = ep_bulk_out, 834 .fifo_num = 1, 835 }, 836 837 .ep[2] = { 838 .ep = { 839 .name = "ep2out-bulk", 840 .ops = &dwc2_ep_ops, 841 .maxpacket = EP_FIFO_SIZE, 842 }, 843 .dev = &memory, 844 845 .bEndpointAddress = USB_DIR_OUT | 2, 846 .bmAttributes = USB_ENDPOINT_XFER_BULK, 847 848 .ep_type = ep_bulk_in, 849 .fifo_num = 2, 850 }, 851 852 .ep[3] = { 853 .ep = { 854 .name = "ep3in-int", 855 .ops = &dwc2_ep_ops, 856 .maxpacket = EP_FIFO_SIZE, 857 }, 858 .dev = &memory, 859 860 .bEndpointAddress = USB_DIR_IN | 3, 861 .bmAttributes = USB_ENDPOINT_XFER_INT, 862 863 .ep_type = ep_interrupt, 864 .fifo_num = 3, 865 }, 866 }; 867 868 /* 869 * probe - binds to the platform device 870 */ 871 872 int dwc2_udc_probe(struct dwc2_plat_otg_data *pdata) 873 { 874 struct dwc2_udc *dev = &memory; 875 int retval = 0; 876 877 debug("%s: %p\n", __func__, pdata); 878 879 dev->pdata = pdata; 880 881 reg = (struct dwc2_usbotg_reg *)pdata->regs_otg; 882 883 dev->gadget.is_dualspeed = 1; /* Hack only*/ 884 dev->gadget.is_otg = 0; 885 dev->gadget.is_a_peripheral = 0; 886 dev->gadget.b_hnp_enable = 0; 887 dev->gadget.a_hnp_support = 0; 888 dev->gadget.a_alt_hnp_support = 0; 889 890 the_controller = dev; 891 892 usb_ctrl = memalign(CONFIG_SYS_CACHELINE_SIZE, 893 ROUND(sizeof(struct usb_ctrlrequest), 894 CONFIG_SYS_CACHELINE_SIZE)); 895 if (!usb_ctrl) { 896 pr_err("No memory available for UDC!\n"); 897 return -ENOMEM; 898 } 899 900 usb_ctrl_dma_addr = (dma_addr_t) usb_ctrl; 901 902 udc_reinit(dev); 903 904 return retval; 905 } 906 907 int dwc2_udc_handle_interrupt(void) 908 { 909 u32 intr_status = readl(®->gintsts); 910 u32 gintmsk = readl(®->gintmsk); 911 912 if (intr_status & gintmsk) 913 return dwc2_udc_irq(1, (void *)the_controller); 914 915 return 0; 916 } 917 918 #if !CONFIG_IS_ENABLED(DM_USB_GADGET) 919 920 int usb_gadget_handle_interrupts(int index) 921 { 922 return dwc2_udc_handle_interrupt(); 923 } 924 925 #else /* CONFIG_IS_ENABLED(DM_USB_GADGET) */ 926 927 struct dwc2_priv_data { 928 struct clk_bulk clks; 929 struct reset_ctl_bulk resets; 930 struct phy *phys; 931 int num_phys; 932 }; 933 934 int dm_usb_gadget_handle_interrupts(struct udevice *dev) 935 { 936 return dwc2_udc_handle_interrupt(); 937 } 938 939 int dwc2_phy_setup(struct udevice *dev, struct phy **array, int *num_phys) 940 { 941 int i, ret, count; 942 struct phy *usb_phys; 943 944 /* Return if no phy declared */ 945 if (!dev_read_prop(dev, "phys", NULL)) 946 return 0; 947 948 count = dev_count_phandle_with_args(dev, "phys", "#phy-cells"); 949 if (count <= 0) 950 return count; 951 952 usb_phys = devm_kcalloc(dev, count, sizeof(struct phy), 953 GFP_KERNEL); 954 if (!usb_phys) 955 return -ENOMEM; 956 957 for (i = 0; i < count; i++) { 958 ret = generic_phy_get_by_index(dev, i, &usb_phys[i]); 959 if (ret && ret != -ENOENT) { 960 dev_err(dev, "Failed to get USB PHY%d for %s\n", 961 i, dev->name); 962 return ret; 963 } 964 } 965 966 for (i = 0; i < count; i++) { 967 ret = generic_phy_init(&usb_phys[i]); 968 if (ret) { 969 dev_err(dev, "Can't init USB PHY%d for %s\n", 970 i, dev->name); 971 goto phys_init_err; 972 } 973 } 974 975 for (i = 0; i < count; i++) { 976 ret = generic_phy_power_on(&usb_phys[i]); 977 if (ret) { 978 dev_err(dev, "Can't power USB PHY%d for %s\n", 979 i, dev->name); 980 goto phys_poweron_err; 981 } 982 } 983 984 *array = usb_phys; 985 *num_phys = count; 986 987 return 0; 988 989 phys_poweron_err: 990 for (i = count - 1; i >= 0; i--) 991 generic_phy_power_off(&usb_phys[i]); 992 993 for (i = 0; i < count; i++) 994 generic_phy_exit(&usb_phys[i]); 995 996 return ret; 997 998 phys_init_err: 999 for (; i >= 0; i--) 1000 generic_phy_exit(&usb_phys[i]); 1001 1002 return ret; 1003 } 1004 1005 void dwc2_phy_shutdown(struct udevice *dev, struct phy *usb_phys, int num_phys) 1006 { 1007 int i, ret; 1008 1009 for (i = 0; i < num_phys; i++) { 1010 if (!generic_phy_valid(&usb_phys[i])) 1011 continue; 1012 1013 ret = generic_phy_power_off(&usb_phys[i]); 1014 ret |= generic_phy_exit(&usb_phys[i]); 1015 if (ret) { 1016 dev_err(dev, "Can't shutdown USB PHY%d for %s\n", 1017 i, dev->name); 1018 } 1019 } 1020 } 1021 1022 static int dwc2_udc_otg_ofdata_to_platdata(struct udevice *dev) 1023 { 1024 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev); 1025 int node = dev_of_offset(dev); 1026 1027 if (usb_get_dr_mode(node) != USB_DR_MODE_PERIPHERAL) { 1028 dev_dbg(dev, "Invalid mode\n"); 1029 return -ENODEV; 1030 } 1031 1032 platdata->regs_otg = dev_read_addr(dev); 1033 1034 platdata->rx_fifo_sz = dev_read_u32_default(dev, "g-rx-fifo-size", 0); 1035 platdata->np_tx_fifo_sz = dev_read_u32_default(dev, 1036 "g-np-tx-fifo-size", 0); 1037 platdata->tx_fifo_sz = dev_read_u32_default(dev, "g-tx-fifo-size", 0); 1038 1039 platdata->force_b_session_valid = 1040 dev_read_bool(dev, "force-b-session-valid"); 1041 1042 return 0; 1043 } 1044 1045 static int dwc2_udc_otg_reset_init(struct udevice *dev, 1046 struct reset_ctl_bulk *resets) 1047 { 1048 int ret; 1049 1050 ret = reset_get_bulk(dev, resets); 1051 if (ret == -ENOTSUPP) 1052 return 0; 1053 1054 if (ret) 1055 return ret; 1056 1057 ret = reset_assert_bulk(resets); 1058 1059 if (!ret) { 1060 udelay(2); 1061 ret = reset_deassert_bulk(resets); 1062 } 1063 if (ret) { 1064 reset_release_bulk(resets); 1065 return ret; 1066 } 1067 1068 return 0; 1069 } 1070 1071 static int dwc2_udc_otg_clk_init(struct udevice *dev, 1072 struct clk_bulk *clks) 1073 { 1074 int ret; 1075 1076 ret = clk_get_bulk(dev, clks); 1077 if (ret == -ENOSYS) 1078 return 0; 1079 1080 if (ret) 1081 return ret; 1082 1083 ret = clk_enable_bulk(clks); 1084 if (ret) { 1085 clk_release_bulk(clks); 1086 return ret; 1087 } 1088 1089 return 0; 1090 } 1091 1092 static int dwc2_udc_otg_probe(struct udevice *dev) 1093 { 1094 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev); 1095 struct dwc2_priv_data *priv = dev_get_priv(dev); 1096 struct dwc2_usbotg_reg *usbotg_reg = 1097 (struct dwc2_usbotg_reg *)platdata->regs_otg; 1098 int ret; 1099 1100 ret = dwc2_udc_otg_clk_init(dev, &priv->clks); 1101 if (ret) 1102 return ret; 1103 1104 ret = dwc2_udc_otg_reset_init(dev, &priv->resets); 1105 if (ret) 1106 return ret; 1107 1108 ret = dwc2_phy_setup(dev, &priv->phys, &priv->num_phys); 1109 if (ret) 1110 return ret; 1111 1112 if (platdata->force_b_session_valid) 1113 /* Override B session bits : value and enable */ 1114 setbits_le32(&usbotg_reg->gotgctl, B_VALOEN | B_VALOVAL); 1115 1116 ret = dwc2_udc_probe(platdata); 1117 if (ret) 1118 return ret; 1119 1120 the_controller->driver = 0; 1121 1122 ret = usb_add_gadget_udc((struct device *)dev, &the_controller->gadget); 1123 1124 return ret; 1125 } 1126 1127 static int dwc2_udc_otg_remove(struct udevice *dev) 1128 { 1129 struct dwc2_priv_data *priv = dev_get_priv(dev); 1130 1131 usb_del_gadget_udc(&the_controller->gadget); 1132 1133 reset_release_bulk(&priv->resets); 1134 1135 clk_release_bulk(&priv->clks); 1136 1137 dwc2_phy_shutdown(dev, priv->phys, priv->num_phys); 1138 1139 return dm_scan_fdt_dev(dev); 1140 } 1141 1142 static const struct udevice_id dwc2_udc_otg_ids[] = { 1143 { .compatible = "snps,dwc2" }, 1144 }; 1145 1146 U_BOOT_DRIVER(dwc2_udc_otg) = { 1147 .name = "dwc2-udc-otg", 1148 .id = UCLASS_USB_GADGET_GENERIC, 1149 .of_match = dwc2_udc_otg_ids, 1150 .ofdata_to_platdata = dwc2_udc_otg_ofdata_to_platdata, 1151 .probe = dwc2_udc_otg_probe, 1152 .remove = dwc2_udc_otg_remove, 1153 .platdata_auto_alloc_size = sizeof(struct dwc2_plat_otg_data), 1154 .priv_auto_alloc_size = sizeof(struct dwc2_priv_data), 1155 }; 1156 1157 int dwc2_udc_B_session_valid(struct udevice *dev) 1158 { 1159 struct dwc2_plat_otg_data *platdata = dev_get_platdata(dev); 1160 struct dwc2_usbotg_reg *usbotg_reg = 1161 (struct dwc2_usbotg_reg *)platdata->regs_otg; 1162 1163 return readl(&usbotg_reg->gotgctl) & B_SESSION_VALID; 1164 } 1165 #endif /* CONFIG_IS_ENABLED(DM_USB_GADGET) */ 1166