2 * Copyright (C) 2012 Oleksandr Tymoshenko <gonzo@freebsd.org>
3 * Copyright (C) 2014 Marek Vasut <marex@denx.de>
5 * SPDX-License-Identifier: GPL-2.0+
15 #include <usbroothubdes.h>
18 #include <power/regulator.h>
22 DECLARE_GLOBAL_DATA_PTR;
24 /* Use only HC channel 0. */
25 #define DWC2_HC_CHANNEL 0
27 #define DWC2_STATUS_BUF_SIZE 64
28 #define DWC2_DATA_BUF_SIZE (64 * 1024)
31 #define MAX_ENDPOINT 16
35 uint8_t aligned_buffer[DWC2_DATA_BUF_SIZE] __aligned(ARCH_DMA_MINALIGN);
36 uint8_t status_buffer[DWC2_STATUS_BUF_SIZE] __aligned(ARCH_DMA_MINALIGN);
38 uint8_t *aligned_buffer;
39 uint8_t *status_buffer;
41 u8 in_data_toggle[MAX_DEVICE][MAX_ENDPOINT];
42 u8 out_data_toggle[MAX_DEVICE][MAX_ENDPOINT];
43 struct dwc2_core_regs *regs;
51 /* We need cacheline-aligned buffers for DMA transfers and dcache support */
52 DEFINE_ALIGN_BUFFER(uint8_t, aligned_buffer_addr, DWC2_DATA_BUF_SIZE,
54 DEFINE_ALIGN_BUFFER(uint8_t, status_buffer_addr, DWC2_STATUS_BUF_SIZE,
57 static struct dwc2_priv local;
65 * Initializes the FSLSPClkSel field of the HCFG register
66 * depending on the PHY type.
68 static void init_fslspclksel(struct dwc2_core_regs *regs)
72 #if (CONFIG_DWC2_PHY_TYPE == DWC2_PHY_TYPE_FS)
73 phyclk = DWC2_HCFG_FSLSPCLKSEL_48_MHZ; /* Full speed PHY */
75 /* High speed PHY running at full speed or high speed */
76 phyclk = DWC2_HCFG_FSLSPCLKSEL_30_60_MHZ;
79 #ifdef CONFIG_DWC2_ULPI_FS_LS
80 uint32_t hwcfg2 = readl(®s->ghwcfg2);
81 uint32_t hval = (ghwcfg2 & DWC2_HWCFG2_HS_PHY_TYPE_MASK) >>
82 DWC2_HWCFG2_HS_PHY_TYPE_OFFSET;
83 uint32_t fval = (ghwcfg2 & DWC2_HWCFG2_FS_PHY_TYPE_MASK) >>
84 DWC2_HWCFG2_FS_PHY_TYPE_OFFSET;
86 if (hval == 2 && fval == 1)
87 phyclk = DWC2_HCFG_FSLSPCLKSEL_48_MHZ; /* Full speed PHY */
90 clrsetbits_le32(®s->host_regs.hcfg,
91 DWC2_HCFG_FSLSPCLKSEL_MASK,
92 phyclk << DWC2_HCFG_FSLSPCLKSEL_OFFSET);
98 * @param regs Programming view of DWC_otg controller.
99 * @param num Tx FIFO to flush.
101 static void dwc_otg_flush_tx_fifo(struct dwc2_core_regs *regs, const int num)
105 writel(DWC2_GRSTCTL_TXFFLSH | (num << DWC2_GRSTCTL_TXFNUM_OFFSET),
107 ret = wait_for_bit(__func__, ®s->grstctl, DWC2_GRSTCTL_TXFFLSH,
110 printf("%s: Timeout!\n", __func__);
112 /* Wait for 3 PHY Clocks */
119 * @param regs Programming view of DWC_otg controller.
121 static void dwc_otg_flush_rx_fifo(struct dwc2_core_regs *regs)
125 writel(DWC2_GRSTCTL_RXFFLSH, ®s->grstctl);
126 ret = wait_for_bit(__func__, ®s->grstctl, DWC2_GRSTCTL_RXFFLSH,
129 printf("%s: Timeout!\n", __func__);
131 /* Wait for 3 PHY Clocks */
136 * Do core a soft reset of the core. Be careful with this because it
137 * resets all the internal state machines of the core.
139 static void dwc_otg_core_reset(struct dwc2_core_regs *regs)
143 /* Wait for AHB master IDLE state. */
144 ret = wait_for_bit(__func__, ®s->grstctl, DWC2_GRSTCTL_AHBIDLE,
147 printf("%s: Timeout!\n", __func__);
149 /* Core Soft Reset */
150 writel(DWC2_GRSTCTL_CSFTRST, ®s->grstctl);
151 ret = wait_for_bit(__func__, ®s->grstctl, DWC2_GRSTCTL_CSFTRST,
154 printf("%s: Timeout!\n", __func__);
157 * Wait for core to come out of reset.
158 * NOTE: This long sleep is _very_ important, otherwise the core will
159 * not stay in host mode after a connector ID change!
164 #if defined(CONFIG_DM_USB) && defined(CONFIG_DM_REGULATOR)
165 static int dwc_vbus_supply_init(struct udevice *dev)
167 struct udevice *vbus_supply;
170 ret = device_get_supply_regulator(dev, "vbus-supply", &vbus_supply);
172 debug("%s: No vbus supply\n", dev->name);
176 ret = regulator_set_enable(vbus_supply, true);
178 error("Error enabling vbus supply\n");
185 static int dwc_vbus_supply_init(struct udevice *dev)
192 * This function initializes the DWC_otg controller registers for
195 * This function flushes the Tx and Rx FIFOs and it flushes any entries in the
196 * request queues. Host channels are reset to ensure that they are ready for
197 * performing transfers.
199 * @param dev USB Device (NULL if driver model is not being used)
200 * @param regs Programming view of DWC_otg controller
203 static void dwc_otg_core_host_init(struct udevice *dev,
204 struct dwc2_core_regs *regs)
206 uint32_t nptxfifosize = 0;
207 uint32_t ptxfifosize = 0;
209 int i, ret, num_channels;
211 /* Restart the Phy Clock */
212 writel(0, ®s->pcgcctl);
214 /* Initialize Host Configuration Register */
215 init_fslspclksel(regs);
216 #ifdef CONFIG_DWC2_DFLT_SPEED_FULL
217 setbits_le32(®s->host_regs.hcfg, DWC2_HCFG_FSLSSUPP);
220 /* Configure data FIFO sizes */
221 #ifdef CONFIG_DWC2_ENABLE_DYNAMIC_FIFO
222 if (readl(®s->ghwcfg2) & DWC2_HWCFG2_DYNAMIC_FIFO) {
224 writel(CONFIG_DWC2_HOST_RX_FIFO_SIZE, ®s->grxfsiz);
226 /* Non-periodic Tx FIFO */
227 nptxfifosize |= CONFIG_DWC2_HOST_NPERIO_TX_FIFO_SIZE <<
228 DWC2_FIFOSIZE_DEPTH_OFFSET;
229 nptxfifosize |= CONFIG_DWC2_HOST_RX_FIFO_SIZE <<
230 DWC2_FIFOSIZE_STARTADDR_OFFSET;
231 writel(nptxfifosize, ®s->gnptxfsiz);
233 /* Periodic Tx FIFO */
234 ptxfifosize |= CONFIG_DWC2_HOST_PERIO_TX_FIFO_SIZE <<
235 DWC2_FIFOSIZE_DEPTH_OFFSET;
236 ptxfifosize |= (CONFIG_DWC2_HOST_RX_FIFO_SIZE +
237 CONFIG_DWC2_HOST_NPERIO_TX_FIFO_SIZE) <<
238 DWC2_FIFOSIZE_STARTADDR_OFFSET;
239 writel(ptxfifosize, ®s->hptxfsiz);
243 /* Clear Host Set HNP Enable in the OTG Control Register */
244 clrbits_le32(®s->gotgctl, DWC2_GOTGCTL_HSTSETHNPEN);
246 /* Make sure the FIFOs are flushed. */
247 dwc_otg_flush_tx_fifo(regs, 0x10); /* All Tx FIFOs */
248 dwc_otg_flush_rx_fifo(regs);
250 /* Flush out any leftover queued requests. */
251 num_channels = readl(®s->ghwcfg2);
252 num_channels &= DWC2_HWCFG2_NUM_HOST_CHAN_MASK;
253 num_channels >>= DWC2_HWCFG2_NUM_HOST_CHAN_OFFSET;
256 for (i = 0; i < num_channels; i++)
257 clrsetbits_le32(®s->hc_regs[i].hcchar,
258 DWC2_HCCHAR_CHEN | DWC2_HCCHAR_EPDIR,
261 /* Halt all channels to put them into a known state. */
262 for (i = 0; i < num_channels; i++) {
263 clrsetbits_le32(®s->hc_regs[i].hcchar,
265 DWC2_HCCHAR_CHEN | DWC2_HCCHAR_CHDIS);
266 ret = wait_for_bit(__func__, ®s->hc_regs[i].hcchar,
267 DWC2_HCCHAR_CHEN, false, 1000, false);
269 printf("%s: Timeout!\n", __func__);
272 /* Turn on the vbus power. */
273 if (readl(®s->gintsts) & DWC2_GINTSTS_CURMODE_HOST) {
274 hprt0 = readl(®s->hprt0);
275 hprt0 &= ~(DWC2_HPRT0_PRTENA | DWC2_HPRT0_PRTCONNDET);
276 hprt0 &= ~(DWC2_HPRT0_PRTENCHNG | DWC2_HPRT0_PRTOVRCURRCHNG);
277 if (!(hprt0 & DWC2_HPRT0_PRTPWR)) {
278 hprt0 |= DWC2_HPRT0_PRTPWR;
279 writel(hprt0, ®s->hprt0);
284 dwc_vbus_supply_init(dev);
288 * This function initializes the DWC_otg controller registers and
289 * prepares the core for device mode or host mode operation.
291 * @param regs Programming view of the DWC_otg controller
293 static void dwc_otg_core_init(struct dwc2_priv *priv)
295 struct dwc2_core_regs *regs = priv->regs;
298 uint8_t brst_sz = CONFIG_DWC2_DMA_BURST_SIZE;
300 /* Common Initialization */
301 usbcfg = readl(®s->gusbcfg);
303 /* Program the ULPI External VBUS bit if needed */
304 if (priv->ext_vbus) {
305 usbcfg |= DWC2_GUSBCFG_ULPI_EXT_VBUS_DRV;
306 if (!priv->oc_disable) {
307 usbcfg |= DWC2_GUSBCFG_ULPI_INT_VBUS_INDICATOR |
308 DWC2_GUSBCFG_INDICATOR_PASSTHROUGH;
311 usbcfg &= ~DWC2_GUSBCFG_ULPI_EXT_VBUS_DRV;
314 /* Set external TS Dline pulsing */
315 #ifdef CONFIG_DWC2_TS_DLINE
316 usbcfg |= DWC2_GUSBCFG_TERM_SEL_DL_PULSE;
318 usbcfg &= ~DWC2_GUSBCFG_TERM_SEL_DL_PULSE;
320 writel(usbcfg, ®s->gusbcfg);
322 /* Reset the Controller */
323 dwc_otg_core_reset(regs);
326 * This programming sequence needs to happen in FS mode before
327 * any other programming occurs
329 #if defined(CONFIG_DWC2_DFLT_SPEED_FULL) && \
330 (CONFIG_DWC2_PHY_TYPE == DWC2_PHY_TYPE_FS)
331 /* If FS mode with FS PHY */
332 setbits_le32(®s->gusbcfg, DWC2_GUSBCFG_PHYSEL);
334 /* Reset after a PHY select */
335 dwc_otg_core_reset(regs);
338 * Program DCFG.DevSpd or HCFG.FSLSPclkSel to 48Mhz in FS.
339 * Also do this on HNP Dev/Host mode switches (done in dev_init
342 if (readl(®s->gintsts) & DWC2_GINTSTS_CURMODE_HOST)
343 init_fslspclksel(regs);
345 #ifdef CONFIG_DWC2_I2C_ENABLE
346 /* Program GUSBCFG.OtgUtmifsSel to I2C */
347 setbits_le32(®s->gusbcfg, DWC2_GUSBCFG_OTGUTMIFSSEL);
349 /* Program GI2CCTL.I2CEn */
350 clrsetbits_le32(®s->gi2cctl, DWC2_GI2CCTL_I2CEN |
351 DWC2_GI2CCTL_I2CDEVADDR_MASK,
352 1 << DWC2_GI2CCTL_I2CDEVADDR_OFFSET);
353 setbits_le32(®s->gi2cctl, DWC2_GI2CCTL_I2CEN);
357 /* High speed PHY. */
360 * HS PHY parameters. These parameters are preserved during
361 * soft reset so only program the first time. Do a soft reset
362 * immediately after setting phyif.
364 usbcfg &= ~(DWC2_GUSBCFG_ULPI_UTMI_SEL | DWC2_GUSBCFG_PHYIF);
365 usbcfg |= CONFIG_DWC2_PHY_TYPE << DWC2_GUSBCFG_ULPI_UTMI_SEL_OFFSET;
367 if (usbcfg & DWC2_GUSBCFG_ULPI_UTMI_SEL) { /* ULPI interface */
368 #ifdef CONFIG_DWC2_PHY_ULPI_DDR
369 usbcfg |= DWC2_GUSBCFG_DDRSEL;
371 usbcfg &= ~DWC2_GUSBCFG_DDRSEL;
373 } else { /* UTMI+ interface */
374 #if (CONFIG_DWC2_UTMI_PHY_WIDTH == 16)
375 usbcfg |= DWC2_GUSBCFG_PHYIF;
379 writel(usbcfg, ®s->gusbcfg);
381 /* Reset after setting the PHY parameters */
382 dwc_otg_core_reset(regs);
385 usbcfg = readl(®s->gusbcfg);
386 usbcfg &= ~(DWC2_GUSBCFG_ULPI_FSLS | DWC2_GUSBCFG_ULPI_CLK_SUS_M);
387 #ifdef CONFIG_DWC2_ULPI_FS_LS
388 uint32_t hwcfg2 = readl(®s->ghwcfg2);
389 uint32_t hval = (ghwcfg2 & DWC2_HWCFG2_HS_PHY_TYPE_MASK) >>
390 DWC2_HWCFG2_HS_PHY_TYPE_OFFSET;
391 uint32_t fval = (ghwcfg2 & DWC2_HWCFG2_FS_PHY_TYPE_MASK) >>
392 DWC2_HWCFG2_FS_PHY_TYPE_OFFSET;
393 if (hval == 2 && fval == 1) {
394 usbcfg |= DWC2_GUSBCFG_ULPI_FSLS;
395 usbcfg |= DWC2_GUSBCFG_ULPI_CLK_SUS_M;
398 if (priv->hnp_srp_disable)
399 usbcfg |= DWC2_GUSBCFG_FORCEHOSTMODE;
401 writel(usbcfg, ®s->gusbcfg);
403 /* Program the GAHBCFG Register. */
404 switch (readl(®s->ghwcfg2) & DWC2_HWCFG2_ARCHITECTURE_MASK) {
405 case DWC2_HWCFG2_ARCHITECTURE_SLAVE_ONLY:
407 case DWC2_HWCFG2_ARCHITECTURE_EXT_DMA:
408 while (brst_sz > 1) {
409 ahbcfg |= ahbcfg + (1 << DWC2_GAHBCFG_HBURSTLEN_OFFSET);
410 ahbcfg &= DWC2_GAHBCFG_HBURSTLEN_MASK;
414 #ifdef CONFIG_DWC2_DMA_ENABLE
415 ahbcfg |= DWC2_GAHBCFG_DMAENABLE;
419 case DWC2_HWCFG2_ARCHITECTURE_INT_DMA:
420 ahbcfg |= DWC2_GAHBCFG_HBURSTLEN_INCR4;
421 #ifdef CONFIG_DWC2_DMA_ENABLE
422 ahbcfg |= DWC2_GAHBCFG_DMAENABLE;
427 writel(ahbcfg, ®s->gahbcfg);
429 /* Program the capabilities in GUSBCFG Register */
432 if (!priv->hnp_srp_disable)
433 usbcfg |= DWC2_GUSBCFG_HNPCAP | DWC2_GUSBCFG_SRPCAP;
434 #ifdef CONFIG_DWC2_IC_USB_CAP
435 usbcfg |= DWC2_GUSBCFG_IC_USB_CAP;
438 setbits_le32(®s->gusbcfg, usbcfg);
442 * Prepares a host channel for transferring packets to/from a specific
443 * endpoint. The HCCHARn register is set up with the characteristics specified
444 * in _hc. Host channel interrupts that may need to be serviced while this
445 * transfer is in progress are enabled.
447 * @param regs Programming view of DWC_otg controller
448 * @param hc Information needed to initialize the host channel
450 static void dwc_otg_hc_init(struct dwc2_core_regs *regs, uint8_t hc_num,
451 struct usb_device *dev, uint8_t dev_addr, uint8_t ep_num,
452 uint8_t ep_is_in, uint8_t ep_type, uint16_t max_packet)
454 struct dwc2_hc_regs *hc_regs = ®s->hc_regs[hc_num];
455 uint32_t hcchar = (dev_addr << DWC2_HCCHAR_DEVADDR_OFFSET) |
456 (ep_num << DWC2_HCCHAR_EPNUM_OFFSET) |
457 (ep_is_in << DWC2_HCCHAR_EPDIR_OFFSET) |
458 (ep_type << DWC2_HCCHAR_EPTYPE_OFFSET) |
459 (max_packet << DWC2_HCCHAR_MPS_OFFSET);
461 if (dev->speed == USB_SPEED_LOW)
462 hcchar |= DWC2_HCCHAR_LSPDDEV;
465 * Program the HCCHARn register with the endpoint characteristics
466 * for the current transfer.
468 writel(hcchar, &hc_regs->hcchar);
470 /* Program the HCSPLIT register, default to no SPLIT */
471 writel(0, &hc_regs->hcsplt);
474 static void dwc_otg_hc_init_split(struct dwc2_hc_regs *hc_regs,
475 uint8_t hub_devnum, uint8_t hub_port)
479 hcsplt = DWC2_HCSPLT_SPLTENA;
480 hcsplt |= hub_devnum << DWC2_HCSPLT_HUBADDR_OFFSET;
481 hcsplt |= hub_port << DWC2_HCSPLT_PRTADDR_OFFSET;
483 /* Program the HCSPLIT register for SPLITs */
484 writel(hcsplt, &hc_regs->hcsplt);
488 * DWC2 to USB API interface
490 /* Direction: In ; Request: Status */
491 static int dwc_otg_submit_rh_msg_in_status(struct dwc2_core_regs *regs,
492 struct usb_device *dev, void *buffer,
493 int txlen, struct devrequest *cmd)
496 uint32_t port_status = 0;
497 uint32_t port_change = 0;
501 switch (cmd->requesttype & ~USB_DIR_IN) {
503 *(uint16_t *)buffer = cpu_to_le16(1);
506 case USB_RECIP_INTERFACE:
507 case USB_RECIP_ENDPOINT:
508 *(uint16_t *)buffer = cpu_to_le16(0);
512 *(uint32_t *)buffer = cpu_to_le32(0);
515 case USB_RECIP_OTHER | USB_TYPE_CLASS:
516 hprt0 = readl(®s->hprt0);
517 if (hprt0 & DWC2_HPRT0_PRTCONNSTS)
518 port_status |= USB_PORT_STAT_CONNECTION;
519 if (hprt0 & DWC2_HPRT0_PRTENA)
520 port_status |= USB_PORT_STAT_ENABLE;
521 if (hprt0 & DWC2_HPRT0_PRTSUSP)
522 port_status |= USB_PORT_STAT_SUSPEND;
523 if (hprt0 & DWC2_HPRT0_PRTOVRCURRACT)
524 port_status |= USB_PORT_STAT_OVERCURRENT;
525 if (hprt0 & DWC2_HPRT0_PRTRST)
526 port_status |= USB_PORT_STAT_RESET;
527 if (hprt0 & DWC2_HPRT0_PRTPWR)
528 port_status |= USB_PORT_STAT_POWER;
530 if ((hprt0 & DWC2_HPRT0_PRTSPD_MASK) == DWC2_HPRT0_PRTSPD_LOW)
531 port_status |= USB_PORT_STAT_LOW_SPEED;
532 else if ((hprt0 & DWC2_HPRT0_PRTSPD_MASK) ==
533 DWC2_HPRT0_PRTSPD_HIGH)
534 port_status |= USB_PORT_STAT_HIGH_SPEED;
536 if (hprt0 & DWC2_HPRT0_PRTENCHNG)
537 port_change |= USB_PORT_STAT_C_ENABLE;
538 if (hprt0 & DWC2_HPRT0_PRTCONNDET)
539 port_change |= USB_PORT_STAT_C_CONNECTION;
540 if (hprt0 & DWC2_HPRT0_PRTOVRCURRCHNG)
541 port_change |= USB_PORT_STAT_C_OVERCURRENT;
543 *(uint32_t *)buffer = cpu_to_le32(port_status |
544 (port_change << 16));
548 puts("unsupported root hub command\n");
549 stat = USB_ST_STALLED;
552 dev->act_len = min(len, txlen);
558 /* Direction: In ; Request: Descriptor */
559 static int dwc_otg_submit_rh_msg_in_descriptor(struct usb_device *dev,
560 void *buffer, int txlen,
561 struct devrequest *cmd)
563 unsigned char data[32];
567 uint16_t wValue = cpu_to_le16(cmd->value);
568 uint16_t wLength = cpu_to_le16(cmd->length);
570 switch (cmd->requesttype & ~USB_DIR_IN) {
572 switch (wValue & 0xff00) {
573 case 0x0100: /* device descriptor */
574 len = min3(txlen, (int)sizeof(root_hub_dev_des), (int)wLength);
575 memcpy(buffer, root_hub_dev_des, len);
577 case 0x0200: /* configuration descriptor */
578 len = min3(txlen, (int)sizeof(root_hub_config_des), (int)wLength);
579 memcpy(buffer, root_hub_config_des, len);
581 case 0x0300: /* string descriptors */
582 switch (wValue & 0xff) {
584 len = min3(txlen, (int)sizeof(root_hub_str_index0),
586 memcpy(buffer, root_hub_str_index0, len);
589 len = min3(txlen, (int)sizeof(root_hub_str_index1),
591 memcpy(buffer, root_hub_str_index1, len);
596 stat = USB_ST_STALLED;
601 /* Root port config, set 1 port and nothing else. */
604 data[0] = 9; /* min length; */
606 data[2] = dsc & RH_A_NDP;
612 else if (dsc & RH_A_OCPM)
615 /* corresponds to data[4-7] */
616 data[5] = (dsc & RH_A_POTPGT) >> 24;
617 data[7] = dsc & RH_B_DR;
622 data[8] = (dsc & RH_B_DR) >> 8;
627 len = min3(txlen, (int)data[0], (int)wLength);
628 memcpy(buffer, data, len);
631 puts("unsupported root hub command\n");
632 stat = USB_ST_STALLED;
635 dev->act_len = min(len, txlen);
641 /* Direction: In ; Request: Configuration */
642 static int dwc_otg_submit_rh_msg_in_configuration(struct usb_device *dev,
643 void *buffer, int txlen,
644 struct devrequest *cmd)
649 switch (cmd->requesttype & ~USB_DIR_IN) {
651 *(uint8_t *)buffer = 0x01;
655 puts("unsupported root hub command\n");
656 stat = USB_ST_STALLED;
659 dev->act_len = min(len, txlen);
666 static int dwc_otg_submit_rh_msg_in(struct dwc2_priv *priv,
667 struct usb_device *dev, void *buffer,
668 int txlen, struct devrequest *cmd)
670 switch (cmd->request) {
671 case USB_REQ_GET_STATUS:
672 return dwc_otg_submit_rh_msg_in_status(priv->regs, dev, buffer,
674 case USB_REQ_GET_DESCRIPTOR:
675 return dwc_otg_submit_rh_msg_in_descriptor(dev, buffer,
677 case USB_REQ_GET_CONFIGURATION:
678 return dwc_otg_submit_rh_msg_in_configuration(dev, buffer,
681 puts("unsupported root hub command\n");
682 return USB_ST_STALLED;
687 static int dwc_otg_submit_rh_msg_out(struct dwc2_priv *priv,
688 struct usb_device *dev,
689 void *buffer, int txlen,
690 struct devrequest *cmd)
692 struct dwc2_core_regs *regs = priv->regs;
695 uint16_t bmrtype_breq = cmd->requesttype | (cmd->request << 8);
696 uint16_t wValue = cpu_to_le16(cmd->value);
698 switch (bmrtype_breq & ~USB_DIR_IN) {
699 case (USB_REQ_CLEAR_FEATURE << 8) | USB_RECIP_ENDPOINT:
700 case (USB_REQ_CLEAR_FEATURE << 8) | USB_TYPE_CLASS:
703 case (USB_REQ_CLEAR_FEATURE << 8) | USB_RECIP_OTHER | USB_TYPE_CLASS:
705 case USB_PORT_FEAT_C_CONNECTION:
706 setbits_le32(®s->hprt0, DWC2_HPRT0_PRTCONNDET);
711 case (USB_REQ_SET_FEATURE << 8) | USB_RECIP_OTHER | USB_TYPE_CLASS:
713 case USB_PORT_FEAT_SUSPEND:
716 case USB_PORT_FEAT_RESET:
717 clrsetbits_le32(®s->hprt0, DWC2_HPRT0_PRTENA |
718 DWC2_HPRT0_PRTCONNDET |
719 DWC2_HPRT0_PRTENCHNG |
720 DWC2_HPRT0_PRTOVRCURRCHNG,
723 clrbits_le32(®s->hprt0, DWC2_HPRT0_PRTRST);
726 case USB_PORT_FEAT_POWER:
727 clrsetbits_le32(®s->hprt0, DWC2_HPRT0_PRTENA |
728 DWC2_HPRT0_PRTCONNDET |
729 DWC2_HPRT0_PRTENCHNG |
730 DWC2_HPRT0_PRTOVRCURRCHNG,
734 case USB_PORT_FEAT_ENABLE:
738 case (USB_REQ_SET_ADDRESS << 8):
739 priv->root_hub_devnum = wValue;
741 case (USB_REQ_SET_CONFIGURATION << 8):
744 puts("unsupported root hub command\n");
745 stat = USB_ST_STALLED;
748 len = min(len, txlen);
756 static int dwc_otg_submit_rh_msg(struct dwc2_priv *priv, struct usb_device *dev,
757 unsigned long pipe, void *buffer, int txlen,
758 struct devrequest *cmd)
762 if (usb_pipeint(pipe)) {
763 puts("Root-Hub submit IRQ: NOT implemented\n");
767 if (cmd->requesttype & USB_DIR_IN)
768 stat = dwc_otg_submit_rh_msg_in(priv, dev, buffer, txlen, cmd);
770 stat = dwc_otg_submit_rh_msg_out(priv, dev, buffer, txlen, cmd);
777 int wait_for_chhltd(struct dwc2_hc_regs *hc_regs, uint32_t *sub, u8 *toggle)
780 uint32_t hcint, hctsiz;
782 ret = wait_for_bit(__func__, &hc_regs->hcint, DWC2_HCINT_CHHLTD, true,
787 hcint = readl(&hc_regs->hcint);
788 hctsiz = readl(&hc_regs->hctsiz);
789 *sub = (hctsiz & DWC2_HCTSIZ_XFERSIZE_MASK) >>
790 DWC2_HCTSIZ_XFERSIZE_OFFSET;
791 *toggle = (hctsiz & DWC2_HCTSIZ_PID_MASK) >> DWC2_HCTSIZ_PID_OFFSET;
793 debug("%s: HCINT=%08x sub=%u toggle=%d\n", __func__, hcint, *sub,
796 if (hcint & DWC2_HCINT_XFERCOMP)
799 if (hcint & (DWC2_HCINT_NAK | DWC2_HCINT_FRMOVRUN))
802 debug("%s: Error (HCINT=%08x)\n", __func__, hcint);
806 static int dwc2_eptype[] = {
807 DWC2_HCCHAR_EPTYPE_ISOC,
808 DWC2_HCCHAR_EPTYPE_INTR,
809 DWC2_HCCHAR_EPTYPE_CONTROL,
810 DWC2_HCCHAR_EPTYPE_BULK,
813 static int transfer_chunk(struct dwc2_hc_regs *hc_regs, void *aligned_buffer,
814 u8 *pid, int in, void *buffer, int num_packets,
815 int xfer_len, int *actual_len, int odd_frame)
820 debug("%s: chunk: pid %d xfer_len %u pkts %u\n", __func__,
821 *pid, xfer_len, num_packets);
823 writel((xfer_len << DWC2_HCTSIZ_XFERSIZE_OFFSET) |
824 (num_packets << DWC2_HCTSIZ_PKTCNT_OFFSET) |
825 (*pid << DWC2_HCTSIZ_PID_OFFSET),
830 invalidate_dcache_range(
831 (uintptr_t)aligned_buffer,
832 (uintptr_t)aligned_buffer +
833 roundup(xfer_len, ARCH_DMA_MINALIGN));
835 memcpy(aligned_buffer, buffer, xfer_len);
837 (uintptr_t)aligned_buffer,
838 (uintptr_t)aligned_buffer +
839 roundup(xfer_len, ARCH_DMA_MINALIGN));
843 writel(phys_to_bus((unsigned long)aligned_buffer), &hc_regs->hcdma);
845 /* Clear old interrupt conditions for this host channel. */
846 writel(0x3fff, &hc_regs->hcint);
848 /* Set host channel enable after all other setup is complete. */
849 clrsetbits_le32(&hc_regs->hcchar, DWC2_HCCHAR_MULTICNT_MASK |
850 DWC2_HCCHAR_CHEN | DWC2_HCCHAR_CHDIS |
852 (1 << DWC2_HCCHAR_MULTICNT_OFFSET) |
853 (odd_frame << DWC2_HCCHAR_ODDFRM_OFFSET) |
856 ret = wait_for_chhltd(hc_regs, &sub, pid);
863 invalidate_dcache_range((unsigned long)aligned_buffer,
864 (unsigned long)aligned_buffer +
865 roundup(xfer_len, ARCH_DMA_MINALIGN));
867 memcpy(buffer, aligned_buffer, xfer_len);
869 *actual_len = xfer_len;
874 int chunk_msg(struct dwc2_priv *priv, struct usb_device *dev,
875 unsigned long pipe, u8 *pid, int in, void *buffer, int len)
877 struct dwc2_core_regs *regs = priv->regs;
878 struct dwc2_hc_regs *hc_regs = ®s->hc_regs[DWC2_HC_CHANNEL];
879 struct dwc2_host_regs *host_regs = ®s->host_regs;
880 int devnum = usb_pipedevice(pipe);
881 int ep = usb_pipeendpoint(pipe);
882 int max = usb_maxpacket(dev, pipe);
883 int eptype = dwc2_eptype[usb_pipetype(pipe)];
887 int complete_split = 0;
889 uint32_t num_packets;
890 int stop_transfer = 0;
891 uint32_t max_xfer_len;
892 int ssplit_frame_num = 0;
894 debug("%s: msg: pipe %lx pid %d in %d len %d\n", __func__, pipe, *pid,
897 max_xfer_len = CONFIG_DWC2_MAX_PACKET_COUNT * max;
898 if (max_xfer_len > CONFIG_DWC2_MAX_TRANSFER_SIZE)
899 max_xfer_len = CONFIG_DWC2_MAX_TRANSFER_SIZE;
900 if (max_xfer_len > DWC2_DATA_BUF_SIZE)
901 max_xfer_len = DWC2_DATA_BUF_SIZE;
903 /* Make sure that max_xfer_len is a multiple of max packet size. */
904 num_packets = max_xfer_len / max;
905 max_xfer_len = num_packets * max;
907 /* Initialize channel */
908 dwc_otg_hc_init(regs, DWC2_HC_CHANNEL, dev, devnum, ep, in,
911 /* Check if the target is a FS/LS device behind a HS hub */
912 if (dev->speed != USB_SPEED_HIGH) {
915 uint32_t hprt0 = readl(®s->hprt0);
916 if ((hprt0 & DWC2_HPRT0_PRTSPD_MASK) ==
917 DWC2_HPRT0_PRTSPD_HIGH) {
918 usb_find_usb2_hub_address_port(dev, &hub_addr,
920 dwc_otg_hc_init_split(hc_regs, hub_addr, hub_port);
932 xfer_len = len - done;
934 if (xfer_len > max_xfer_len)
935 xfer_len = max_xfer_len;
936 else if (xfer_len > max)
937 num_packets = (xfer_len + max - 1) / max;
942 setbits_le32(&hc_regs->hcsplt, DWC2_HCSPLT_COMPSPLT);
944 clrbits_le32(&hc_regs->hcsplt, DWC2_HCSPLT_COMPSPLT);
946 if (eptype == DWC2_HCCHAR_EPTYPE_INTR) {
947 int uframe_num = readl(&host_regs->hfnum);
948 if (!(uframe_num & 0x1))
952 ret = transfer_chunk(hc_regs, priv->aligned_buffer, pid,
953 in, (char *)buffer + done, num_packets,
954 xfer_len, &actual_len, odd_frame);
956 hcint = readl(&hc_regs->hcint);
957 if (complete_split) {
959 if (hcint & DWC2_HCINT_NYET) {
961 int frame_num = DWC2_HFNUM_MAX_FRNUM &
962 readl(&host_regs->hfnum);
963 if (((frame_num - ssplit_frame_num) &
964 DWC2_HFNUM_MAX_FRNUM) > 4)
968 } else if (do_split) {
969 if (hcint & DWC2_HCINT_ACK) {
970 ssplit_frame_num = DWC2_HFNUM_MAX_FRNUM &
971 readl(&host_regs->hfnum);
980 if (actual_len < xfer_len)
985 /* Transactions are done when when either all data is transferred or
986 * there is a short transfer. In case of a SPLIT make sure the CSPLIT
989 } while (((done < len) && !stop_transfer) || complete_split);
991 writel(0, &hc_regs->hcintmsk);
992 writel(0xFFFFFFFF, &hc_regs->hcint);
1000 /* U-Boot USB transmission interface */
1001 int _submit_bulk_msg(struct dwc2_priv *priv, struct usb_device *dev,
1002 unsigned long pipe, void *buffer, int len)
1004 int devnum = usb_pipedevice(pipe);
1005 int ep = usb_pipeendpoint(pipe);
1008 if ((devnum >= MAX_DEVICE) || (devnum == priv->root_hub_devnum)) {
1013 if (usb_pipein(pipe))
1014 pid = &priv->in_data_toggle[devnum][ep];
1016 pid = &priv->out_data_toggle[devnum][ep];
1018 return chunk_msg(priv, dev, pipe, pid, usb_pipein(pipe), buffer, len);
1021 static int _submit_control_msg(struct dwc2_priv *priv, struct usb_device *dev,
1022 unsigned long pipe, void *buffer, int len,
1023 struct devrequest *setup)
1025 int devnum = usb_pipedevice(pipe);
1028 /* For CONTROL endpoint pid should start with DATA1 */
1029 int status_direction;
1031 if (devnum == priv->root_hub_devnum) {
1033 dev->speed = USB_SPEED_HIGH;
1034 return dwc_otg_submit_rh_msg(priv, dev, pipe, buffer, len,
1039 pid = DWC2_HC_PID_SETUP;
1041 ret = chunk_msg(priv, dev, pipe, &pid, 0, setup, 8);
1042 } while (ret == -EAGAIN);
1049 pid = DWC2_HC_PID_DATA1;
1051 ret = chunk_msg(priv, dev, pipe, &pid, usb_pipein(pipe),
1053 act_len += dev->act_len;
1054 buffer += dev->act_len;
1055 len -= dev->act_len;
1056 } while (ret == -EAGAIN);
1059 status_direction = usb_pipeout(pipe);
1061 /* No-data CONTROL always ends with an IN transaction */
1062 status_direction = 1;
1066 pid = DWC2_HC_PID_DATA1;
1068 ret = chunk_msg(priv, dev, pipe, &pid, status_direction,
1069 priv->status_buffer, 0);
1070 } while (ret == -EAGAIN);
1074 dev->act_len = act_len;
1079 int _submit_int_msg(struct dwc2_priv *priv, struct usb_device *dev,
1080 unsigned long pipe, void *buffer, int len, int interval)
1082 unsigned long timeout;
1085 /* FIXME: what is interval? */
1087 timeout = get_timer(0) + USB_TIMEOUT_MS(pipe);
1089 if (get_timer(0) > timeout) {
1090 printf("Timeout poll on interrupt endpoint\n");
1093 ret = _submit_bulk_msg(priv, dev, pipe, buffer, len);
1099 static int dwc2_init_common(struct udevice *dev, struct dwc2_priv *priv)
1101 struct dwc2_core_regs *regs = priv->regs;
1105 snpsid = readl(®s->gsnpsid);
1106 printf("Core Release: %x.%03x\n", snpsid >> 12 & 0xf, snpsid & 0xfff);
1108 if ((snpsid & DWC2_SNPSID_DEVID_MASK) != DWC2_SNPSID_DEVID_VER_2xx &&
1109 (snpsid & DWC2_SNPSID_DEVID_MASK) != DWC2_SNPSID_DEVID_VER_3xx) {
1110 printf("SNPSID invalid (not DWC2 OTG device): %08x\n", snpsid);
1114 #ifdef CONFIG_DWC2_PHY_ULPI_EXT_VBUS
1120 dwc_otg_core_init(priv);
1121 dwc_otg_core_host_init(dev, regs);
1123 clrsetbits_le32(®s->hprt0, DWC2_HPRT0_PRTENA |
1124 DWC2_HPRT0_PRTCONNDET | DWC2_HPRT0_PRTENCHNG |
1125 DWC2_HPRT0_PRTOVRCURRCHNG,
1128 clrbits_le32(®s->hprt0, DWC2_HPRT0_PRTENA | DWC2_HPRT0_PRTCONNDET |
1129 DWC2_HPRT0_PRTENCHNG | DWC2_HPRT0_PRTOVRCURRCHNG |
1132 for (i = 0; i < MAX_DEVICE; i++) {
1133 for (j = 0; j < MAX_ENDPOINT; j++) {
1134 priv->in_data_toggle[i][j] = DWC2_HC_PID_DATA0;
1135 priv->out_data_toggle[i][j] = DWC2_HC_PID_DATA0;
1140 * Add a 1 second delay here. This gives the host controller
1141 * a bit time before the comminucation with the USB devices
1142 * is started (the bus is scanned) and fixes the USB detection
1143 * problems with some problematic USB keys.
1145 if (readl(®s->gintsts) & DWC2_GINTSTS_CURMODE_HOST)
1151 static void dwc2_uninit_common(struct dwc2_core_regs *regs)
1153 /* Put everything in reset. */
1154 clrsetbits_le32(®s->hprt0, DWC2_HPRT0_PRTENA |
1155 DWC2_HPRT0_PRTCONNDET | DWC2_HPRT0_PRTENCHNG |
1156 DWC2_HPRT0_PRTOVRCURRCHNG,
1160 #ifndef CONFIG_DM_USB
1161 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1162 int len, struct devrequest *setup)
1164 return _submit_control_msg(&local, dev, pipe, buffer, len, setup);
1167 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1170 return _submit_bulk_msg(&local, dev, pipe, buffer, len);
1173 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1174 int len, int interval)
1176 return _submit_int_msg(&local, dev, pipe, buffer, len, interval);
1179 /* U-Boot USB control interface */
1180 int usb_lowlevel_init(int index, enum usb_init_type init, void **controller)
1182 struct dwc2_priv *priv = &local;
1184 memset(priv, '\0', sizeof(*priv));
1185 priv->root_hub_devnum = 0;
1186 priv->regs = (struct dwc2_core_regs *)CONFIG_USB_DWC2_REG_ADDR;
1187 priv->aligned_buffer = aligned_buffer_addr;
1188 priv->status_buffer = status_buffer_addr;
1190 /* board-dependant init */
1191 if (board_usb_init(index, USB_INIT_HOST))
1194 return dwc2_init_common(NULL, priv);
1197 int usb_lowlevel_stop(int index)
1199 dwc2_uninit_common(local.regs);
1205 #ifdef CONFIG_DM_USB
1206 static int dwc2_submit_control_msg(struct udevice *dev, struct usb_device *udev,
1207 unsigned long pipe, void *buffer, int length,
1208 struct devrequest *setup)
1210 struct dwc2_priv *priv = dev_get_priv(dev);
1212 debug("%s: dev='%s', udev=%p, udev->dev='%s', portnr=%d\n", __func__,
1213 dev->name, udev, udev->dev->name, udev->portnr);
1215 return _submit_control_msg(priv, udev, pipe, buffer, length, setup);
1218 static int dwc2_submit_bulk_msg(struct udevice *dev, struct usb_device *udev,
1219 unsigned long pipe, void *buffer, int length)
1221 struct dwc2_priv *priv = dev_get_priv(dev);
1223 debug("%s: dev='%s', udev=%p\n", __func__, dev->name, udev);
1225 return _submit_bulk_msg(priv, udev, pipe, buffer, length);
1228 static int dwc2_submit_int_msg(struct udevice *dev, struct usb_device *udev,
1229 unsigned long pipe, void *buffer, int length,
1232 struct dwc2_priv *priv = dev_get_priv(dev);
1234 debug("%s: dev='%s', udev=%p\n", __func__, dev->name, udev);
1236 return _submit_int_msg(priv, udev, pipe, buffer, length, interval);
1239 static int dwc2_usb_ofdata_to_platdata(struct udevice *dev)
1241 struct dwc2_priv *priv = dev_get_priv(dev);
1245 addr = devfdt_get_addr(dev);
1246 if (addr == FDT_ADDR_T_NONE)
1248 priv->regs = (struct dwc2_core_regs *)addr;
1250 prop = fdt_getprop(gd->fdt_blob, dev_of_offset(dev),
1251 "disable-over-current", NULL);
1253 priv->oc_disable = true;
1255 prop = fdt_getprop(gd->fdt_blob, dev_of_offset(dev),
1256 "hnp-srp-disable", NULL);
1258 priv->hnp_srp_disable = true;
1263 static int dwc2_usb_probe(struct udevice *dev)
1265 struct dwc2_priv *priv = dev_get_priv(dev);
1266 struct usb_bus_priv *bus_priv = dev_get_uclass_priv(dev);
1268 bus_priv->desc_before_addr = true;
1270 return dwc2_init_common(dev, priv);
1273 static int dwc2_usb_remove(struct udevice *dev)
1275 struct dwc2_priv *priv = dev_get_priv(dev);
1277 dwc2_uninit_common(priv->regs);
1282 struct dm_usb_ops dwc2_usb_ops = {
1283 .control = dwc2_submit_control_msg,
1284 .bulk = dwc2_submit_bulk_msg,
1285 .interrupt = dwc2_submit_int_msg,
1288 static const struct udevice_id dwc2_usb_ids[] = {
1289 { .compatible = "brcm,bcm2835-usb" },
1290 { .compatible = "snps,dwc2" },
1294 U_BOOT_DRIVER(usb_dwc2) = {
1297 .of_match = dwc2_usb_ids,
1298 .ofdata_to_platdata = dwc2_usb_ofdata_to_platdata,
1299 .probe = dwc2_usb_probe,
1300 .remove = dwc2_usb_remove,
1301 .ops = &dwc2_usb_ops,
1302 .priv_auto_alloc_size = sizeof(struct dwc2_priv),
1303 .flags = DM_FLAG_ALLOC_PRIV_DMA,