2 ******************************************************************************
4 * @author MCD Application Team
7 * @brief USB-OTG Core Layer
8 ******************************************************************************
11 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
18 * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
19 ******************************************************************************
22 /* Includes ------------------------------------------------------------------*/
27 /** @addtogroup USB_OTG_DRIVER
31 /** @defgroup USB_CORE
32 * @brief This file includes the USB-OTG Core Layer
37 /** @defgroup USB_CORE_Private_Defines
46 /** @defgroup USB_CORE_Private_TypesDefinitions
55 /** @defgroup USB_CORE_Private_Macros
63 /** @defgroup USB_CORE_Private_Variables
71 /** @defgroup USB_CORE_Private_FunctionPrototypes
79 /** @defgroup USB_CORE_Private_Functions
84 * @brief USB_OTG_EnableCommonInt
85 * Initializes the commmon interrupts, used in both device and modes
86 * @param pdev : Selected device
89 static void USB_OTG_EnableCommonInt(USB_OTG_CORE_HANDLE *pdev)
91 USB_OTG_GINTMSK_TypeDef int_mask;
94 /* Clear any pending USB_OTG Interrupts */
96 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GOTGINT, 0xFFFFFFFF);
98 /* Clear any pending interrupts */
99 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GINTSTS, 0xFFFFFFFF);
100 /* Enable the interrupts in the INTMSK */
101 int_mask.b.wkupintr = 1;
102 int_mask.b.usbsuspend = 1;
105 int_mask.b.otgintr = 1;
106 int_mask.b.sessreqintr = 1;
107 int_mask.b.conidstschng = 1;
109 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GINTMSK, int_mask.d32);
113 * @brief USB_OTG_CoreReset : Soft reset of the core
114 * @param pdev : Selected device
115 * @retval USB_OTG_STS : status
117 static USB_OTG_STS USB_OTG_CoreReset(USB_OTG_CORE_HANDLE *pdev)
119 USB_OTG_STS status = USB_OTG_OK;
120 __IO USB_OTG_GRSTCTL_TypeDef greset;
124 /* Wait for AHB master IDLE state. */
127 USB_OTG_BSP_uDelay(3);
128 greset.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GRSTCTL);
129 if (++count > 200000)
134 while (greset.b.ahbidle == 0);
135 /* Core Soft Reset */
137 greset.b.csftrst = 1;
138 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GRSTCTL, greset.d32 );
141 greset.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GRSTCTL);
142 if (++count > 200000)
147 while (greset.b.csftrst == 1);
148 /* Wait for 3 PHY Clocks*/
149 USB_OTG_BSP_uDelay(3);
154 * @brief USB_OTG_WritePacket : Writes a packet into the Tx FIFO associated
156 * @param pdev : Selected device
157 * @param src : source pointer
158 * @param ch_ep_num : end point number
159 * @param bytes : No. of bytes
160 * @retval USB_OTG_STS : status
162 USB_OTG_STS USB_OTG_WritePacket(USB_OTG_CORE_HANDLE *pdev,
167 USB_OTG_STS status = USB_OTG_OK;
168 if (pdev->cfg.dma_enable == 0)
170 uint32_t count32b= 0 , i= 0;
173 count32b = (len + 3) / 4;
174 fifo = pdev->regs.DFIFO[ch_ep_num];
175 for (i = 0; i < count32b; i++, src+=4)
177 USB_OTG_WRITE_REG32( fifo, *((__packed uint32_t *)src) );
185 * @brief USB_OTG_ReadPacket : Reads a packet from the Rx FIFO
186 * @param pdev : Selected device
187 * @param dest : Destination Pointer
188 * @param bytes : No. of bytes
191 void *USB_OTG_ReadPacket(USB_OTG_CORE_HANDLE *pdev,
196 uint32_t count32b = (len + 3) / 4;
198 __IO uint32_t *fifo = pdev->regs.DFIFO[0];
200 for ( i = 0; i < count32b; i++, dest += 4 )
202 *(__packed uint32_t *)dest = USB_OTG_READ_REG32(fifo);
205 return ((void *)dest);
209 * @brief USB_OTG_SelectCore
210 * Initialize core registers address.
211 * @param pdev : Selected device
212 * @param coreID : USB OTG Core ID
213 * @retval USB_OTG_STS : status
215 USB_OTG_STS USB_OTG_SelectCore(USB_OTG_CORE_HANDLE *pdev,
216 USB_OTG_CORE_ID_TypeDef coreID)
218 uint32_t i , baseAddress = 0;
219 USB_OTG_STS status = USB_OTG_OK;
221 pdev->cfg.dma_enable = 0;
223 /* at startup the core is in FS mode */
224 pdev->cfg.speed = USB_OTG_SPEED_FULL;
225 pdev->cfg.mps = USB_OTG_FS_MAX_PACKET_SIZE ;
227 /* initialize device cfg following its address */
228 if (coreID == USB_OTG_FS_CORE_ID)
230 baseAddress = USB_OTG_FS_BASE_ADDR;
231 pdev->cfg.coreID = USB_OTG_FS_CORE_ID;
232 pdev->cfg.host_channels = 8 ;
233 pdev->cfg.dev_endpoints = 4 ;
234 pdev->cfg.TotalFifoSize = 320; /* in 32-bits */
235 pdev->cfg.phy_itface = USB_OTG_EMBEDDED_PHY;
237 #ifdef USB_OTG_FS_SOF_OUTPUT_ENABLED
238 pdev->cfg.Sof_output = 1;
241 #ifdef USB_OTG_FS_LOW_PWR_MGMT_SUPPORT
242 pdev->cfg.low_power = 1;
245 else if (coreID == USB_OTG_HS_CORE_ID)
247 baseAddress = USB_OTG_HS_BASE_ADDR;
248 pdev->cfg.coreID = USB_OTG_HS_CORE_ID;
249 pdev->cfg.host_channels = 12 ;
250 pdev->cfg.dev_endpoints = 6 ;
251 pdev->cfg.TotalFifoSize = 1280;/* in 32-bits */
253 #ifdef USB_OTG_ULPI_PHY_ENABLED
254 pdev->cfg.phy_itface = USB_OTG_ULPI_PHY;
256 #ifdef USB_OTG_EMBEDDED_PHY_ENABLED
257 pdev->cfg.phy_itface = USB_OTG_EMBEDDED_PHY;
259 #ifdef USB_OTG_I2C_PHY_ENABLED
260 pdev->cfg.phy_itface = USB_OTG_I2C_PHY;
265 #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
266 pdev->cfg.dma_enable = 1;
269 #ifdef USB_OTG_HS_SOF_OUTPUT_ENABLED
270 pdev->cfg.Sof_output = 1;
273 #ifdef USB_OTG_HS_LOW_PWR_MGMT_SUPPORT
274 pdev->cfg.low_power = 1;
279 pdev->regs.GREGS = (USB_OTG_GREGS *)(baseAddress + \
280 USB_OTG_CORE_GLOBAL_REGS_OFFSET);
281 pdev->regs.DREGS = (USB_OTG_DREGS *) (baseAddress + \
282 USB_OTG_DEV_GLOBAL_REG_OFFSET);
284 for (i = 0; i < pdev->cfg.dev_endpoints; i++)
286 pdev->regs.INEP_REGS[i] = (USB_OTG_INEPREGS *) \
287 (baseAddress + USB_OTG_DEV_IN_EP_REG_OFFSET + \
288 (i * USB_OTG_EP_REG_OFFSET));
289 pdev->regs.OUTEP_REGS[i] = (USB_OTG_OUTEPREGS *) \
290 (baseAddress + USB_OTG_DEV_OUT_EP_REG_OFFSET + \
291 (i * USB_OTG_EP_REG_OFFSET));
293 pdev->regs.HREGS = (USB_OTG_HREGS *)(baseAddress + \
294 USB_OTG_HOST_GLOBAL_REG_OFFSET);
295 pdev->regs.HPRT0 = (uint32_t *)(baseAddress + USB_OTG_HOST_PORT_REGS_OFFSET);
297 for (i = 0; i < pdev->cfg.host_channels; i++)
299 pdev->regs.HC_REGS[i] = (USB_OTG_HC_REGS *)(baseAddress + \
300 USB_OTG_HOST_CHAN_REGS_OFFSET + \
301 (i * USB_OTG_CHAN_REGS_OFFSET));
303 for (i = 0; i < pdev->cfg.host_channels; i++)
305 pdev->regs.DFIFO[i] = (uint32_t *)(baseAddress + USB_OTG_DATA_FIFO_OFFSET +\
306 (i * USB_OTG_DATA_FIFO_SIZE));
308 pdev->regs.PCGCCTL = (uint32_t *)(baseAddress + USB_OTG_PCGCCTL_OFFSET);
315 * @brief USB_OTG_CoreInit
316 * Initializes the USB_OTG controller registers and prepares the core
317 * device mode or host mode operation.
318 * @param pdev : Selected device
319 * @retval USB_OTG_STS : status
321 USB_OTG_STS USB_OTG_CoreInit(USB_OTG_CORE_HANDLE *pdev)
323 USB_OTG_STS status = USB_OTG_OK;
324 USB_OTG_GUSBCFG_TypeDef usbcfg;
325 USB_OTG_GCCFG_TypeDef gccfg;
326 USB_OTG_GI2CCTL_TypeDef i2cctl;
327 USB_OTG_GAHBCFG_TypeDef ahbcfg;
335 if (pdev->cfg.phy_itface == USB_OTG_ULPI_PHY)
337 gccfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GCCFG);
340 if (pdev->cfg.Sof_output)
342 gccfg.b.sofouten = 1;
344 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GCCFG, gccfg.d32);
346 /* Init The ULPI Interface */
348 usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
350 usbcfg.b.physel = 0; /* HS Interface */
351 #ifdef USB_OTG_INTERNAL_VBUS_ENABLED
352 usbcfg.b.ulpi_ext_vbus_drv = 0; /* Use internal VBUS */
354 #ifdef USB_OTG_EXTERNAL_VBUS_ENABLED
355 usbcfg.b.ulpi_ext_vbus_drv = 1; /* Use external VBUS */
358 usbcfg.b.term_sel_dl_pulse = 0; /* Data line pulsing using utmi_txvalid */
359 usbcfg.b.ulpi_utmi_sel = 1; /* ULPI seleInterfacect */
361 usbcfg.b.phyif = 0; /* 8 bits */
362 usbcfg.b.ddrsel = 0; /* single data rate */
364 usbcfg.b.ulpi_fsls = 0;
365 usbcfg.b.ulpi_clk_sus_m = 0;
366 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
368 /* Reset after a PHY select */
369 USB_OTG_CoreReset(pdev);
371 if(pdev->cfg.dma_enable == 1)
374 ahbcfg.b.hburstlen = 5; /* 64 x 32-bits*/
375 ahbcfg.b.dmaenable = 1;
376 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
380 else /* FS interface (embedded Phy or I2C Phy) */
383 usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);;
384 usbcfg.b.physel = 1; /* FS Interface */
385 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
386 /* Reset after a PHY select and set Host mode */
387 USB_OTG_CoreReset(pdev);
388 /* Enable the I2C interface and deactivate the power down*/
392 if(pdev->cfg.phy_itface == USB_OTG_I2C_PHY)
396 gccfg.b.vbussensingA = 1 ;
397 gccfg.b.vbussensingB = 1 ;
398 #ifndef VBUS_SENSING_ENABLED
399 gccfg.b.disablevbussensing = 1;
402 if(pdev->cfg.Sof_output)
404 gccfg.b.sofouten = 1;
407 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GCCFG, gccfg.d32);
408 USB_OTG_BSP_mDelay(20);
409 /* Program GUSBCFG.OtgUtmifsSel to I2C*/
410 usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
412 if(pdev->cfg.phy_itface == USB_OTG_I2C_PHY)
414 usbcfg.b.otgutmifssel = 1;
417 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
419 if(pdev->cfg.phy_itface == USB_OTG_I2C_PHY)
421 /*Program GI2CCTL.I2CEn*/
422 i2cctl.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GI2CCTL);
423 i2cctl.b.i2cdevaddr = 1;
425 i2cctl.b.dat_se0 = 1;
426 i2cctl.b.addr = 0x2D;
427 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GI2CCTL, i2cctl.d32);
429 USB_OTG_BSP_mDelay(200);
432 USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GI2CCTL, i2cctl.d32);
433 USB_OTG_BSP_mDelay(200);
436 /* case the HS core is working in FS mode */
437 if(pdev->cfg.dma_enable == 1)
440 ahbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GAHBCFG);
441 ahbcfg.b.hburstlen = 5; /* 64 x 32-bits*/
442 ahbcfg.b.dmaenable = 1;
443 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
446 /* initialize OTG features */
448 usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
451 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
452 USB_OTG_EnableCommonInt(pdev);
457 * @brief USB_OTG_EnableGlobalInt
458 * Enables the controller's Global Int in the AHB Config reg
459 * @param pdev : Selected device
460 * @retval USB_OTG_STS : status
462 USB_OTG_STS USB_OTG_EnableGlobalInt(USB_OTG_CORE_HANDLE *pdev)
464 USB_OTG_STS status = USB_OTG_OK;
465 USB_OTG_GAHBCFG_TypeDef ahbcfg;
468 ahbcfg.b.glblintrmsk = 1; /* Enable interrupts */
469 USB_OTG_MODIFY_REG32(&pdev->regs.GREGS->GAHBCFG, 0, ahbcfg.d32);
475 * @brief USB_OTG_DisableGlobalInt
476 * Enables the controller's Global Int in the AHB Config reg
477 * @param pdev : Selected device
478 * @retval USB_OTG_STS : status
480 USB_OTG_STS USB_OTG_DisableGlobalInt(USB_OTG_CORE_HANDLE *pdev)
482 USB_OTG_STS status = USB_OTG_OK;
483 USB_OTG_GAHBCFG_TypeDef ahbcfg;
485 ahbcfg.b.glblintrmsk = 1; /* Enable interrupts */
486 USB_OTG_MODIFY_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32, 0);
492 * @brief USB_OTG_FlushTxFifo : Flush a Tx FIFO
493 * @param pdev : Selected device
494 * @param num : FO num
495 * @retval USB_OTG_STS : status
497 USB_OTG_STS USB_OTG_FlushTxFifo (USB_OTG_CORE_HANDLE *pdev , uint32_t num )
499 USB_OTG_STS status = USB_OTG_OK;
500 __IO USB_OTG_GRSTCTL_TypeDef greset;
504 greset.b.txfflsh = 1;
505 greset.b.txfnum = num;
506 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GRSTCTL, greset.d32 );
509 greset.d32 = USB_OTG_READ_REG32( &pdev->regs.GREGS->GRSTCTL);
510 if (++count > 200000)
515 while (greset.b.txfflsh == 1);
516 /* Wait for 3 PHY Clocks*/
517 USB_OTG_BSP_uDelay(3);
523 * @brief USB_OTG_FlushRxFifo : Flush a Rx FIFO
524 * @param pdev : Selected device
525 * @retval USB_OTG_STS : status
527 USB_OTG_STS USB_OTG_FlushRxFifo( USB_OTG_CORE_HANDLE *pdev )
529 USB_OTG_STS status = USB_OTG_OK;
530 __IO USB_OTG_GRSTCTL_TypeDef greset;
534 greset.b.rxfflsh = 1;
535 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GRSTCTL, greset.d32 );
538 greset.d32 = USB_OTG_READ_REG32( &pdev->regs.GREGS->GRSTCTL);
539 if (++count > 200000)
544 while (greset.b.rxfflsh == 1);
545 /* Wait for 3 PHY Clocks*/
546 USB_OTG_BSP_uDelay(3);
552 * @brief USB_OTG_SetCurrentMode : Set ID line
553 * @param pdev : Selected device
554 * @param mode : (Host/device)
555 * @retval USB_OTG_STS : status
557 USB_OTG_STS USB_OTG_SetCurrentMode(USB_OTG_CORE_HANDLE *pdev , uint8_t mode)
559 USB_OTG_STS status = USB_OTG_OK;
560 USB_OTG_GUSBCFG_TypeDef usbcfg;
562 usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
564 usbcfg.b.force_host = 0;
565 usbcfg.b.force_dev = 0;
567 if ( mode == HOST_MODE)
569 usbcfg.b.force_host = 1;
571 else if ( mode == DEVICE_MODE)
573 usbcfg.b.force_dev = 1;
576 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
577 USB_OTG_BSP_mDelay(50);
583 * @brief USB_OTG_GetMode : Get current mode
584 * @param pdev : Selected device
585 * @retval current mode
587 uint32_t USB_OTG_GetMode(USB_OTG_CORE_HANDLE *pdev)
589 return (USB_OTG_READ_REG32(&pdev->regs.GREGS->GINTSTS ) & 0x1);
594 * @brief USB_OTG_IsDeviceMode : Check if it is device mode
595 * @param pdev : Selected device
598 uint8_t USB_OTG_IsDeviceMode(USB_OTG_CORE_HANDLE *pdev)
600 return (USB_OTG_GetMode(pdev) != HOST_MODE);
605 * @brief USB_OTG_IsHostMode : Check if it is host mode
606 * @param pdev : Selected device
609 uint8_t USB_OTG_IsHostMode(USB_OTG_CORE_HANDLE *pdev)
611 return (USB_OTG_GetMode(pdev) == HOST_MODE);
616 * @brief USB_OTG_ReadCoreItr : returns the Core Interrupt register
617 * @param pdev : Selected device
620 uint32_t USB_OTG_ReadCoreItr(USB_OTG_CORE_HANDLE *pdev)
623 v = USB_OTG_READ_REG32(&pdev->regs.GREGS->GINTSTS);
624 v &= USB_OTG_READ_REG32(&pdev->regs.GREGS->GINTMSK);
630 * @brief USB_OTG_ReadOtgItr : returns the USB_OTG Interrupt register
631 * @param pdev : Selected device
634 uint32_t USB_OTG_ReadOtgItr (USB_OTG_CORE_HANDLE *pdev)
636 return (USB_OTG_READ_REG32 (&pdev->regs.GREGS->GOTGINT));
641 * @brief USB_OTG_CoreInitHost : Initializes USB_OTG controller for host mode
642 * @param pdev : Selected device
645 USB_OTG_STS USB_OTG_CoreInitHost(USB_OTG_CORE_HANDLE *pdev)
647 USB_OTG_STS status = USB_OTG_OK;
648 USB_OTG_FSIZ_TypeDef nptxfifosize;
649 USB_OTG_FSIZ_TypeDef ptxfifosize;
650 USB_OTG_HCFG_TypeDef hcfg;
653 USB_OTG_OTGCTL_TypeDef gotgctl;
658 nptxfifosize.d32 = 0;
666 /* configure charge pump IO */
667 USB_OTG_BSP_ConfigVBUS(pdev);
669 /* Restart the Phy Clock */
670 USB_OTG_WRITE_REG32(pdev->regs.PCGCCTL, 0);
672 /* Initialize Host Configuration Register */
673 USB_OTG_InitFSLSPClkSel(pdev , HCFG_48_MHZ); /* in init phase */
675 hcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.HREGS->HCFG);
677 USB_OTG_WRITE_REG32(&pdev->regs.HREGS->HCFG, hcfg.d32);
679 /* Configure data FIFO sizes */
681 #ifdef USB_OTG_FS_CORE
682 if(pdev->cfg.coreID == USB_OTG_FS_CORE_ID)
684 /* set Rx FIFO size */
685 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GRXFSIZ, RX_FIFO_FS_SIZE);
686 nptxfifosize.b.startaddr = RX_FIFO_FS_SIZE;
687 nptxfifosize.b.depth = TXH_NP_FS_FIFOSIZ;
688 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->DIEPTXF0_HNPTXFSIZ, nptxfifosize.d32);
690 ptxfifosize.b.startaddr = RX_FIFO_FS_SIZE + TXH_NP_FS_FIFOSIZ;
691 ptxfifosize.b.depth = TXH_P_FS_FIFOSIZ;
692 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->HPTXFSIZ, ptxfifosize.d32);
695 #ifdef USB_OTG_HS_CORE
696 if (pdev->cfg.coreID == USB_OTG_HS_CORE_ID)
698 /* set Rx FIFO size */
699 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GRXFSIZ, RX_FIFO_HS_SIZE);
700 nptxfifosize.b.startaddr = RX_FIFO_HS_SIZE;
701 nptxfifosize.b.depth = TXH_NP_HS_FIFOSIZ;
702 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->DIEPTXF0_HNPTXFSIZ, nptxfifosize.d32);
704 ptxfifosize.b.startaddr = RX_FIFO_HS_SIZE + TXH_NP_HS_FIFOSIZ;
705 ptxfifosize.b.depth = TXH_P_HS_FIFOSIZ;
706 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->HPTXFSIZ, ptxfifosize.d32);
711 /* Clear Host Set HNP Enable in the USB_OTG Control Register */
712 gotgctl.b.hstsethnpen = 1;
713 USB_OTG_MODIFY_REG32( &pdev->regs.GREGS->GOTGCTL, gotgctl.d32, 0);
716 /* Make sure the FIFOs are flushed. */
717 USB_OTG_FlushTxFifo(pdev, 0x10 ); /* all Tx FIFOs */
718 USB_OTG_FlushRxFifo(pdev);
721 /* Clear all pending HC Interrupts */
722 for (i = 0; i < pdev->cfg.host_channels; i++)
724 USB_OTG_WRITE_REG32( &pdev->regs.HC_REGS[i]->HCINT, 0xFFFFFFFF );
725 USB_OTG_WRITE_REG32( &pdev->regs.HC_REGS[i]->HCGINTMSK, 0 );
728 USB_OTG_DriveVbus(pdev, 1);
731 USB_OTG_EnableHostInt(pdev);
736 * @brief USB_OTG_IsEvenFrame
737 * This function returns the frame number for sof packet
738 * @param pdev : Selected device
739 * @retval Frame number
741 uint8_t USB_OTG_IsEvenFrame (USB_OTG_CORE_HANDLE *pdev)
743 return !(USB_OTG_READ_REG32(&pdev->regs.HREGS->HFNUM) & 0x1);
747 * @brief USB_OTG_DriveVbus : set/reset vbus
748 * @param pdev : Selected device
749 * @param state : VBUS state
752 void USB_OTG_DriveVbus (USB_OTG_CORE_HANDLE *pdev, uint8_t state)
754 USB_OTG_HPRT0_TypeDef hprt0;
758 /* enable disable the external charge pump */
759 USB_OTG_BSP_DriveVBUS(pdev, state);
761 /* Turn on the Host port power. */
762 hprt0.d32 = USB_OTG_ReadHPRT0(pdev);
763 if ((hprt0.b.prtpwr == 0 ) && (state == 1 ))
766 USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
768 if ((hprt0.b.prtpwr == 1 ) && (state == 0 ))
771 USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
774 USB_OTG_BSP_mDelay(200);
777 * @brief USB_OTG_EnableHostInt: Enables the Host mode interrupts
778 * @param pdev : Selected device
779 * @retval USB_OTG_STS : status
781 USB_OTG_STS USB_OTG_EnableHostInt(USB_OTG_CORE_HANDLE *pdev)
783 USB_OTG_STS status = USB_OTG_OK;
784 USB_OTG_GINTMSK_TypeDef intmsk;
786 /* Disable all interrupts. */
787 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GINTMSK, 0);
789 /* Clear any pending interrupts. */
790 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GINTSTS, 0xFFFFFFFF);
792 /* Enable the common interrupts */
793 USB_OTG_EnableCommonInt(pdev);
795 if (pdev->cfg.dma_enable == 0)
797 intmsk.b.rxstsqlvl = 1;
799 intmsk.b.portintr = 1;
801 intmsk.b.disconnect = 1;
802 intmsk.b.sofintr = 1;
803 intmsk.b.incomplisoout = 1;
804 USB_OTG_MODIFY_REG32(&pdev->regs.GREGS->GINTMSK, intmsk.d32, intmsk.d32);
809 * @brief USB_OTG_InitFSLSPClkSel : Initializes the FSLSPClkSel field of the
810 * HCFG register on the PHY type
811 * @param pdev : Selected device
812 * @param freq : clock frequency
815 void USB_OTG_InitFSLSPClkSel(USB_OTG_CORE_HANDLE *pdev , uint8_t freq)
817 USB_OTG_HCFG_TypeDef hcfg;
819 hcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.HREGS->HCFG);
820 hcfg.b.fslspclksel = freq;
821 USB_OTG_WRITE_REG32(&pdev->regs.HREGS->HCFG, hcfg.d32);
826 * @brief USB_OTG_ReadHPRT0 : Reads HPRT0 to modify later
827 * @param pdev : Selected device
828 * @retval HPRT0 value
830 uint32_t USB_OTG_ReadHPRT0(USB_OTG_CORE_HANDLE *pdev)
832 USB_OTG_HPRT0_TypeDef hprt0;
834 hprt0.d32 = USB_OTG_READ_REG32(pdev->regs.HPRT0);
836 hprt0.b.prtconndet = 0;
837 hprt0.b.prtenchng = 0;
838 hprt0.b.prtovrcurrchng = 0;
844 * @brief USB_OTG_ReadHostAllChannels_intr : Register PCD Callbacks
845 * @param pdev : Selected device
848 uint32_t USB_OTG_ReadHostAllChannels_intr (USB_OTG_CORE_HANDLE *pdev)
850 return (USB_OTG_READ_REG32 (&pdev->regs.HREGS->HAINT));
855 * @brief USB_OTG_ResetPort : Reset Host Port
856 * @param pdev : Selected device
858 * @note : (1)The application must wait at least 10 ms (+ 10 ms security)
859 * before clearing the reset bit.
861 uint32_t USB_OTG_ResetPort(USB_OTG_CORE_HANDLE *pdev)
863 USB_OTG_HPRT0_TypeDef hprt0;
865 hprt0.d32 = USB_OTG_ReadHPRT0(pdev);
867 USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
868 USB_OTG_BSP_mDelay (10); /* See Note #1 */
870 USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
871 USB_OTG_BSP_mDelay (20);
877 * @brief USB_OTG_HC_Init : Prepares a host channel for transferring packets
878 * @param pdev : Selected device
879 * @param hc_num : channel number
880 * @retval USB_OTG_STS : status
882 USB_OTG_STS USB_OTG_HC_Init(USB_OTG_CORE_HANDLE *pdev , uint8_t hc_num)
884 USB_OTG_STS status = USB_OTG_OK;
885 uint32_t intr_enable = 0;
886 USB_OTG_HCGINTMSK_TypeDef hcintmsk;
887 USB_OTG_GINTMSK_TypeDef gintmsk;
888 USB_OTG_HCCHAR_TypeDef hcchar;
889 USB_OTG_HCINTn_TypeDef hcint;
896 /* Clear old interrupt conditions for this host channel. */
897 hcint.d32 = 0xFFFFFFFF;
898 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCINT, hcint.d32);
900 /* Enable channel interrupts required for this transfer. */
903 if (pdev->cfg.dma_enable == 1)
905 hcintmsk.b.ahberr = 1;
908 switch (pdev->host.hc[hc_num].ep_type)
912 hcintmsk.b.xfercompl = 1;
913 hcintmsk.b.stall = 1;
914 hcintmsk.b.xacterr = 1;
915 hcintmsk.b.datatglerr = 1;
917 if (pdev->host.hc[hc_num].ep_is_in)
919 hcintmsk.b.bblerr = 1;
924 if (pdev->host.hc[hc_num].do_ping)
931 hcintmsk.b.xfercompl = 1;
933 hcintmsk.b.stall = 1;
934 hcintmsk.b.xacterr = 1;
935 hcintmsk.b.datatglerr = 1;
936 hcintmsk.b.frmovrun = 1;
938 if (pdev->host.hc[hc_num].ep_is_in)
940 hcintmsk.b.bblerr = 1;
945 hcintmsk.b.xfercompl = 1;
946 hcintmsk.b.frmovrun = 1;
949 if (pdev->host.hc[hc_num].ep_is_in)
951 hcintmsk.b.xacterr = 1;
952 hcintmsk.b.bblerr = 1;
958 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCGINTMSK, hcintmsk.d32);
961 /* Enable the top level host channel interrupt. */
962 intr_enable = (1 << hc_num);
963 USB_OTG_MODIFY_REG32(&pdev->regs.HREGS->HAINTMSK, 0, intr_enable);
965 /* Make sure host channel interrupts are enabled. */
966 gintmsk.b.hcintr = 1;
967 USB_OTG_MODIFY_REG32(&pdev->regs.GREGS->GINTMSK, 0, gintmsk.d32);
969 /* Program the HCCHAR register */
971 hcchar.b.devaddr = pdev->host.hc[hc_num].dev_addr;
972 hcchar.b.epnum = pdev->host.hc[hc_num].ep_num;
973 hcchar.b.epdir = pdev->host.hc[hc_num].ep_is_in;
974 hcchar.b.lspddev = (pdev->host.hc[hc_num].speed == HPRT0_PRTSPD_LOW_SPEED);
975 hcchar.b.eptype = pdev->host.hc[hc_num].ep_type;
976 hcchar.b.mps = pdev->host.hc[hc_num].max_packet;
977 if (pdev->host.hc[hc_num].ep_type == HCCHAR_INTR)
981 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR, hcchar.d32);
987 * @brief USB_OTG_HC_StartXfer : Start transfer
988 * @param pdev : Selected device
989 * @param hc_num : channel number
990 * @retval USB_OTG_STS : status
992 USB_OTG_STS USB_OTG_HC_StartXfer(USB_OTG_CORE_HANDLE *pdev , uint8_t hc_num)
994 USB_OTG_STS status = USB_OTG_OK;
995 USB_OTG_HCCHAR_TypeDef hcchar;
996 USB_OTG_HCTSIZn_TypeDef hctsiz;
997 USB_OTG_HNPTXSTS_TypeDef hnptxsts;
998 USB_OTG_HPTXSTS_TypeDef hptxsts;
999 USB_OTG_GINTMSK_TypeDef intmsk;
1000 uint16_t len_words = 0;
1002 uint16_t num_packets;
1003 uint16_t max_hc_pkt_count;
1005 max_hc_pkt_count = 256;
1010 /* Compute the expected number of packets associated to the transfer */
1011 if (pdev->host.hc[hc_num].xfer_len > 0)
1013 num_packets = (pdev->host.hc[hc_num].xfer_len + \
1014 pdev->host.hc[hc_num].max_packet - 1) / pdev->host.hc[hc_num].max_packet;
1016 if (num_packets > max_hc_pkt_count)
1018 num_packets = max_hc_pkt_count;
1019 pdev->host.hc[hc_num].xfer_len = num_packets * \
1020 pdev->host.hc[hc_num].max_packet;
1027 if (pdev->host.hc[hc_num].ep_is_in)
1029 pdev->host.hc[hc_num].xfer_len = num_packets * \
1030 pdev->host.hc[hc_num].max_packet;
1032 /* Initialize the HCTSIZn register */
1033 hctsiz.b.xfersize = pdev->host.hc[hc_num].xfer_len;
1034 hctsiz.b.pktcnt = num_packets;
1035 hctsiz.b.pid = pdev->host.hc[hc_num].data_pid;
1036 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCTSIZ, hctsiz.d32);
1038 if (pdev->cfg.dma_enable == 1)
1040 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCDMA, (unsigned int)pdev->host.hc[hc_num].xfer_buff);
1044 hcchar.d32 = USB_OTG_READ_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR);
1045 hcchar.b.oddfrm = USB_OTG_IsEvenFrame(pdev);
1047 /* Set host channel enable */
1050 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR, hcchar.d32);
1052 if (pdev->cfg.dma_enable == 0) /* Slave mode */
1054 if((pdev->host.hc[hc_num].ep_is_in == 0) &&
1055 (pdev->host.hc[hc_num].xfer_len > 0))
1057 switch(pdev->host.hc[hc_num].ep_type)
1059 /* Non periodic transfer */
1063 hnptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS);
1064 len_words = (pdev->host.hc[hc_num].xfer_len + 3) / 4;
1066 /* check if there is enough space in FIFO space */
1067 if(len_words > hnptxsts.b.nptxfspcavail)
1069 /* need to process data in nptxfempty interrupt */
1070 intmsk.b.nptxfempty = 1;
1071 USB_OTG_MODIFY_REG32( &pdev->regs.GREGS->GINTMSK, 0, intmsk.d32);
1075 /* Periodic transfer */
1078 hptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.HREGS->HPTXSTS);
1079 len_words = (pdev->host.hc[hc_num].xfer_len + 3) / 4;
1080 /* check if there is enough space in FIFO space */
1081 if(len_words > hptxsts.b.ptxfspcavail) /* split the transfer */
1083 /* need to process data in ptxfempty interrupt */
1084 intmsk.b.ptxfempty = 1;
1085 USB_OTG_MODIFY_REG32( &pdev->regs.GREGS->GINTMSK, 0, intmsk.d32);
1093 /* Write packet into the Tx FIFO. */
1094 USB_OTG_WritePacket(pdev,
1095 pdev->host.hc[hc_num].xfer_buff ,
1096 hc_num, pdev->host.hc[hc_num].xfer_len);
1104 * @brief USB_OTG_HC_Halt : Halt channel
1105 * @param pdev : Selected device
1106 * @param hc_num : channel number
1107 * @retval USB_OTG_STS : status
1109 USB_OTG_STS USB_OTG_HC_Halt(USB_OTG_CORE_HANDLE *pdev , uint8_t hc_num)
1111 USB_OTG_STS status = USB_OTG_OK;
1112 USB_OTG_HNPTXSTS_TypeDef nptxsts;
1113 USB_OTG_HPTXSTS_TypeDef hptxsts;
1114 USB_OTG_HCCHAR_TypeDef hcchar;
1118 hcchar.d32 = USB_OTG_READ_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR);
1122 /* Check for space in the request queue to issue the halt. */
1123 if (hcchar.b.eptype == HCCHAR_CTRL || hcchar.b.eptype == HCCHAR_BULK)
1125 nptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS);
1126 if (nptxsts.b.nptxqspcavail == 0)
1133 hptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.HREGS->HPTXSTS);
1134 if (hptxsts.b.ptxqspcavail == 0)
1139 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR, hcchar.d32);
1144 * @brief Issue a ping token
1148 USB_OTG_STS USB_OTG_HC_DoPing(USB_OTG_CORE_HANDLE *pdev , uint8_t hc_num)
1150 USB_OTG_STS status = USB_OTG_OK;
1151 USB_OTG_HCCHAR_TypeDef hcchar;
1152 USB_OTG_HCTSIZn_TypeDef hctsiz;
1156 hctsiz.b.pktcnt = 1;
1157 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCTSIZ, hctsiz.d32);
1159 hcchar.d32 = USB_OTG_READ_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR);
1162 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[hc_num]->HCCHAR, hcchar.d32);
1167 * @brief Stop the device and clean up fifo's
1171 void USB_OTG_StopHost(USB_OTG_CORE_HANDLE *pdev)
1173 USB_OTG_HCCHAR_TypeDef hcchar;
1176 USB_OTG_WRITE_REG32(&pdev->regs.HREGS->HAINTMSK , 0);
1177 USB_OTG_WRITE_REG32(&pdev->regs.HREGS->HAINT, 0xFFFFFFFF);
1178 /* Flush out any leftover queued requests. */
1180 for (i = 0; i < pdev->cfg.host_channels; i++)
1182 hcchar.d32 = USB_OTG_READ_REG32(&pdev->regs.HC_REGS[i]->HCCHAR);
1186 USB_OTG_WRITE_REG32(&pdev->regs.HC_REGS[i]->HCCHAR, hcchar.d32);
1189 /* Flush the FIFO */
1190 USB_OTG_FlushRxFifo(pdev);
1191 USB_OTG_FlushTxFifo(pdev , 0x10 );
1194 #ifdef USE_DEVICE_MODE
1195 /* PCD Core Layer */
1198 * @brief USB_OTG_InitDevSpeed :Initializes the DevSpd field of DCFG register
1199 * depending the PHY type and the enumeration speed of the device.
1200 * @param pdev : Selected device
1203 void USB_OTG_InitDevSpeed(USB_OTG_CORE_HANDLE *pdev , uint8_t speed)
1205 USB_OTG_DCFG_TypeDef dcfg;
1207 dcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCFG);
1208 dcfg.b.devspd = speed;
1209 USB_OTG_WRITE_REG32(&pdev->regs.DREGS->DCFG, dcfg.d32);
1214 * @brief USB_OTG_CoreInitDev : Initializes the USB_OTG controller registers
1216 * @param pdev : Selected device
1217 * @retval USB_OTG_STS : status
1219 USB_OTG_STS USB_OTG_CoreInitDev (USB_OTG_CORE_HANDLE *pdev)
1221 USB_OTG_STS status = USB_OTG_OK;
1222 USB_OTG_DEPCTL_TypeDef depctl;
1224 USB_OTG_DCFG_TypeDef dcfg;
1225 USB_OTG_FSIZ_TypeDef nptxfifosize;
1226 USB_OTG_FSIZ_TypeDef txfifosize;
1227 USB_OTG_DIEPMSK_TypeDef msk;
1228 USB_OTG_DTHRCTL_TypeDef dthrctl;
1232 nptxfifosize.d32 = 0;
1236 /* Restart the Phy Clock */
1237 USB_OTG_WRITE_REG32(pdev->regs.PCGCCTL, 0);
1238 /* Device configuration register */
1239 dcfg.d32 = USB_OTG_READ_REG32( &pdev->regs.DREGS->DCFG);
1240 dcfg.b.perfrint = DCFG_FRAME_INTERVAL_80;
1241 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DCFG, dcfg.d32 );
1243 #ifdef USB_OTG_FS_CORE
1244 if(pdev->cfg.coreID == USB_OTG_FS_CORE_ID )
1247 /* Set Full speed phy */
1248 USB_OTG_InitDevSpeed (pdev , USB_OTG_SPEED_PARAM_FULL);
1250 /* set Rx FIFO size */
1251 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GRXFSIZ, RX_FIFO_FS_SIZE);
1254 nptxfifosize.b.depth = TX0_FIFO_FS_SIZE;
1255 nptxfifosize.b.startaddr = RX_FIFO_FS_SIZE;
1256 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF0_HNPTXFSIZ, nptxfifosize.d32 );
1260 txfifosize.b.startaddr = nptxfifosize.b.startaddr + nptxfifosize.b.depth;
1261 txfifosize.b.depth = TX1_FIFO_FS_SIZE;
1262 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[0], txfifosize.d32 );
1266 txfifosize.b.startaddr += txfifosize.b.depth;
1267 txfifosize.b.depth = TX2_FIFO_FS_SIZE;
1268 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[1], txfifosize.d32 );
1272 txfifosize.b.startaddr += txfifosize.b.depth;
1273 txfifosize.b.depth = TX3_FIFO_FS_SIZE;
1274 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[2], txfifosize.d32 );
1277 #ifdef USB_OTG_HS_CORE
1278 if(pdev->cfg.coreID == USB_OTG_HS_CORE_ID )
1281 /* Set High speed phy */
1283 if(pdev->cfg.phy_itface == USB_OTG_ULPI_PHY)
1285 USB_OTG_InitDevSpeed (pdev , USB_OTG_SPEED_PARAM_HIGH);
1287 else /* set High speed phy in Full speed mode */
1289 USB_OTG_InitDevSpeed (pdev , USB_OTG_SPEED_PARAM_HIGH_IN_FULL);
1292 /* set Rx FIFO size */
1293 USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GRXFSIZ, RX_FIFO_HS_SIZE);
1296 nptxfifosize.b.depth = TX0_FIFO_HS_SIZE;
1297 nptxfifosize.b.startaddr = RX_FIFO_HS_SIZE;
1298 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF0_HNPTXFSIZ, nptxfifosize.d32 );
1302 txfifosize.b.startaddr = nptxfifosize.b.startaddr + nptxfifosize.b.depth;
1303 txfifosize.b.depth = TX1_FIFO_HS_SIZE;
1304 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[0], txfifosize.d32 );
1308 txfifosize.b.startaddr += txfifosize.b.depth;
1309 txfifosize.b.depth = TX2_FIFO_HS_SIZE;
1310 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[1], txfifosize.d32 );
1314 txfifosize.b.startaddr += txfifosize.b.depth;
1315 txfifosize.b.depth = TX3_FIFO_HS_SIZE;
1316 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[2], txfifosize.d32 );
1319 txfifosize.b.startaddr += txfifosize.b.depth;
1320 txfifosize.b.depth = TX4_FIFO_HS_SIZE;
1321 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[3], txfifosize.d32 );
1325 txfifosize.b.startaddr += txfifosize.b.depth;
1326 txfifosize.b.depth = TX5_FIFO_HS_SIZE;
1327 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->DIEPTXF[4], txfifosize.d32 );
1330 /* Flush the FIFOs */
1331 USB_OTG_FlushTxFifo(pdev , 0x10); /* all Tx FIFOs */
1332 USB_OTG_FlushRxFifo(pdev);
1333 /* Clear all pending Device Interrupts */
1334 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DIEPMSK, 0 );
1335 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DOEPMSK, 0 );
1336 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DAINT, 0xFFFFFFFF );
1337 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DAINTMSK, 0 );
1339 for (i = 0; i < pdev->cfg.dev_endpoints; i++)
1341 depctl.d32 = USB_OTG_READ_REG32(&pdev->regs.INEP_REGS[i]->DIEPCTL);
1352 USB_OTG_WRITE_REG32( &pdev->regs.INEP_REGS[i]->DIEPCTL, depctl.d32);
1353 USB_OTG_WRITE_REG32( &pdev->regs.INEP_REGS[i]->DIEPTSIZ, 0);
1354 USB_OTG_WRITE_REG32( &pdev->regs.INEP_REGS[i]->DIEPINT, 0xFF);
1356 for (i = 0; i < pdev->cfg.dev_endpoints; i++)
1358 USB_OTG_DEPCTL_TypeDef depctl;
1359 depctl.d32 = USB_OTG_READ_REG32(&pdev->regs.OUTEP_REGS[i]->DOEPCTL);
1370 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[i]->DOEPCTL, depctl.d32);
1371 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[i]->DOEPTSIZ, 0);
1372 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[i]->DOEPINT, 0xFF);
1375 msk.b.txfifoundrn = 1;
1376 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DIEPMSK, msk.d32, msk.d32);
1378 if (pdev->cfg.dma_enable == 1)
1381 dthrctl.b.non_iso_thr_en = 1;
1382 dthrctl.b.iso_thr_en = 1;
1383 dthrctl.b.tx_thr_len = 64;
1384 dthrctl.b.rx_thr_en = 1;
1385 dthrctl.b.rx_thr_len = 64;
1386 USB_OTG_WRITE_REG32(&pdev->regs.DREGS->DTHRCTL, dthrctl.d32);
1388 USB_OTG_EnableDevInt(pdev);
1394 * @brief USB_OTG_EnableDevInt : Enables the Device mode interrupts
1395 * @param pdev : Selected device
1396 * @retval USB_OTG_STS : status
1398 USB_OTG_STS USB_OTG_EnableDevInt(USB_OTG_CORE_HANDLE *pdev)
1400 USB_OTG_STS status = USB_OTG_OK;
1401 USB_OTG_GINTMSK_TypeDef intmsk;
1405 /* Disable all interrupts. */
1406 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GINTMSK, 0);
1407 /* Clear any pending interrupts */
1408 USB_OTG_WRITE_REG32( &pdev->regs.GREGS->GINTSTS, 0xFFFFFFFF);
1409 /* Enable the common interrupts */
1410 USB_OTG_EnableCommonInt(pdev);
1412 if (pdev->cfg.dma_enable == 0)
1414 intmsk.b.rxstsqlvl = 1;
1417 /* Enable interrupts matching to the Device mode ONLY */
1418 intmsk.b.usbsuspend = 1;
1419 intmsk.b.usbreset = 1;
1420 intmsk.b.enumdone = 1;
1421 intmsk.b.inepintr = 1;
1422 intmsk.b.outepintr = 1;
1423 intmsk.b.sofintr = 1;
1425 intmsk.b.incomplisoin = 1;
1426 intmsk.b.incomplisoout = 1;
1427 #ifdef VBUS_SENSING_ENABLED
1428 intmsk.b.sessreqintr = 1;
1429 intmsk.b.otgintr = 1;
1431 USB_OTG_MODIFY_REG32( &pdev->regs.GREGS->GINTMSK, intmsk.d32, intmsk.d32);
1437 * @brief USB_OTG_GetDeviceSpeed
1438 * Get the device speed from the device status register
1442 enum USB_OTG_SPEED USB_OTG_GetDeviceSpeed (USB_OTG_CORE_HANDLE *pdev)
1444 USB_OTG_DSTS_TypeDef dsts;
1445 enum USB_OTG_SPEED speed = USB_SPEED_UNKNOWN;
1448 dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
1450 switch (dsts.b.enumspd)
1452 case DSTS_ENUMSPD_HS_PHY_30MHZ_OR_60MHZ:
1453 speed = USB_SPEED_HIGH;
1455 case DSTS_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ:
1456 case DSTS_ENUMSPD_FS_PHY_48MHZ:
1457 speed = USB_SPEED_FULL;
1460 case DSTS_ENUMSPD_LS_PHY_6MHZ:
1461 speed = USB_SPEED_LOW;
1468 * @brief enables EP0 OUT to receive SETUP packets and configures EP0
1469 * for transmitting packets
1471 * @retval USB_OTG_STS : status
1473 USB_OTG_STS USB_OTG_EP0Activate(USB_OTG_CORE_HANDLE *pdev)
1475 USB_OTG_STS status = USB_OTG_OK;
1476 USB_OTG_DSTS_TypeDef dsts;
1477 USB_OTG_DEPCTL_TypeDef diepctl;
1478 USB_OTG_DCTL_TypeDef dctl;
1481 /* Read the Device Status and Endpoint 0 Control registers */
1482 dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
1483 diepctl.d32 = USB_OTG_READ_REG32(&pdev->regs.INEP_REGS[0]->DIEPCTL);
1484 /* Set the MPS of the IN EP based on the enumeration speed */
1485 switch (dsts.b.enumspd)
1487 case DSTS_ENUMSPD_HS_PHY_30MHZ_OR_60MHZ:
1488 case DSTS_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ:
1489 case DSTS_ENUMSPD_FS_PHY_48MHZ:
1490 diepctl.b.mps = DEP0CTL_MPS_64;
1492 case DSTS_ENUMSPD_LS_PHY_6MHZ:
1493 diepctl.b.mps = DEP0CTL_MPS_8;
1496 USB_OTG_WRITE_REG32(&pdev->regs.INEP_REGS[0]->DIEPCTL, diepctl.d32);
1497 dctl.b.cgnpinnak = 1;
1498 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DCTL, dctl.d32, dctl.d32);
1504 * @brief USB_OTG_EPActivate : Activates an EP
1505 * @param pdev : Selected device
1506 * @retval USB_OTG_STS : status
1508 USB_OTG_STS USB_OTG_EPActivate(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1510 USB_OTG_STS status = USB_OTG_OK;
1511 USB_OTG_DEPCTL_TypeDef depctl;
1512 USB_OTG_DAINT_TypeDef daintmsk;
1513 __IO uint32_t *addr;
1518 /* Read DEPCTLn register */
1521 addr = &pdev->regs.INEP_REGS[ep->num]->DIEPCTL;
1522 daintmsk.ep.in = 1 << ep->num;
1526 addr = &pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL;
1527 daintmsk.ep.out = 1 << ep->num;
1529 /* If the EP is already active don't change the EP Control
1531 depctl.d32 = USB_OTG_READ_REG32(addr);
1532 if (!depctl.b.usbactep)
1534 depctl.b.mps = ep->maxpacket;
1535 depctl.b.eptype = ep->type;
1536 depctl.b.txfnum = ep->tx_fifo_num;
1537 depctl.b.setd0pid = 1;
1538 depctl.b.usbactep = 1;
1539 USB_OTG_WRITE_REG32(addr, depctl.d32);
1541 /* Enable the Interrupt for this EP */
1542 #ifdef USB_OTG_HS_DEDICATED_EP1_ENABLED
1543 if((ep->num == 1)&&(pdev->cfg.coreID == USB_OTG_HS_CORE_ID))
1545 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DEACHMSK, 0, daintmsk.d32);
1549 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DAINTMSK, 0, daintmsk.d32);
1555 * @brief USB_OTG_EPDeactivate : Deactivates an EP
1556 * @param pdev : Selected device
1557 * @retval USB_OTG_STS : status
1559 USB_OTG_STS USB_OTG_EPDeactivate(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1561 USB_OTG_STS status = USB_OTG_OK;
1562 USB_OTG_DEPCTL_TypeDef depctl;
1563 USB_OTG_DAINT_TypeDef daintmsk;
1564 __IO uint32_t *addr;
1568 /* Read DEPCTLn register */
1571 addr = &pdev->regs.INEP_REGS[ep->num]->DIEPCTL;
1572 daintmsk.ep.in = 1 << ep->num;
1576 addr = &pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL;
1577 daintmsk.ep.out = 1 << ep->num;
1579 depctl.b.usbactep = 0;
1580 USB_OTG_WRITE_REG32(addr, depctl.d32);
1581 /* Disable the Interrupt for this EP */
1583 #ifdef USB_OTG_HS_DEDICATED_EP1_ENABLED
1584 if((ep->num == 1)&&(pdev->cfg.coreID == USB_OTG_HS_CORE_ID))
1586 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DEACHMSK, daintmsk.d32, 0);
1590 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DAINTMSK, daintmsk.d32, 0);
1596 * @brief USB_OTG_EPStartXfer : Handle the setup for data xfer for an EP and
1598 * @param pdev : Selected device
1599 * @retval USB_OTG_STS : status
1601 USB_OTG_STS USB_OTG_EPStartXfer(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1603 USB_OTG_STS status = USB_OTG_OK;
1604 USB_OTG_DEPCTL_TypeDef depctl;
1605 USB_OTG_DEPXFRSIZ_TypeDef deptsiz;
1606 USB_OTG_DSTS_TypeDef dsts;
1607 uint32_t fifoemptymsk = 0;
1614 depctl.d32 = USB_OTG_READ_REG32(&(pdev->regs.INEP_REGS[ep->num]->DIEPCTL));
1615 deptsiz.d32 = USB_OTG_READ_REG32(&(pdev->regs.INEP_REGS[ep->num]->DIEPTSIZ));
1616 /* Zero Length Packet? */
1617 if (ep->xfer_len == 0)
1619 deptsiz.b.xfersize = 0;
1620 deptsiz.b.pktcnt = 1;
1624 /* Program the transfer size and packet count
1625 * as follows: xfersize = N * maxpacket +
1626 * short_packet pktcnt = N + (short_packet
1629 deptsiz.b.xfersize = ep->xfer_len;
1630 deptsiz.b.pktcnt = (ep->xfer_len - 1 + ep->maxpacket) / ep->maxpacket;
1632 if (ep->type == EP_TYPE_ISOC)
1637 USB_OTG_WRITE_REG32(&pdev->regs.INEP_REGS[ep->num]->DIEPTSIZ, deptsiz.d32);
1639 if (pdev->cfg.dma_enable == 1)
1641 USB_OTG_WRITE_REG32(&pdev->regs.INEP_REGS[ep->num]->DIEPDMA, ep->dma_addr);
1645 if (ep->type != EP_TYPE_ISOC)
1647 /* Enable the Tx FIFO Empty Interrupt for this EP */
1648 if (ep->xfer_len > 0)
1650 fifoemptymsk = 1 << ep->num;
1651 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DIEPEMPMSK, 0, fifoemptymsk);
1657 if (ep->type == EP_TYPE_ISOC)
1659 dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
1661 if (((dsts.b.soffn)&0x1) == 0)
1663 depctl.b.setd1pid = 1;
1667 depctl.b.setd0pid = 1;
1671 /* EP enable, IN data in FIFO */
1674 USB_OTG_WRITE_REG32(&pdev->regs.INEP_REGS[ep->num]->DIEPCTL, depctl.d32);
1676 if (ep->type == EP_TYPE_ISOC)
1678 USB_OTG_WritePacket(pdev, ep->xfer_buff, ep->num, ep->xfer_len);
1684 depctl.d32 = USB_OTG_READ_REG32(&(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL));
1685 deptsiz.d32 = USB_OTG_READ_REG32(&(pdev->regs.OUTEP_REGS[ep->num]->DOEPTSIZ));
1686 /* Program the transfer size and packet count as follows:
1688 * xfersize = N * maxpacket
1690 if (ep->xfer_len == 0)
1692 deptsiz.b.xfersize = ep->maxpacket;
1693 deptsiz.b.pktcnt = 1;
1697 deptsiz.b.pktcnt = (ep->xfer_len + (ep->maxpacket - 1)) / ep->maxpacket;
1698 deptsiz.b.xfersize = deptsiz.b.pktcnt * ep->maxpacket;
1700 USB_OTG_WRITE_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPTSIZ, deptsiz.d32);
1702 if (pdev->cfg.dma_enable == 1)
1704 USB_OTG_WRITE_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPDMA, ep->dma_addr);
1707 if (ep->type == EP_TYPE_ISOC)
1709 if (ep->even_odd_frame)
1711 depctl.b.setd1pid = 1;
1715 depctl.b.setd0pid = 1;
1721 USB_OTG_WRITE_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL, depctl.d32);
1728 * @brief USB_OTG_EP0StartXfer : Handle the setup for a data xfer for EP0 and
1730 * @param pdev : Selected device
1731 * @retval USB_OTG_STS : status
1733 USB_OTG_STS USB_OTG_EP0StartXfer(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1735 USB_OTG_STS status = USB_OTG_OK;
1736 USB_OTG_DEPCTL_TypeDef depctl;
1737 USB_OTG_DEP0XFRSIZ_TypeDef deptsiz;
1738 USB_OTG_INEPREGS *in_regs;
1739 uint32_t fifoemptymsk = 0;
1746 in_regs = pdev->regs.INEP_REGS[0];
1747 depctl.d32 = USB_OTG_READ_REG32(&in_regs->DIEPCTL);
1748 deptsiz.d32 = USB_OTG_READ_REG32(&in_regs->DIEPTSIZ);
1749 /* Zero Length Packet? */
1750 if (ep->xfer_len == 0)
1752 deptsiz.b.xfersize = 0;
1753 deptsiz.b.pktcnt = 1;
1758 if (ep->xfer_len > ep->maxpacket)
1760 ep->xfer_len = ep->maxpacket;
1761 deptsiz.b.xfersize = ep->maxpacket;
1765 deptsiz.b.xfersize = ep->xfer_len;
1767 deptsiz.b.pktcnt = 1;
1769 USB_OTG_WRITE_REG32(&in_regs->DIEPTSIZ, deptsiz.d32);
1771 if (pdev->cfg.dma_enable == 1)
1773 USB_OTG_WRITE_REG32(&pdev->regs.INEP_REGS[ep->num]->DIEPDMA, ep->dma_addr);
1776 /* EP enable, IN data in FIFO */
1779 USB_OTG_WRITE_REG32(&in_regs->DIEPCTL, depctl.d32);
1783 if (pdev->cfg.dma_enable == 0)
1785 /* Enable the Tx FIFO Empty Interrupt for this EP */
1786 if (ep->xfer_len > 0)
1789 fifoemptymsk |= 1 << ep->num;
1790 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DIEPEMPMSK, 0, fifoemptymsk);
1798 depctl.d32 = USB_OTG_READ_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL);
1799 deptsiz.d32 = USB_OTG_READ_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPTSIZ);
1800 /* Program the transfer size and packet count as follows:
1801 * xfersize = N * (maxpacket + 4 - (maxpacket % 4))
1803 if (ep->xfer_len == 0)
1805 deptsiz.b.xfersize = ep->maxpacket;
1806 deptsiz.b.pktcnt = 1;
1810 ep->xfer_len = ep->maxpacket;
1811 deptsiz.b.xfersize = ep->maxpacket;
1812 deptsiz.b.pktcnt = 1;
1814 USB_OTG_WRITE_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPTSIZ, deptsiz.d32);
1815 if (pdev->cfg.dma_enable == 1)
1817 USB_OTG_WRITE_REG32(&pdev->regs.OUTEP_REGS[ep->num]->DOEPDMA, ep->dma_addr);
1822 USB_OTG_WRITE_REG32 (&(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL), depctl.d32);
1830 * @brief USB_OTG_EPSetStall : Set the EP STALL
1831 * @param pdev : Selected device
1832 * @retval USB_OTG_STS : status
1834 USB_OTG_STS USB_OTG_EPSetStall(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1836 USB_OTG_STS status = USB_OTG_OK;
1837 USB_OTG_DEPCTL_TypeDef depctl;
1838 __IO uint32_t *depctl_addr;
1843 depctl_addr = &(pdev->regs.INEP_REGS[ep->num]->DIEPCTL);
1844 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
1845 /* set the disable and stall bits */
1851 USB_OTG_WRITE_REG32(depctl_addr, depctl.d32);
1855 depctl_addr = &(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL);
1856 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
1857 /* set the stall bit */
1859 USB_OTG_WRITE_REG32(depctl_addr, depctl.d32);
1866 * @brief Clear the EP STALL
1867 * @param pdev : Selected device
1868 * @retval USB_OTG_STS : status
1870 USB_OTG_STS USB_OTG_EPClearStall(USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep)
1872 USB_OTG_STS status = USB_OTG_OK;
1873 USB_OTG_DEPCTL_TypeDef depctl;
1874 __IO uint32_t *depctl_addr;
1880 depctl_addr = &(pdev->regs.INEP_REGS[ep->num]->DIEPCTL);
1884 depctl_addr = &(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL);
1886 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
1887 /* clear the stall bits */
1889 if (ep->type == EP_TYPE_INTR || ep->type == EP_TYPE_BULK)
1891 depctl.b.setd0pid = 1; /* DATA0 */
1893 USB_OTG_WRITE_REG32(depctl_addr, depctl.d32);
1899 * @brief USB_OTG_ReadDevAllOutEp_itr : returns OUT endpoint interrupt bits
1900 * @param pdev : Selected device
1901 * @retval OUT endpoint interrupt bits
1903 uint32_t USB_OTG_ReadDevAllOutEp_itr(USB_OTG_CORE_HANDLE *pdev)
1906 v = USB_OTG_READ_REG32(&pdev->regs.DREGS->DAINT);
1907 v &= USB_OTG_READ_REG32(&pdev->regs.DREGS->DAINTMSK);
1908 return ((v & 0xffff0000) >> 16);
1913 * @brief USB_OTG_ReadDevOutEP_itr : returns Device OUT EP Interrupt register
1914 * @param pdev : Selected device
1915 * @param ep : end point number
1916 * @retval Device OUT EP Interrupt register
1918 uint32_t USB_OTG_ReadDevOutEP_itr(USB_OTG_CORE_HANDLE *pdev , uint8_t epnum)
1921 v = USB_OTG_READ_REG32(&pdev->regs.OUTEP_REGS[epnum]->DOEPINT);
1922 v &= USB_OTG_READ_REG32(&pdev->regs.DREGS->DOEPMSK);
1928 * @brief USB_OTG_ReadDevAllInEPItr : Get int status register
1929 * @param pdev : Selected device
1930 * @retval int status register
1932 uint32_t USB_OTG_ReadDevAllInEPItr(USB_OTG_CORE_HANDLE *pdev)
1935 v = USB_OTG_READ_REG32(&pdev->regs.DREGS->DAINT);
1936 v &= USB_OTG_READ_REG32(&pdev->regs.DREGS->DAINTMSK);
1937 return (v & 0xffff);
1941 * @brief configures EPO to receive SETUP packets
1945 void USB_OTG_EP0_OutStart(USB_OTG_CORE_HANDLE *pdev)
1947 USB_OTG_DEP0XFRSIZ_TypeDef doeptsize0;
1949 doeptsize0.b.supcnt = 3;
1950 doeptsize0.b.pktcnt = 1;
1951 doeptsize0.b.xfersize = 8 * 3;
1952 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[0]->DOEPTSIZ, doeptsize0.d32 );
1954 if (pdev->cfg.dma_enable == 1)
1956 USB_OTG_DEPCTL_TypeDef doepctl;
1958 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[0]->DOEPDMA,
1959 (uint32_t)&pdev->dev.setup_packet);
1962 doepctl.d32 = USB_OTG_READ_REG32(&pdev->regs.OUTEP_REGS[0]->DOEPCTL);
1963 doepctl.b.epena = 1;
1964 doepctl.d32 = 0x80008000;
1965 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[0]->DOEPCTL, doepctl.d32);
1970 * @brief USB_OTG_RemoteWakeup : active remote wakeup signalling
1974 void USB_OTG_ActiveRemoteWakeup(USB_OTG_CORE_HANDLE *pdev)
1977 USB_OTG_DCTL_TypeDef dctl;
1978 USB_OTG_DSTS_TypeDef dsts;
1979 USB_OTG_PCGCCTL_TypeDef power;
1981 if (pdev->dev.DevRemoteWakeup)
1983 dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
1984 if(dsts.b.suspsts == 1)
1986 if(pdev->cfg.low_power)
1988 /* un-gate USB Core clock */
1989 power.d32 = USB_OTG_READ_REG32(&pdev->regs.PCGCCTL);
1990 power.b.gatehclk = 0;
1991 power.b.stoppclk = 0;
1992 USB_OTG_WRITE_REG32(pdev->regs.PCGCCTL, power.d32);
1994 /* active Remote wakeup signaling */
1996 dctl.b.rmtwkupsig = 1;
1997 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DCTL, 0, dctl.d32);
1998 USB_OTG_BSP_mDelay(5);
1999 USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DCTL, dctl.d32, 0 );
2006 * @brief USB_OTG_UngateClock : active USB Core clock
2010 void USB_OTG_UngateClock(USB_OTG_CORE_HANDLE *pdev)
2012 if(pdev->cfg.low_power)
2015 USB_OTG_DSTS_TypeDef dsts;
2016 USB_OTG_PCGCCTL_TypeDef power;
2018 dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
2020 if(dsts.b.suspsts == 1)
2022 /* un-gate USB Core clock */
2023 power.d32 = USB_OTG_READ_REG32(&pdev->regs.PCGCCTL);
2024 power.b.gatehclk = 0;
2025 power.b.stoppclk = 0;
2026 USB_OTG_WRITE_REG32(pdev->regs.PCGCCTL, power.d32);
2033 * @brief Stop the device and clean up fifo's
2037 void USB_OTG_StopDevice(USB_OTG_CORE_HANDLE *pdev)
2041 pdev->dev.device_status = 1;
2043 for (i = 0; i < pdev->cfg.dev_endpoints ; i++)
2045 USB_OTG_WRITE_REG32( &pdev->regs.INEP_REGS[i]->DIEPINT, 0xFF);
2046 USB_OTG_WRITE_REG32( &pdev->regs.OUTEP_REGS[i]->DOEPINT, 0xFF);
2049 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DIEPMSK, 0 );
2050 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DOEPMSK, 0 );
2051 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DAINTMSK, 0 );
2052 USB_OTG_WRITE_REG32( &pdev->regs.DREGS->DAINT, 0xFFFFFFFF );
2054 /* Flush the FIFO */
2055 USB_OTG_FlushRxFifo(pdev);
2056 USB_OTG_FlushTxFifo(pdev , 0x10 );
2060 * @brief returns the EP Status
2061 * @param pdev : Selected device
2062 * ep : endpoint structure
2063 * @retval : EP status
2066 uint32_t USB_OTG_GetEPStatus(USB_OTG_CORE_HANDLE *pdev ,USB_OTG_EP *ep)
2068 USB_OTG_DEPCTL_TypeDef depctl;
2069 __IO uint32_t *depctl_addr;
2070 uint32_t Status = 0;
2075 depctl_addr = &(pdev->regs.INEP_REGS[ep->num]->DIEPCTL);
2076 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
2078 if (depctl.b.stall == 1)
2079 Status = USB_OTG_EP_TX_STALL;
2080 else if (depctl.b.naksts == 1)
2081 Status = USB_OTG_EP_TX_NAK;
2083 Status = USB_OTG_EP_TX_VALID;
2088 depctl_addr = &(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL);
2089 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
2090 if (depctl.b.stall == 1)
2091 Status = USB_OTG_EP_RX_STALL;
2092 else if (depctl.b.naksts == 1)
2093 Status = USB_OTG_EP_RX_NAK;
2095 Status = USB_OTG_EP_RX_VALID;
2098 /* Return the current status */
2103 * @brief Set the EP Status
2104 * @param pdev : Selected device
2105 * Status : new Status
2109 void USB_OTG_SetEPStatus (USB_OTG_CORE_HANDLE *pdev , USB_OTG_EP *ep , uint32_t Status)
2111 USB_OTG_DEPCTL_TypeDef depctl;
2112 __IO uint32_t *depctl_addr;
2116 /* Process for IN endpoint */
2119 depctl_addr = &(pdev->regs.INEP_REGS[ep->num]->DIEPCTL);
2120 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
2122 if (Status == USB_OTG_EP_TX_STALL)
2124 USB_OTG_EPSetStall(pdev, ep); return;
2126 else if (Status == USB_OTG_EP_TX_NAK)
2128 else if (Status == USB_OTG_EP_TX_VALID)
2130 if (depctl.b.stall == 1)
2132 ep->even_odd_frame = 0;
2133 USB_OTG_EPClearStall(pdev, ep);
2137 depctl.b.usbactep = 1;
2140 else if (Status == USB_OTG_EP_TX_DIS)
2141 depctl.b.usbactep = 0;
2143 else /* Process for OUT endpoint */
2145 depctl_addr = &(pdev->regs.OUTEP_REGS[ep->num]->DOEPCTL);
2146 depctl.d32 = USB_OTG_READ_REG32(depctl_addr);
2148 if (Status == USB_OTG_EP_RX_STALL) {
2151 else if (Status == USB_OTG_EP_RX_NAK)
2153 else if (Status == USB_OTG_EP_RX_VALID)
2155 if (depctl.b.stall == 1)
2157 ep->even_odd_frame = 0;
2158 USB_OTG_EPClearStall(pdev, ep);
2162 depctl.b.usbactep = 1;
2165 else if (Status == USB_OTG_EP_RX_DIS)
2167 depctl.b.usbactep = 0;
2171 USB_OTG_WRITE_REG32(depctl_addr, depctl.d32);
2187 /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/