Subversion Repositories LedShow

Rev

Rev 2 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_hcd.c
  4.   * @author  MCD Application Team
  5.   * @brief   HCD HAL module driver.
  6.   *          This file provides firmware functions to manage the following
  7.   *          functionalities of the USB Peripheral Controller:
  8.   *           + Initialization and de-initialization functions
  9.   *           + IO operation functions
  10.   *           + Peripheral Control functions
  11.   *           + Peripheral State functions
  12.   *
  13.   @verbatim
  14.   ==============================================================================
  15.                     ##### How to use this driver #####
  16.   ==============================================================================
  17.   [..]
  18.     (#)Declare a HCD_HandleTypeDef handle structure, for example:
  19.        HCD_HandleTypeDef  hhcd;
  20.  
  21.     (#)Fill parameters of Init structure in HCD handle
  22.  
  23.     (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)
  24.  
  25.     (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
  26.         (##) Enable the HCD/USB Low Level interface clock using the following macros
  27.              (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
  28.         (##) Initialize the related GPIO clocks
  29.         (##) Configure HCD pin-out
  30.         (##) Configure HCD NVIC interrupt
  31.  
  32.     (#)Associate the Upper USB Host stack to the HAL HCD Driver:
  33.         (##) hhcd.pData = phost;
  34.  
  35.     (#)Enable HCD transmission and reception:
  36.         (##) HAL_HCD_Start();
  37.  
  38.   @endverbatim
  39.   ******************************************************************************
  40.   * @attention
  41.   *
  42.   * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
  43.   * All rights reserved.</center></h2>
  44.   *
  45.   * This software component is licensed by ST under BSD 3-Clause license,
  46.   * the "License"; You may not use this file except in compliance with the
  47.   * License. You may obtain a copy of the License at:
  48.   *                        opensource.org/licenses/BSD-3-Clause
  49.   *
  50.   ******************************************************************************
  51.   */
  52.  
  53. /* Includes ------------------------------------------------------------------*/
  54. #include "stm32f1xx_hal.h"
  55.  
  56. /** @addtogroup STM32F1xx_HAL_Driver
  57.   * @{
  58.   */
  59.  
  60. #ifdef HAL_HCD_MODULE_ENABLED
  61.  
  62. #if defined (USB_OTG_FS)
  63.  
  64. /** @defgroup HCD HCD
  65.   * @brief HCD HAL module driver
  66.   * @{
  67.   */
  68.  
  69. /* Private typedef -----------------------------------------------------------*/
  70. /* Private define ------------------------------------------------------------*/
  71. /* Private macro -------------------------------------------------------------*/
  72. /* Private variables ---------------------------------------------------------*/
  73. /* Private function prototypes -----------------------------------------------*/
  74. /** @defgroup HCD_Private_Functions HCD Private Functions
  75.   * @{
  76.   */
  77. static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
  78. static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
  79. static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd);
  80. static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd);
  81. /**
  82.   * @}
  83.   */
  84.  
  85. /* Exported functions --------------------------------------------------------*/
  86. /** @defgroup HCD_Exported_Functions HCD Exported Functions
  87.   * @{
  88.   */
  89.  
  90. /** @defgroup HCD_Exported_Functions_Group1 Initialization and de-initialization functions
  91.   *  @brief    Initialization and Configuration functions
  92.   *
  93. @verbatim
  94.  ===============================================================================
  95.           ##### Initialization and de-initialization functions #####
  96.  ===============================================================================
  97.     [..]  This section provides functions allowing to:
  98.  
  99. @endverbatim
  100.   * @{
  101.   */
  102.  
  103. /**
  104.   * @brief  Initialize the host driver.
  105.   * @param  hhcd HCD handle
  106.   * @retval HAL status
  107.   */
  108. HAL_StatusTypeDef HAL_HCD_Init(HCD_HandleTypeDef *hhcd)
  109. {
  110.   USB_OTG_GlobalTypeDef *USBx;
  111.  
  112.   /* Check the HCD handle allocation */
  113.   if (hhcd == NULL)
  114.   {
  115.     return HAL_ERROR;
  116.   }
  117.  
  118.   /* Check the parameters */
  119.   assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance));
  120.  
  121.   USBx = hhcd->Instance;
  122.  
  123.   if (hhcd->State == HAL_HCD_STATE_RESET)
  124.   {
  125.     /* Allocate lock resource and initialize it */
  126.     hhcd->Lock = HAL_UNLOCKED;
  127.  
  128. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  129.     hhcd->SOFCallback = HAL_HCD_SOF_Callback;
  130.     hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
  131.     hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
  132.     hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
  133.     hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
  134.     hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback;
  135.  
  136.     if (hhcd->MspInitCallback == NULL)
  137.     {
  138.       hhcd->MspInitCallback = HAL_HCD_MspInit;
  139.     }
  140.  
  141.     /* Init the low level hardware */
  142.     hhcd->MspInitCallback(hhcd);
  143. #else
  144.     /* Init the low level hardware : GPIO, CLOCK, NVIC... */
  145.     HAL_HCD_MspInit(hhcd);
  146. #endif /* (USE_HAL_HCD_REGISTER_CALLBACKS) */
  147.   }
  148.  
  149.   hhcd->State = HAL_HCD_STATE_BUSY;
  150.  
  151.   /* Disable DMA mode for FS instance */
  152.   if ((USBx->CID & (0x1U << 8)) == 0U)
  153.   {
  154.     hhcd->Init.dma_enable = 0U;
  155.   }
  156.  
  157.   /* Disable the Interrupts */
  158.   __HAL_HCD_DISABLE(hhcd);
  159.  
  160.   /* Init the Core (common init.) */
  161.   (void)USB_CoreInit(hhcd->Instance, hhcd->Init);
  162.  
  163.   /* Force Host Mode*/
  164.   (void)USB_SetCurrentMode(hhcd->Instance, USB_HOST_MODE);
  165.  
  166.   /* Init Host */
  167.   (void)USB_HostInit(hhcd->Instance, hhcd->Init);
  168.  
  169.   hhcd->State = HAL_HCD_STATE_READY;
  170.  
  171.   return HAL_OK;
  172. }
  173.  
  174. /**
  175.   * @brief  Initialize a host channel.
  176.   * @param  hhcd HCD handle
  177.   * @param  ch_num Channel number.
  178.   *         This parameter can be a value from 1 to 15
  179.   * @param  epnum Endpoint number.
  180.   *          This parameter can be a value from 1 to 15
  181.   * @param  dev_address Current device address
  182.   *          This parameter can be a value from 0 to 255
  183.   * @param  speed Current device speed.
  184.   *          This parameter can be one of these values:
  185.   *            HCD_SPEED_FULL: Full speed mode,
  186.   *            HCD_SPEED_LOW: Low speed mode
  187.   * @param  ep_type Endpoint Type.
  188.   *          This parameter can be one of these values:
  189.   *            EP_TYPE_CTRL: Control type,
  190.   *            EP_TYPE_ISOC: Isochronous type,
  191.   *            EP_TYPE_BULK: Bulk type,
  192.   *            EP_TYPE_INTR: Interrupt type
  193.   * @param  mps Max Packet Size.
  194.   *          This parameter can be a value from 0 to32K
  195.   * @retval HAL status
  196.   */
  197. HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd,
  198.                                   uint8_t ch_num,
  199.                                   uint8_t epnum,
  200.                                   uint8_t dev_address,
  201.                                   uint8_t speed,
  202.                                   uint8_t ep_type,
  203.                                   uint16_t mps)
  204. {
  205.   HAL_StatusTypeDef status;
  206.  
  207.   __HAL_LOCK(hhcd);
  208.   hhcd->hc[ch_num].do_ping = 0U;
  209.   hhcd->hc[ch_num].dev_addr = dev_address;
  210.   hhcd->hc[ch_num].max_packet = mps;
  211.   hhcd->hc[ch_num].ch_num = ch_num;
  212.   hhcd->hc[ch_num].ep_type = ep_type;
  213.   hhcd->hc[ch_num].ep_num = epnum & 0x7FU;
  214.  
  215.   if ((epnum & 0x80U) == 0x80U)
  216.   {
  217.     hhcd->hc[ch_num].ep_is_in = 1U;
  218.   }
  219.   else
  220.   {
  221.     hhcd->hc[ch_num].ep_is_in = 0U;
  222.   }
  223.  
  224.   hhcd->hc[ch_num].speed = speed;
  225.  
  226.   status =  USB_HC_Init(hhcd->Instance,
  227.                         ch_num,
  228.                         epnum,
  229.                         dev_address,
  230.                         speed,
  231.                         ep_type,
  232.                         mps);
  233.   __HAL_UNLOCK(hhcd);
  234.  
  235.   return status;
  236. }
  237.  
  238. /**
  239.   * @brief  Halt a host channel.
  240.   * @param  hhcd HCD handle
  241.   * @param  ch_num Channel number.
  242.   *         This parameter can be a value from 1 to 15
  243.   * @retval HAL status
  244.   */
  245. HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd, uint8_t ch_num)
  246. {
  247.   HAL_StatusTypeDef status = HAL_OK;
  248.  
  249.   __HAL_LOCK(hhcd);
  250.   (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  251.   __HAL_UNLOCK(hhcd);
  252.  
  253.   return status;
  254. }
  255.  
  256. /**
  257.   * @brief  DeInitialize the host driver.
  258.   * @param  hhcd HCD handle
  259.   * @retval HAL status
  260.   */
  261. HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd)
  262. {
  263.   /* Check the HCD handle allocation */
  264.   if (hhcd == NULL)
  265.   {
  266.     return HAL_ERROR;
  267.   }
  268.  
  269.   hhcd->State = HAL_HCD_STATE_BUSY;
  270.  
  271. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  272.   if (hhcd->MspDeInitCallback == NULL)
  273.   {
  274.     hhcd->MspDeInitCallback = HAL_HCD_MspDeInit; /* Legacy weak MspDeInit  */
  275.   }
  276.  
  277.   /* DeInit the low level hardware */
  278.   hhcd->MspDeInitCallback(hhcd);
  279. #else
  280.   /* DeInit the low level hardware: CLOCK, NVIC.*/
  281.   HAL_HCD_MspDeInit(hhcd);
  282. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  283.  
  284.   __HAL_HCD_DISABLE(hhcd);
  285.  
  286.   hhcd->State = HAL_HCD_STATE_RESET;
  287.  
  288.   return HAL_OK;
  289. }
  290.  
  291. /**
  292.   * @brief  Initialize the HCD MSP.
  293.   * @param  hhcd HCD handle
  294.   * @retval None
  295.   */
  296. __weak void  HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd)
  297. {
  298.   /* Prevent unused argument(s) compilation warning */
  299.   UNUSED(hhcd);
  300.  
  301.   /* NOTE : This function should not be modified, when the callback is needed,
  302.             the HAL_HCD_MspInit could be implemented in the user file
  303.    */
  304. }
  305.  
  306. /**
  307.   * @brief  DeInitialize the HCD MSP.
  308.   * @param  hhcd HCD handle
  309.   * @retval None
  310.   */
  311. __weak void  HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd)
  312. {
  313.   /* Prevent unused argument(s) compilation warning */
  314.   UNUSED(hhcd);
  315.  
  316.   /* NOTE : This function should not be modified, when the callback is needed,
  317.             the HAL_HCD_MspDeInit could be implemented in the user file
  318.    */
  319. }
  320.  
  321. /**
  322.   * @}
  323.   */
  324.  
  325. /** @defgroup HCD_Exported_Functions_Group2 Input and Output operation functions
  326.   *  @brief   HCD IO operation functions
  327.   *
  328. @verbatim
  329.  ===============================================================================
  330.                       ##### IO operation functions #####
  331.  ===============================================================================
  332.  [..] This subsection provides a set of functions allowing to manage the USB Host Data
  333.     Transfer
  334.  
  335. @endverbatim
  336.   * @{
  337.   */
  338.  
  339. /**
  340.   * @brief  Submit a new URB for processing.
  341.   * @param  hhcd HCD handle
  342.   * @param  ch_num Channel number.
  343.   *         This parameter can be a value from 1 to 15
  344.   * @param  direction Channel number.
  345.   *          This parameter can be one of these values:
  346.   *           0 : Output / 1 : Input
  347.   * @param  ep_type Endpoint Type.
  348.   *          This parameter can be one of these values:
  349.   *            EP_TYPE_CTRL: Control type/
  350.   *            EP_TYPE_ISOC: Isochronous type/
  351.   *            EP_TYPE_BULK: Bulk type/
  352.   *            EP_TYPE_INTR: Interrupt type/
  353.   * @param  token Endpoint Type.
  354.   *          This parameter can be one of these values:
  355.   *            0: HC_PID_SETUP / 1: HC_PID_DATA1
  356.   * @param  pbuff pointer to URB data
  357.   * @param  length Length of URB data
  358.   * @param  do_ping activate do ping protocol (for high speed only).
  359.   *          This parameter can be one of these values:
  360.   *           0 : do ping inactive / 1 : do ping active
  361.   * @retval HAL status
  362.   */
  363. HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd,
  364.                                            uint8_t ch_num,
  365.                                            uint8_t direction,
  366.                                            uint8_t ep_type,
  367.                                            uint8_t token,
  368.                                            uint8_t *pbuff,
  369.                                            uint16_t length,
  370.                                            uint8_t do_ping)
  371. {
  372.   hhcd->hc[ch_num].ep_is_in = direction;
  373.   hhcd->hc[ch_num].ep_type  = ep_type;
  374.  
  375.   if (token == 0U)
  376.   {
  377.     hhcd->hc[ch_num].data_pid = HC_PID_SETUP;
  378.     hhcd->hc[ch_num].do_ping = do_ping;
  379.   }
  380.   else
  381.   {
  382.     hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  383.   }
  384.  
  385.   /* Manage Data Toggle */
  386.   switch (ep_type)
  387.   {
  388.     case EP_TYPE_CTRL:
  389.       if ((token == 1U) && (direction == 0U)) /*send data */
  390.       {
  391.         if (length == 0U)
  392.         {
  393.           /* For Status OUT stage, Length==0, Status Out PID = 1 */
  394.           hhcd->hc[ch_num].toggle_out = 1U;
  395.         }
  396.  
  397.         /* Set the Data Toggle bit as per the Flag */
  398.         if (hhcd->hc[ch_num].toggle_out == 0U)
  399.         {
  400.           /* Put the PID 0 */
  401.           hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  402.         }
  403.         else
  404.         {
  405.           /* Put the PID 1 */
  406.           hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  407.         }
  408.       }
  409.       break;
  410.  
  411.     case EP_TYPE_BULK:
  412.       if (direction == 0U)
  413.       {
  414.         /* Set the Data Toggle bit as per the Flag */
  415.         if (hhcd->hc[ch_num].toggle_out == 0U)
  416.         {
  417.           /* Put the PID 0 */
  418.           hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  419.         }
  420.         else
  421.         {
  422.           /* Put the PID 1 */
  423.           hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  424.         }
  425.       }
  426.       else
  427.       {
  428.         if (hhcd->hc[ch_num].toggle_in == 0U)
  429.         {
  430.           hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  431.         }
  432.         else
  433.         {
  434.           hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  435.         }
  436.       }
  437.  
  438.       break;
  439.     case EP_TYPE_INTR:
  440.       if (direction == 0U)
  441.       {
  442.         /* Set the Data Toggle bit as per the Flag */
  443.         if (hhcd->hc[ch_num].toggle_out == 0U)
  444.         {
  445.           /* Put the PID 0 */
  446.           hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  447.         }
  448.         else
  449.         {
  450.           /* Put the PID 1 */
  451.           hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  452.         }
  453.       }
  454.       else
  455.       {
  456.         if (hhcd->hc[ch_num].toggle_in == 0U)
  457.         {
  458.           hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  459.         }
  460.         else
  461.         {
  462.           hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
  463.         }
  464.       }
  465.       break;
  466.  
  467.     case EP_TYPE_ISOC:
  468.       hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
  469.       break;
  470.  
  471.     default:
  472.       break;
  473.   }
  474.  
  475.   hhcd->hc[ch_num].xfer_buff = pbuff;
  476.   hhcd->hc[ch_num].xfer_len  = length;
  477.   hhcd->hc[ch_num].urb_state = URB_IDLE;
  478.   hhcd->hc[ch_num].xfer_count = 0U;
  479.   hhcd->hc[ch_num].ch_num = ch_num;
  480.   hhcd->hc[ch_num].state = HC_IDLE;
  481.  
  482.   return USB_HC_StartXfer(hhcd->Instance, &hhcd->hc[ch_num]);
  483. }
  484.  
  485. /**
  486.   * @brief  Handle HCD interrupt request.
  487.   * @param  hhcd HCD handle
  488.   * @retval None
  489.   */
  490. void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
  491. {
  492.   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
  493.   uint32_t USBx_BASE = (uint32_t)USBx;
  494.   uint32_t i, interrupt;
  495.  
  496.   /* Ensure that we are in device mode */
  497.   if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
  498.   {
  499.     /* Avoid spurious interrupt */
  500.     if (__HAL_HCD_IS_INVALID_INTERRUPT(hhcd))
  501.     {
  502.       return;
  503.     }
  504.  
  505.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
  506.     {
  507.       /* Incorrect mode, acknowledge the interrupt */
  508.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
  509.     }
  510.  
  511.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
  512.     {
  513.       /* Incorrect mode, acknowledge the interrupt */
  514.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
  515.     }
  516.  
  517.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
  518.     {
  519.       /* Incorrect mode, acknowledge the interrupt */
  520.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
  521.     }
  522.  
  523.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
  524.     {
  525.       /* Incorrect mode, acknowledge the interrupt */
  526.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
  527.     }
  528.  
  529.     /* Handle Host Disconnect Interrupts */
  530.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
  531.     {
  532.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
  533.  
  534.       if ((USBx_HPRT0 & USB_OTG_HPRT_PCSTS) == 0U)
  535.       {
  536.         /* Handle Host Port Disconnect Interrupt */
  537. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  538.         hhcd->DisconnectCallback(hhcd);
  539. #else
  540.         HAL_HCD_Disconnect_Callback(hhcd);
  541. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  542.  
  543.         (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
  544.       }
  545.     }
  546.  
  547.     /* Handle Host Port Interrupts */
  548.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
  549.     {
  550.       HCD_Port_IRQHandler(hhcd);
  551.     }
  552.  
  553.     /* Handle Host SOF Interrupt */
  554.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
  555.     {
  556. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  557.       hhcd->SOFCallback(hhcd);
  558. #else
  559.       HAL_HCD_SOF_Callback(hhcd);
  560. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  561.  
  562.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
  563.     }
  564.  
  565.     /* Handle Host channel Interrupt */
  566.     if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
  567.     {
  568.       interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
  569.       for (i = 0U; i < hhcd->Init.Host_channels; i++)
  570.       {
  571.         if ((interrupt & (1UL << (i & 0xFU))) != 0U)
  572.         {
  573.           if ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_EPDIR) == USB_OTG_HCCHAR_EPDIR)
  574.           {
  575.             HCD_HC_IN_IRQHandler(hhcd, (uint8_t)i);
  576.           }
  577.           else
  578.           {
  579.             HCD_HC_OUT_IRQHandler(hhcd, (uint8_t)i);
  580.           }
  581.         }
  582.       }
  583.       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
  584.     }
  585.  
  586.     /* Handle Rx Queue Level Interrupts */
  587.     if ((__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL)) != 0U)
  588.     {
  589.       USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
  590.  
  591.       HCD_RXQLVL_IRQHandler(hhcd);
  592.  
  593.       USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
  594.     }
  595.   }
  596. }
  597.  
  598.  
  599. /**
  600.   * @brief  Handles HCD Wakeup interrupt request.
  601.   * @param  hhcd HCD handle
  602.   * @retval HAL status
  603.   */
  604. void HAL_HCD_WKUP_IRQHandler(HCD_HandleTypeDef *hhcd)
  605. {
  606.   UNUSED(hhcd);
  607. }
  608.  
  609.  
  610. /**
  611.   * @brief  SOF callback.
  612.   * @param  hhcd HCD handle
  613.   * @retval None
  614.   */
  615. __weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd)
  616. {
  617.   /* Prevent unused argument(s) compilation warning */
  618.   UNUSED(hhcd);
  619.  
  620.   /* NOTE : This function should not be modified, when the callback is needed,
  621.             the HAL_HCD_SOF_Callback could be implemented in the user file
  622.    */
  623. }
  624.  
  625. /**
  626.   * @brief Connection Event callback.
  627.   * @param  hhcd HCD handle
  628.   * @retval None
  629.   */
  630. __weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd)
  631. {
  632.   /* Prevent unused argument(s) compilation warning */
  633.   UNUSED(hhcd);
  634.  
  635.   /* NOTE : This function should not be modified, when the callback is needed,
  636.             the HAL_HCD_Connect_Callback could be implemented in the user file
  637.    */
  638. }
  639.  
  640. /**
  641.   * @brief  Disconnection Event callback.
  642.   * @param  hhcd HCD handle
  643.   * @retval None
  644.   */
  645. __weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd)
  646. {
  647.   /* Prevent unused argument(s) compilation warning */
  648.   UNUSED(hhcd);
  649.  
  650.   /* NOTE : This function should not be modified, when the callback is needed,
  651.             the HAL_HCD_Disconnect_Callback could be implemented in the user file
  652.    */
  653. }
  654.  
  655. /**
  656.   * @brief  Port Enabled  Event callback.
  657.   * @param  hhcd HCD handle
  658.   * @retval None
  659.   */
  660. __weak void HAL_HCD_PortEnabled_Callback(HCD_HandleTypeDef *hhcd)
  661. {
  662.   /* Prevent unused argument(s) compilation warning */
  663.   UNUSED(hhcd);
  664.  
  665.   /* NOTE : This function should not be modified, when the callback is needed,
  666.             the HAL_HCD_Disconnect_Callback could be implemented in the user file
  667.    */
  668. }
  669.  
  670. /**
  671.   * @brief  Port Disabled  Event callback.
  672.   * @param  hhcd HCD handle
  673.   * @retval None
  674.   */
  675. __weak void HAL_HCD_PortDisabled_Callback(HCD_HandleTypeDef *hhcd)
  676. {
  677.   /* Prevent unused argument(s) compilation warning */
  678.   UNUSED(hhcd);
  679.  
  680.   /* NOTE : This function should not be modified, when the callback is needed,
  681.             the HAL_HCD_Disconnect_Callback could be implemented in the user file
  682.    */
  683. }
  684.  
  685. /**
  686.   * @brief  Notify URB state change callback.
  687.   * @param  hhcd HCD handle
  688.   * @param  chnum Channel number.
  689.   *         This parameter can be a value from 1 to 15
  690.   * @param  urb_state:
  691.   *          This parameter can be one of these values:
  692.   *            URB_IDLE/
  693.   *            URB_DONE/
  694.   *            URB_NOTREADY/
  695.   *            URB_NYET/
  696.   *            URB_ERROR/
  697.   *            URB_STALL/
  698.   * @retval None
  699.   */
  700. __weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
  701. {
  702.   /* Prevent unused argument(s) compilation warning */
  703.   UNUSED(hhcd);
  704.   UNUSED(chnum);
  705.   UNUSED(urb_state);
  706.  
  707.   /* NOTE : This function should not be modified, when the callback is needed,
  708.             the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file
  709.    */
  710. }
  711.  
  712. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  713. /**
  714.   * @brief  Register a User USB HCD Callback
  715.   *         To be used instead of the weak predefined callback
  716.   * @param  hhcd USB HCD handle
  717.   * @param  CallbackID ID of the callback to be registered
  718.   *         This parameter can be one of the following values:
  719.   *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
  720.   *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
  721.   *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
  722.   *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enable callback ID
  723.   *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disable callback ID
  724.   *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
  725.   *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
  726.   * @param  pCallback pointer to the Callback function
  727.   * @retval HAL status
  728.   */
  729. HAL_StatusTypeDef HAL_HCD_RegisterCallback(HCD_HandleTypeDef *hhcd,
  730.                                            HAL_HCD_CallbackIDTypeDef CallbackID,
  731.                                            pHCD_CallbackTypeDef pCallback)
  732. {
  733.   HAL_StatusTypeDef status = HAL_OK;
  734.  
  735.   if (pCallback == NULL)
  736.   {
  737.     /* Update the error code */
  738.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  739.     return HAL_ERROR;
  740.   }
  741.   /* Process locked */
  742.   __HAL_LOCK(hhcd);
  743.  
  744.   if (hhcd->State == HAL_HCD_STATE_READY)
  745.   {
  746.     switch (CallbackID)
  747.     {
  748.       case HAL_HCD_SOF_CB_ID :
  749.         hhcd->SOFCallback = pCallback;
  750.         break;
  751.  
  752.       case HAL_HCD_CONNECT_CB_ID :
  753.         hhcd->ConnectCallback = pCallback;
  754.         break;
  755.  
  756.       case HAL_HCD_DISCONNECT_CB_ID :
  757.         hhcd->DisconnectCallback = pCallback;
  758.         break;
  759.  
  760.       case HAL_HCD_PORT_ENABLED_CB_ID :
  761.         hhcd->PortEnabledCallback = pCallback;
  762.         break;
  763.  
  764.       case HAL_HCD_PORT_DISABLED_CB_ID :
  765.         hhcd->PortDisabledCallback = pCallback;
  766.         break;
  767.  
  768.       case HAL_HCD_MSPINIT_CB_ID :
  769.         hhcd->MspInitCallback = pCallback;
  770.         break;
  771.  
  772.       case HAL_HCD_MSPDEINIT_CB_ID :
  773.         hhcd->MspDeInitCallback = pCallback;
  774.         break;
  775.  
  776.       default :
  777.         /* Update the error code */
  778.         hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  779.         /* Return error status */
  780.         status =  HAL_ERROR;
  781.         break;
  782.     }
  783.   }
  784.   else if (hhcd->State == HAL_HCD_STATE_RESET)
  785.   {
  786.     switch (CallbackID)
  787.     {
  788.       case HAL_HCD_MSPINIT_CB_ID :
  789.         hhcd->MspInitCallback = pCallback;
  790.         break;
  791.  
  792.       case HAL_HCD_MSPDEINIT_CB_ID :
  793.         hhcd->MspDeInitCallback = pCallback;
  794.         break;
  795.  
  796.       default :
  797.         /* Update the error code */
  798.         hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  799.         /* Return error status */
  800.         status =  HAL_ERROR;
  801.         break;
  802.     }
  803.   }
  804.   else
  805.   {
  806.     /* Update the error code */
  807.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  808.     /* Return error status */
  809.     status =  HAL_ERROR;
  810.   }
  811.  
  812.   /* Release Lock */
  813.   __HAL_UNLOCK(hhcd);
  814.   return status;
  815. }
  816.  
  817. /**
  818.   * @brief  Unregister an USB HCD Callback
  819.   *         USB HCD callback is redirected to the weak predefined callback
  820.   * @param  hhcd USB HCD handle
  821.   * @param  CallbackID ID of the callback to be unregistered
  822.   *         This parameter can be one of the following values:
  823.   *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
  824.   *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
  825.   *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
  826.   *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enabled callback ID
  827.   *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disabled callback ID
  828.   *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
  829.   *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
  830.   * @retval HAL status
  831.   */
  832. HAL_StatusTypeDef HAL_HCD_UnRegisterCallback(HCD_HandleTypeDef *hhcd, HAL_HCD_CallbackIDTypeDef CallbackID)
  833. {
  834.   HAL_StatusTypeDef status = HAL_OK;
  835.  
  836.   /* Process locked */
  837.   __HAL_LOCK(hhcd);
  838.  
  839.   /* Setup Legacy weak Callbacks  */
  840.   if (hhcd->State == HAL_HCD_STATE_READY)
  841.   {
  842.     switch (CallbackID)
  843.     {
  844.       case HAL_HCD_SOF_CB_ID :
  845.         hhcd->SOFCallback = HAL_HCD_SOF_Callback;
  846.         break;
  847.  
  848.       case HAL_HCD_CONNECT_CB_ID :
  849.         hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
  850.         break;
  851.  
  852.       case HAL_HCD_DISCONNECT_CB_ID :
  853.         hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
  854.         break;
  855.  
  856.       case HAL_HCD_PORT_ENABLED_CB_ID :
  857.         hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
  858.         break;
  859.  
  860.       case HAL_HCD_PORT_DISABLED_CB_ID :
  861.         hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
  862.         break;
  863.  
  864.       case HAL_HCD_MSPINIT_CB_ID :
  865.         hhcd->MspInitCallback = HAL_HCD_MspInit;
  866.         break;
  867.  
  868.       case HAL_HCD_MSPDEINIT_CB_ID :
  869.         hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
  870.         break;
  871.  
  872.       default :
  873.         /* Update the error code */
  874.         hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  875.  
  876.         /* Return error status */
  877.         status =  HAL_ERROR;
  878.         break;
  879.     }
  880.   }
  881.   else if (hhcd->State == HAL_HCD_STATE_RESET)
  882.   {
  883.     switch (CallbackID)
  884.     {
  885.       case HAL_HCD_MSPINIT_CB_ID :
  886.         hhcd->MspInitCallback = HAL_HCD_MspInit;
  887.         break;
  888.  
  889.       case HAL_HCD_MSPDEINIT_CB_ID :
  890.         hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
  891.         break;
  892.  
  893.       default :
  894.         /* Update the error code */
  895.         hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  896.  
  897.         /* Return error status */
  898.         status =  HAL_ERROR;
  899.         break;
  900.     }
  901.   }
  902.   else
  903.   {
  904.     /* Update the error code */
  905.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  906.  
  907.     /* Return error status */
  908.     status =  HAL_ERROR;
  909.   }
  910.  
  911.   /* Release Lock */
  912.   __HAL_UNLOCK(hhcd);
  913.   return status;
  914. }
  915.  
  916. /**
  917.   * @brief  Register USB HCD Host Channel Notify URB Change Callback
  918.   *         To be used instead of the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
  919.   * @param  hhcd HCD handle
  920.   * @param  pCallback pointer to the USB HCD Host Channel Notify URB Change Callback function
  921.   * @retval HAL status
  922.   */
  923. HAL_StatusTypeDef HAL_HCD_RegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd,
  924.                                                              pHCD_HC_NotifyURBChangeCallbackTypeDef pCallback)
  925. {
  926.   HAL_StatusTypeDef status = HAL_OK;
  927.  
  928.   if (pCallback == NULL)
  929.   {
  930.     /* Update the error code */
  931.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  932.  
  933.     return HAL_ERROR;
  934.   }
  935.  
  936.   /* Process locked */
  937.   __HAL_LOCK(hhcd);
  938.  
  939.   if (hhcd->State == HAL_HCD_STATE_READY)
  940.   {
  941.     hhcd->HC_NotifyURBChangeCallback = pCallback;
  942.   }
  943.   else
  944.   {
  945.     /* Update the error code */
  946.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  947.  
  948.     /* Return error status */
  949.     status =  HAL_ERROR;
  950.   }
  951.  
  952.   /* Release Lock */
  953.   __HAL_UNLOCK(hhcd);
  954.  
  955.   return status;
  956. }
  957.  
  958. /**
  959.   * @brief  Unregister the USB HCD Host Channel Notify URB Change Callback
  960.   *         USB HCD Host Channel Notify URB Change Callback is redirected to the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
  961.   * @param  hhcd HCD handle
  962.   * @retval HAL status
  963.   */
  964. HAL_StatusTypeDef HAL_HCD_UnRegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd)
  965. {
  966.   HAL_StatusTypeDef status = HAL_OK;
  967.  
  968.   /* Process locked */
  969.   __HAL_LOCK(hhcd);
  970.  
  971.   if (hhcd->State == HAL_HCD_STATE_READY)
  972.   {
  973.     hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback; /* Legacy weak DataOutStageCallback  */
  974.   }
  975.   else
  976.   {
  977.     /* Update the error code */
  978.     hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
  979.  
  980.     /* Return error status */
  981.     status =  HAL_ERROR;
  982.   }
  983.  
  984.   /* Release Lock */
  985.   __HAL_UNLOCK(hhcd);
  986.  
  987.   return status;
  988. }
  989. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  990.  
  991. /**
  992.   * @}
  993.   */
  994.  
  995. /** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions
  996.   *  @brief   Management functions
  997.   *
  998. @verbatim
  999.  ===============================================================================
  1000.                       ##### Peripheral Control functions #####
  1001.  ===============================================================================
  1002.     [..]
  1003.     This subsection provides a set of functions allowing to control the HCD data
  1004.     transfers.
  1005.  
  1006. @endverbatim
  1007.   * @{
  1008.   */
  1009.  
  1010. /**
  1011.   * @brief  Start the host driver.
  1012.   * @param  hhcd HCD handle
  1013.   * @retval HAL status
  1014.   */
  1015. HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd)
  1016. {
  1017.   __HAL_LOCK(hhcd);
  1018.   __HAL_HCD_ENABLE(hhcd);
  1019.   (void)USB_DriveVbus(hhcd->Instance, 1U);
  1020.   __HAL_UNLOCK(hhcd);
  1021.  
  1022.   return HAL_OK;
  1023. }
  1024.  
  1025. /**
  1026.   * @brief  Stop the host driver.
  1027.   * @param  hhcd HCD handle
  1028.   * @retval HAL status
  1029.   */
  1030.  
  1031. HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd)
  1032. {
  1033.   __HAL_LOCK(hhcd);
  1034.   (void)USB_StopHost(hhcd->Instance);
  1035.   __HAL_UNLOCK(hhcd);
  1036.  
  1037.   return HAL_OK;
  1038. }
  1039.  
  1040. /**
  1041.   * @brief  Reset the host port.
  1042.   * @param  hhcd HCD handle
  1043.   * @retval HAL status
  1044.   */
  1045. HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd)
  1046. {
  1047.   return (USB_ResetPort(hhcd->Instance));
  1048. }
  1049.  
  1050. /**
  1051.   * @}
  1052.   */
  1053.  
  1054. /** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions
  1055.   *  @brief   Peripheral State functions
  1056.   *
  1057. @verbatim
  1058.  ===============================================================================
  1059.                       ##### Peripheral State functions #####
  1060.  ===============================================================================
  1061.     [..]
  1062.     This subsection permits to get in run-time the status of the peripheral
  1063.     and the data flow.
  1064.  
  1065. @endverbatim
  1066.   * @{
  1067.   */
  1068.  
  1069. /**
  1070.   * @brief  Return the HCD handle state.
  1071.   * @param  hhcd HCD handle
  1072.   * @retval HAL state
  1073.   */
  1074. HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef *hhcd)
  1075. {
  1076.   return hhcd->State;
  1077. }
  1078.  
  1079. /**
  1080.   * @brief  Return  URB state for a channel.
  1081.   * @param  hhcd HCD handle
  1082.   * @param  chnum Channel number.
  1083.   *         This parameter can be a value from 1 to 15
  1084.   * @retval URB state.
  1085.   *          This parameter can be one of these values:
  1086.   *            URB_IDLE/
  1087.   *            URB_DONE/
  1088.   *            URB_NOTREADY/
  1089.   *            URB_NYET/
  1090.   *            URB_ERROR/
  1091.   *            URB_STALL
  1092.   */
  1093. HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
  1094. {
  1095.   return hhcd->hc[chnum].urb_state;
  1096. }
  1097.  
  1098.  
  1099. /**
  1100.   * @brief  Return the last host transfer size.
  1101.   * @param  hhcd HCD handle
  1102.   * @param  chnum Channel number.
  1103.   *         This parameter can be a value from 1 to 15
  1104.   * @retval last transfer size in byte
  1105.   */
  1106. uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef *hhcd, uint8_t chnum)
  1107. {
  1108.   return hhcd->hc[chnum].xfer_count;
  1109. }
  1110.  
  1111. /**
  1112.   * @brief  Return the Host Channel state.
  1113.   * @param  hhcd HCD handle
  1114.   * @param  chnum Channel number.
  1115.   *         This parameter can be a value from 1 to 15
  1116.   * @retval Host channel state
  1117.   *          This parameter can be one of these values:
  1118.   *            HC_IDLE/
  1119.   *            HC_XFRC/
  1120.   *            HC_HALTED/
  1121.   *            HC_NYET/
  1122.   *            HC_NAK/
  1123.   *            HC_STALL/
  1124.   *            HC_XACTERR/
  1125.   *            HC_BBLERR/
  1126.   *            HC_DATATGLERR
  1127.   */
  1128. HCD_HCStateTypeDef  HAL_HCD_HC_GetState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
  1129. {
  1130.   return hhcd->hc[chnum].state;
  1131. }
  1132.  
  1133. /**
  1134.   * @brief  Return the current Host frame number.
  1135.   * @param  hhcd HCD handle
  1136.   * @retval Current Host frame number
  1137.   */
  1138. uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd)
  1139. {
  1140.   return (USB_GetCurrentFrame(hhcd->Instance));
  1141. }
  1142.  
  1143. /**
  1144.   * @brief  Return the Host enumeration speed.
  1145.   * @param  hhcd HCD handle
  1146.   * @retval Enumeration speed
  1147.   */
  1148. uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd)
  1149. {
  1150.   return (USB_GetHostSpeed(hhcd->Instance));
  1151. }
  1152.  
  1153. /**
  1154.   * @}
  1155.   */
  1156.  
  1157. /**
  1158.   * @}
  1159.   */
  1160.  
  1161. /** @addtogroup HCD_Private_Functions
  1162.   * @{
  1163.   */
  1164. /**
  1165.   * @brief  Handle Host Channel IN interrupt requests.
  1166.   * @param  hhcd HCD handle
  1167.   * @param  chnum Channel number.
  1168.   *         This parameter can be a value from 1 to 15
  1169.   * @retval none
  1170.   */
  1171. static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
  1172. {
  1173.   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
  1174.   uint32_t USBx_BASE = (uint32_t)USBx;
  1175.   uint32_t ch_num = (uint32_t)chnum;
  1176.  
  1177.   uint32_t tmpreg;
  1178.  
  1179.   if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
  1180.   {
  1181.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
  1182.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1183.   }
  1184.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR)
  1185.   {
  1186.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_BBERR);
  1187.     hhcd->hc[ch_num].state = HC_BBLERR;
  1188.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1189.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1190.   }
  1191.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
  1192.   {
  1193.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
  1194.   }
  1195.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
  1196.   {
  1197.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1198.     hhcd->hc[ch_num].state = HC_STALL;
  1199.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1200.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
  1201.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1202.   }
  1203.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
  1204.   {
  1205.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1206.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1207.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1208.     hhcd->hc[ch_num].state = HC_DATATGLERR;
  1209.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
  1210.   }
  1211.   else
  1212.   {
  1213.     /* ... */
  1214.   }
  1215.  
  1216.   if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
  1217.   {
  1218.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1219.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1220.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
  1221.   }
  1222.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
  1223.   {
  1224.     hhcd->hc[ch_num].state = HC_XFRC;
  1225.     hhcd->hc[ch_num].ErrCnt = 0U;
  1226.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
  1227.  
  1228.     if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) ||
  1229.         (hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
  1230.     {
  1231.       __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1232.       (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1233.       __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1234.     }
  1235.     else if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
  1236.     {
  1237.       USBx_HC(ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
  1238.       hhcd->hc[ch_num].urb_state = URB_DONE;
  1239.  
  1240. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  1241.       hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1242. #else
  1243.       HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1244. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  1245.     }
  1246.     else if (hhcd->hc[ch_num].ep_type == EP_TYPE_ISOC)
  1247.     {
  1248.       hhcd->hc[ch_num].urb_state = URB_DONE;
  1249.       hhcd->hc[ch_num].toggle_in ^= 1U;
  1250.  
  1251. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  1252.       hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1253. #else
  1254.       HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1255. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  1256.     }
  1257.     else
  1258.     {
  1259.       /* ... */
  1260.     }
  1261.     hhcd->hc[ch_num].toggle_in ^= 1U;
  1262.  
  1263.   }
  1264.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
  1265.   {
  1266.     __HAL_HCD_MASK_HALT_HC_INT(ch_num);
  1267.  
  1268.     if (hhcd->hc[ch_num].state == HC_XFRC)
  1269.     {
  1270.       hhcd->hc[ch_num].urb_state  = URB_DONE;
  1271.     }
  1272.     else if (hhcd->hc[ch_num].state == HC_STALL)
  1273.     {
  1274.       hhcd->hc[ch_num].urb_state  = URB_STALL;
  1275.     }
  1276.     else if ((hhcd->hc[ch_num].state == HC_XACTERR) ||
  1277.              (hhcd->hc[ch_num].state == HC_DATATGLERR))
  1278.     {
  1279.       hhcd->hc[ch_num].ErrCnt++;
  1280.       if (hhcd->hc[ch_num].ErrCnt > 3U)
  1281.       {
  1282.         hhcd->hc[ch_num].ErrCnt = 0U;
  1283.         hhcd->hc[ch_num].urb_state = URB_ERROR;
  1284.       }
  1285.       else
  1286.       {
  1287.         hhcd->hc[ch_num].urb_state = URB_NOTREADY;
  1288.       }
  1289.  
  1290.       /* re-activate the channel  */
  1291.       tmpreg = USBx_HC(ch_num)->HCCHAR;
  1292.       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
  1293.       tmpreg |= USB_OTG_HCCHAR_CHENA;
  1294.       USBx_HC(ch_num)->HCCHAR = tmpreg;
  1295.     }
  1296.     else if (hhcd->hc[ch_num].state == HC_NAK)
  1297.     {
  1298.       hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
  1299.       /* re-activate the channel  */
  1300.       tmpreg = USBx_HC(ch_num)->HCCHAR;
  1301.       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
  1302.       tmpreg |= USB_OTG_HCCHAR_CHENA;
  1303.       USBx_HC(ch_num)->HCCHAR = tmpreg;
  1304.     }
  1305.     else if (hhcd->hc[ch_num].state == HC_BBLERR)
  1306.     {
  1307.       hhcd->hc[ch_num].ErrCnt++;
  1308.       hhcd->hc[ch_num].urb_state = URB_ERROR;
  1309.     }
  1310.     else
  1311.     {
  1312.       /* ... */
  1313.     }
  1314.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
  1315.     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1316.   }
  1317.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
  1318.   {
  1319.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1320.     hhcd->hc[ch_num].ErrCnt++;
  1321.     hhcd->hc[ch_num].state = HC_XACTERR;
  1322.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1323.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
  1324.   }
  1325.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
  1326.   {
  1327.     if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
  1328.     {
  1329.       hhcd->hc[ch_num].ErrCnt = 0U;
  1330.       __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1331.       (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1332.     }
  1333.     else if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) ||
  1334.              (hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
  1335.     {
  1336.       hhcd->hc[ch_num].ErrCnt = 0U;
  1337.       hhcd->hc[ch_num].state = HC_NAK;
  1338.       __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1339.       (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1340.     }
  1341.     else
  1342.     {
  1343.       /* ... */
  1344.     }
  1345.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1346.   }
  1347.   else
  1348.   {
  1349.     /* ... */
  1350.   }
  1351. }
  1352.  
  1353. /**
  1354.   * @brief  Handle Host Channel OUT interrupt requests.
  1355.   * @param  hhcd HCD handle
  1356.   * @param  chnum Channel number.
  1357.   *         This parameter can be a value from 1 to 15
  1358.   * @retval none
  1359.   */
  1360. static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
  1361. {
  1362.   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
  1363.   uint32_t USBx_BASE = (uint32_t)USBx;
  1364.   uint32_t ch_num = (uint32_t)chnum;
  1365.   uint32_t tmpreg;
  1366.  
  1367.   if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
  1368.   {
  1369.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
  1370.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1371.   }
  1372.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
  1373.   {
  1374.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
  1375.  
  1376.     if (hhcd->hc[ch_num].do_ping == 1U)
  1377.     {
  1378.       hhcd->hc[ch_num].do_ping = 0U;
  1379.       hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
  1380.       __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1381.       (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1382.     }
  1383.   }
  1384.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
  1385.   {
  1386.     hhcd->hc[ch_num].state = HC_NYET;
  1387.     hhcd->hc[ch_num].do_ping = 1U;
  1388.     hhcd->hc[ch_num].ErrCnt = 0U;
  1389.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1390.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1391.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);
  1392.   }
  1393.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
  1394.   {
  1395.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1396.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1397.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
  1398.   }
  1399.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
  1400.   {
  1401.     hhcd->hc[ch_num].ErrCnt = 0U;
  1402.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1403.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1404.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
  1405.     hhcd->hc[ch_num].state = HC_XFRC;
  1406.   }
  1407.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
  1408.   {
  1409.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
  1410.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1411.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1412.     hhcd->hc[ch_num].state = HC_STALL;
  1413.   }
  1414.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
  1415.   {
  1416.     hhcd->hc[ch_num].ErrCnt = 0U;
  1417.     hhcd->hc[ch_num].state = HC_NAK;
  1418.  
  1419.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1420.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1421.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1422.   }
  1423.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
  1424.   {
  1425.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1426.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1427.     hhcd->hc[ch_num].state = HC_XACTERR;
  1428.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
  1429.   }
  1430.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
  1431.   {
  1432.     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
  1433.     (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
  1434.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
  1435.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
  1436.     hhcd->hc[ch_num].state = HC_DATATGLERR;
  1437.   }
  1438.   else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
  1439.   {
  1440.     __HAL_HCD_MASK_HALT_HC_INT(ch_num);
  1441.  
  1442.     if (hhcd->hc[ch_num].state == HC_XFRC)
  1443.     {
  1444.       hhcd->hc[ch_num].urb_state  = URB_DONE;
  1445.       if ((hhcd->hc[ch_num].ep_type == EP_TYPE_BULK) ||
  1446.           (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR))
  1447.       {
  1448.         hhcd->hc[ch_num].toggle_out ^= 1U;
  1449.       }
  1450.     }
  1451.     else if (hhcd->hc[ch_num].state == HC_NAK)
  1452.     {
  1453.       hhcd->hc[ch_num].urb_state = URB_NOTREADY;
  1454.     }
  1455.     else if (hhcd->hc[ch_num].state == HC_NYET)
  1456.     {
  1457.       hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
  1458.     }
  1459.     else if (hhcd->hc[ch_num].state == HC_STALL)
  1460.     {
  1461.       hhcd->hc[ch_num].urb_state  = URB_STALL;
  1462.     }
  1463.     else if ((hhcd->hc[ch_num].state == HC_XACTERR) ||
  1464.              (hhcd->hc[ch_num].state == HC_DATATGLERR))
  1465.     {
  1466.       hhcd->hc[ch_num].ErrCnt++;
  1467.       if (hhcd->hc[ch_num].ErrCnt > 3U)
  1468.       {
  1469.         hhcd->hc[ch_num].ErrCnt = 0U;
  1470.         hhcd->hc[ch_num].urb_state = URB_ERROR;
  1471.       }
  1472.       else
  1473.       {
  1474.         hhcd->hc[ch_num].urb_state = URB_NOTREADY;
  1475.       }
  1476.  
  1477.       /* re-activate the channel  */
  1478.       tmpreg = USBx_HC(ch_num)->HCCHAR;
  1479.       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
  1480.       tmpreg |= USB_OTG_HCCHAR_CHENA;
  1481.       USBx_HC(ch_num)->HCCHAR = tmpreg;
  1482.     }
  1483.     else
  1484.     {
  1485.       /* ... */
  1486.     }
  1487.  
  1488.     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
  1489.     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
  1490.   }
  1491.   else
  1492.   {
  1493.     /* ... */
  1494.   }
  1495. }
  1496.  
  1497. /**
  1498.   * @brief  Handle Rx Queue Level interrupt requests.
  1499.   * @param  hhcd HCD handle
  1500.   * @retval none
  1501.   */
  1502. static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd)
  1503. {
  1504.   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
  1505.   uint32_t USBx_BASE = (uint32_t)USBx;
  1506.   uint32_t pktsts;
  1507.   uint32_t pktcnt;
  1508.   uint32_t temp;
  1509.   uint32_t tmpreg;
  1510.   uint32_t ch_num;
  1511.  
  1512.   temp = hhcd->Instance->GRXSTSP;
  1513.   ch_num = temp & USB_OTG_GRXSTSP_EPNUM;
  1514.   pktsts = (temp & USB_OTG_GRXSTSP_PKTSTS) >> 17;
  1515.   pktcnt = (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
  1516.  
  1517.   switch (pktsts)
  1518.   {
  1519.     case GRXSTS_PKTSTS_IN:
  1520.       /* Read the data into the host buffer. */
  1521.       if ((pktcnt > 0U) && (hhcd->hc[ch_num].xfer_buff != (void *)0))
  1522.       {
  1523.         (void)USB_ReadPacket(hhcd->Instance, hhcd->hc[ch_num].xfer_buff, (uint16_t)pktcnt);
  1524.  
  1525.         /*manage multiple Xfer */
  1526.         hhcd->hc[ch_num].xfer_buff += pktcnt;
  1527.         hhcd->hc[ch_num].xfer_count  += pktcnt;
  1528.  
  1529.         if ((USBx_HC(ch_num)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) > 0U)
  1530.         {
  1531.           /* re-activate the channel when more packets are expected */
  1532.           tmpreg = USBx_HC(ch_num)->HCCHAR;
  1533.           tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
  1534.           tmpreg |= USB_OTG_HCCHAR_CHENA;
  1535.           USBx_HC(ch_num)->HCCHAR = tmpreg;
  1536.           hhcd->hc[ch_num].toggle_in ^= 1U;
  1537.         }
  1538.       }
  1539.       break;
  1540.  
  1541.     case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
  1542.       break;
  1543.  
  1544.     case GRXSTS_PKTSTS_IN_XFER_COMP:
  1545.     case GRXSTS_PKTSTS_CH_HALTED:
  1546.     default:
  1547.       break;
  1548.   }
  1549. }
  1550.  
  1551. /**
  1552.   * @brief  Handle Host Port interrupt requests.
  1553.   * @param  hhcd HCD handle
  1554.   * @retval None
  1555.   */
  1556. static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd)
  1557. {
  1558.   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
  1559.   uint32_t USBx_BASE = (uint32_t)USBx;
  1560.   __IO uint32_t hprt0, hprt0_dup;
  1561.  
  1562.   /* Handle Host Port Interrupts */
  1563.   hprt0 = USBx_HPRT0;
  1564.   hprt0_dup = USBx_HPRT0;
  1565.  
  1566.   hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET | \
  1567.                  USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
  1568.  
  1569.   /* Check whether Port Connect detected */
  1570.   if ((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
  1571.   {
  1572.     if ((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
  1573.     {
  1574. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  1575.       hhcd->ConnectCallback(hhcd);
  1576. #else
  1577.       HAL_HCD_Connect_Callback(hhcd);
  1578. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  1579.     }
  1580.     hprt0_dup  |= USB_OTG_HPRT_PCDET;
  1581.   }
  1582.  
  1583.   /* Check whether Port Enable Changed */
  1584.   if ((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
  1585.   {
  1586.     hprt0_dup |= USB_OTG_HPRT_PENCHNG;
  1587.  
  1588.     if ((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
  1589.     {
  1590.       if (hhcd->Init.phy_itface  == USB_OTG_EMBEDDED_PHY)
  1591.       {
  1592.         if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17))
  1593.         {
  1594.           (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_6_MHZ);
  1595.         }
  1596.         else
  1597.         {
  1598.           (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
  1599.         }
  1600.       }
  1601.       else
  1602.       {
  1603.         if (hhcd->Init.speed == HCD_SPEED_FULL)
  1604.         {
  1605.           USBx_HOST->HFIR = 60000U;
  1606.         }
  1607.       }
  1608. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  1609.       hhcd->PortEnabledCallback(hhcd);
  1610. #else
  1611.       HAL_HCD_PortEnabled_Callback(hhcd);
  1612. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  1613.  
  1614.     }
  1615.     else
  1616.     {
  1617. #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
  1618.       hhcd->PortDisabledCallback(hhcd);
  1619. #else
  1620.       HAL_HCD_PortDisabled_Callback(hhcd);
  1621. #endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
  1622.     }
  1623.   }
  1624.  
  1625.   /* Check for an overcurrent */
  1626.   if ((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
  1627.   {
  1628.     hprt0_dup |= USB_OTG_HPRT_POCCHNG;
  1629.   }
  1630.  
  1631.   /* Clear Port Interrupts */
  1632.   USBx_HPRT0 = hprt0_dup;
  1633. }
  1634.  
  1635. /**
  1636.   * @}
  1637.   */
  1638.  
  1639. /**
  1640.   * @}
  1641.   */
  1642.  
  1643. #endif /* defined (USB_OTG_FS) */
  1644. #endif /* HAL_HCD_MODULE_ENABLED */
  1645.  
  1646. /**
  1647.   * @}
  1648.   */
  1649.  
  1650. /**
  1651.   * @}
  1652.   */
  1653.  
  1654. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  1655.