WebSVN – canSerial – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_hcd.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_hal_hcd.c
   * @author  MCD Application Team
   * @brief   HCD HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the USB Peripheral Controller:
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
   *           + Peripheral State functions
   *
-  @verbatim
+  ******************************************************************************
-  ==============================================================================
+  * @attention
-                    ##### How to use this driver #####
+  *
-  ==============================================================================
+  * Copyright (c) 2016 STMicroelectronics.
-  [..]
+  * All rights reserved.
-    (#)Declare a HCD_HandleTypeDef handle structure, for example:
+  *
-       HCD_HandleTypeDef  hhcd;
+  * This software is licensed under terms that can be found in the LICENSE file
+  * in the root directory of this software component.
-    (#)Fill parameters of Init structure in HCD handle
+  * If no LICENSE file comes with this software, it is provided AS-IS.
+  *
-    (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)
+  ******************************************************************************
+  @verbatim
-    (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
+  ==============================================================================
-        (##) Enable the HCD/USB Low Level interface clock using the following macros
+                    ##### How to use this driver #####
-             (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
+  ==============================================================================
-        (##) Initialize the related GPIO clocks
+  [..]
-        (##) Configure HCD pin-out
+    (#)Declare a HCD_HandleTypeDef handle structure, for example:
-        (##) Configure HCD NVIC interrupt
+       HCD_HandleTypeDef  hhcd;
-    (#)Associate the Upper USB Host stack to the HAL HCD Driver:
+    (#)Fill parameters of Init structure in HCD handle
-        (##) hhcd.pData = phost;
+    (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)
-    (#)Enable HCD transmission and reception:
-        (##) HAL_HCD_Start();
+    (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
+        (##) Enable the HCD/USB Low Level interface clock using the following macros
-  @endverbatim
+             (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
-  ******************************************************************************
+        (##) Initialize the related GPIO clocks
-  * @attention
+        (##) Configure HCD pin-out
-  *
+        (##) Configure HCD NVIC interrupt
-  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
-  * All rights reserved.</center></h2>
+    (#)Associate the Upper USB Host stack to the HAL HCD Driver:
-  *
+        (##) hhcd.pData = phost;
-  * This software component is licensed by ST under BSD 3-Clause license,
-  * the "License"; You may not use this file except in compliance with the
+    (#)Enable HCD transmission and reception:
-  * License. You may obtain a copy of the License at:
+        (##) HAL_HCD_Start();
-  *                        opensource.org/licenses/BSD-3-Clause
-  *
+  @endverbatim
   ******************************************************************************
   */
 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_hal.h"
 /** @addtogroup STM32F1xx_HAL_Driver
   * @{
   */
 #ifdef HAL_HCD_MODULE_ENABLED
 #if defined (USB_OTG_FS)
 /** @defgroup HCD HCD
   * @brief HCD HAL module driver
   * @{
   */
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /** @defgroup HCD_Private_Functions HCD Private Functions
   * @{
   */
 static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
 static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
 static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd);
 static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd);
 /**
   * @}
   */
 /* Exported functions --------------------------------------------------------*/
 /** @defgroup HCD_Exported_Functions HCD Exported Functions
   * @{
   */
 /** @defgroup HCD_Exported_Functions_Group1 Initialization and de-initialization functions
   *  @brief    Initialization and Configuration functions
   *
 @verbatim
  ===============================================================================
           ##### Initialization and de-initialization functions #####
  ===============================================================================
     [..]  This section provides functions allowing to:
 @endverbatim
   * @{
   */
 /**
   * @brief  Initialize the host driver.
   * @param  hhcd HCD handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_HCD_Init(HCD_HandleTypeDef *hhcd)
 {
   USB_OTG_GlobalTypeDef *USBx;
   /* Check the HCD handle allocation */
   if (hhcd == NULL)
   {
     return HAL_ERROR;
   }
   /* Check the parameters */
   assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance));
   USBx = hhcd->Instance;
   if (hhcd->State == HAL_HCD_STATE_RESET)
   {
     /* Allocate lock resource and initialize it */
     hhcd->Lock = HAL_UNLOCKED;
 #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
     hhcd->SOFCallback = HAL_HCD_SOF_Callback;
     hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
     hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
     hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
     hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
     hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback;
     if (hhcd->MspInitCallback == NULL)
     {
       hhcd->MspInitCallback = HAL_HCD_MspInit;
     }
     /* Init the low level hardware */
     hhcd->MspInitCallback(hhcd);
 #else
     /* Init the low level hardware : GPIO, CLOCK, NVIC... */
     HAL_HCD_MspInit(hhcd);
 #endif /* (USE_HAL_HCD_REGISTER_CALLBACKS) */
   }
   hhcd->State = HAL_HCD_STATE_BUSY;
   /* Disable DMA mode for FS instance */
   if ((USBx->CID & (0x1U << 8)) == 0U)
   {
     hhcd->Init.dma_enable = 0U;
   }
   /* Disable the Interrupts */
   __HAL_HCD_DISABLE(hhcd);
   /* Init the Core (common init.) */
   (void)USB_CoreInit(hhcd->Instance, hhcd->Init);
   /* Force Host Mode*/
   (void)USB_SetCurrentMode(hhcd->Instance, USB_HOST_MODE);
   /* Init Host */
   (void)USB_HostInit(hhcd->Instance, hhcd->Init);
   hhcd->State = HAL_HCD_STATE_READY;
   return HAL_OK;
 }
 /**
   * @brief  Initialize a host channel.
   * @param  hhcd HCD handle
   * @param  ch_num Channel number.
   *         This parameter can be a value from 1 to 15
   * @param  epnum Endpoint number.
   *          This parameter can be a value from 1 to 15
   * @param  dev_address Current device address
   *          This parameter can be a value from 0 to 255
   * @param  speed Current device speed.
   *          This parameter can be one of these values:
   *            HCD_DEVICE_SPEED_FULL: Full speed mode,
   *            HCD_DEVICE_SPEED_LOW: Low speed mode
   * @param  ep_type Endpoint Type.
   *          This parameter can be one of these values:
   *            EP_TYPE_CTRL: Control type,
   *            EP_TYPE_ISOC: Isochronous type,
   *            EP_TYPE_BULK: Bulk type,
   *            EP_TYPE_INTR: Interrupt type
   * @param  mps Max Packet Size.
   *          This parameter can be a value from 0 to32K
   * @retval HAL status
   */
-HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd,
+HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd, uint8_t ch_num, uint8_t epnum,
-                                  uint8_t ch_num,
+                                  uint8_t dev_address, uint8_t speed, uint8_t ep_type, uint16_t mps)
-                                  uint8_t epnum,
+{
-                                  uint8_t dev_address,
+  HAL_StatusTypeDef status;
-                                  uint8_t speed,
+  uint32_t HCcharMps = mps;
-                                  uint8_t ep_type,
-                                  uint16_t mps)
+  __HAL_LOCK(hhcd);
-{
+  hhcd->hc[ch_num].do_ping = 0U;
-  HAL_StatusTypeDef status;
+  hhcd->hc[ch_num].dev_addr = dev_address;
+  hhcd->hc[ch_num].ch_num = ch_num;
-  __HAL_LOCK(hhcd);
+  hhcd->hc[ch_num].ep_type = ep_type;
-  hhcd->hc[ch_num].do_ping = 0U;
+  hhcd->hc[ch_num].ep_num = epnum & 0x7FU;
-  hhcd->hc[ch_num].dev_addr = dev_address;
-  hhcd->hc[ch_num].max_packet = mps;
+  (void)HAL_HCD_HC_ClearHubInfo(hhcd, ch_num);
-  hhcd->hc[ch_num].ch_num = ch_num;
-  hhcd->hc[ch_num].ep_type = ep_type;
+  if ((epnum & 0x80U) == 0x80U)
-  hhcd->hc[ch_num].ep_num = epnum & 0x7FU;
+  {
+    hhcd->hc[ch_num].ep_is_in = 1U;
-  if ((epnum & 0x80U) == 0x80U)
+  }
-  {
+  else
-    hhcd->hc[ch_num].ep_is_in = 1U;
+  {
-  }
+    hhcd->hc[ch_num].ep_is_in = 0U;
-  else
+  }
-  {
-    hhcd->hc[ch_num].ep_is_in = 0U;
+  hhcd->hc[ch_num].speed = speed;
-  }
+  hhcd->hc[ch_num].max_packet = (uint16_t)HCcharMps;
-  hhcd->hc[ch_num].speed = speed;
+  status =  USB_HC_Init(hhcd->Instance, ch_num, epnum,
+                        dev_address, speed, ep_type, (uint16_t)HCcharMps);
-  status =  USB_HC_Init(hhcd->Instance,
-                        ch_num,
+  __HAL_UNLOCK(hhcd);
-                        epnum,
-                        dev_address,
+  return status;
-                        speed,
+}
-                        ep_type,
-                        mps);
+/**
-  __HAL_UNLOCK(hhcd);
+  * @brief  Halt a host channel.
+  * @param  hhcd HCD handle
-  return status;
+  * @param  ch_num Channel number.
-}
+  *         This parameter can be a value from 1 to 15
+  * @retval HAL status
-/**
+  */
-  * @brief  Halt a host channel.
+HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd, uint8_t ch_num)
-  * @param  hhcd HCD handle
+{
-  * @param  ch_num Channel number.
+  HAL_StatusTypeDef status = HAL_OK;
-  *         This parameter can be a value from 1 to 15
-  * @retval HAL status
+  __HAL_LOCK(hhcd);
-  */
+  (void)USB_HC_Halt(hhcd->Instance, ch_num);
-HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd, uint8_t ch_num)
+  __HAL_UNLOCK(hhcd);
-{
-  HAL_StatusTypeDef status = HAL_OK;
+  return status;
+}
-  __HAL_LOCK(hhcd);
-  (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+/**
-  __HAL_UNLOCK(hhcd);
+  * @brief  DeInitialize the host driver.
+  * @param  hhcd HCD handle
-  return status;
+  * @retval HAL status
-}
+  */
+HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd)
-/**
+{
-  * @brief  DeInitialize the host driver.
+  /* Check the HCD handle allocation */
-  * @param  hhcd HCD handle
+  if (hhcd == NULL)
-  * @retval HAL status
+  {
-  */
+    return HAL_ERROR;
-HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd)
+  }
-{
-  /* Check the HCD handle allocation */
+  hhcd->State = HAL_HCD_STATE_BUSY;
-  if (hhcd == NULL)
-  {
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-    return HAL_ERROR;
+  if (hhcd->MspDeInitCallback == NULL)
-  }
+  {
+    hhcd->MspDeInitCallback = HAL_HCD_MspDeInit; /* Legacy weak MspDeInit  */
-  hhcd->State = HAL_HCD_STATE_BUSY;
+  }
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+  /* DeInit the low level hardware */
-  if (hhcd->MspDeInitCallback == NULL)
+  hhcd->MspDeInitCallback(hhcd);
-  {
+#else
-    hhcd->MspDeInitCallback = HAL_HCD_MspDeInit; /* Legacy weak MspDeInit  */
+  /* DeInit the low level hardware: CLOCK, NVIC.*/
-  }
+  HAL_HCD_MspDeInit(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-  /* DeInit the low level hardware */
-  hhcd->MspDeInitCallback(hhcd);
+  __HAL_HCD_DISABLE(hhcd);
-#else
-  /* DeInit the low level hardware: CLOCK, NVIC.*/
+  hhcd->State = HAL_HCD_STATE_RESET;
-  HAL_HCD_MspDeInit(hhcd);
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+  return HAL_OK;
+}
-  __HAL_HCD_DISABLE(hhcd);
+/**
-  hhcd->State = HAL_HCD_STATE_RESET;
+  * @brief  Initialize the HCD MSP.
+  * @param  hhcd HCD handle
-  return HAL_OK;
+  * @retval None
-}
+  */
+__weak void  HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd)
-/**
+{
-  * @brief  Initialize the HCD MSP.
+  /* Prevent unused argument(s) compilation warning */
-  * @param  hhcd HCD handle
+  UNUSED(hhcd);
-  * @retval None
-  */
+  /* NOTE : This function should not be modified, when the callback is needed,
-__weak void  HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd)
+            the HAL_HCD_MspInit could be implemented in the user file
-{
+   */
-  /* Prevent unused argument(s) compilation warning */
+}
-  UNUSED(hhcd);
+/**
-  /* NOTE : This function should not be modified, when the callback is needed,
+  * @brief  DeInitialize the HCD MSP.
-            the HAL_HCD_MspInit could be implemented in the user file
+  * @param  hhcd HCD handle
-   */
+  * @retval None
-}
+  */
+__weak void  HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd)
-/**
+{
-  * @brief  DeInitialize the HCD MSP.
+  /* Prevent unused argument(s) compilation warning */
-  * @param  hhcd HCD handle
+  UNUSED(hhcd);
-  * @retval None
-  */
+  /* NOTE : This function should not be modified, when the callback is needed,
-__weak void  HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd)
+            the HAL_HCD_MspDeInit could be implemented in the user file
-{
+   */
-  /* Prevent unused argument(s) compilation warning */
+}
-  UNUSED(hhcd);
+/**
-  /* NOTE : This function should not be modified, when the callback is needed,
+  * @}
-            the HAL_HCD_MspDeInit could be implemented in the user file
+  */
-   */
-}
+/** @defgroup HCD_Exported_Functions_Group2 Input and Output operation functions
+  *  @brief   HCD IO operation functions
-/**
+  *
-  * @}
+@verbatim
-  */
+ ===============================================================================
+                      ##### IO operation functions #####
-/** @defgroup HCD_Exported_Functions_Group2 Input and Output operation functions
+ ===============================================================================
-  *  @brief   HCD IO operation functions
+ [..] This subsection provides a set of functions allowing to manage the USB Host Data
-  *
+    Transfer
-@verbatim
- ===============================================================================
+@endverbatim
-                      ##### IO operation functions #####
+  * @{
- ===============================================================================
+  */
- [..] This subsection provides a set of functions allowing to manage the USB Host Data
-    Transfer
+/**
+  * @brief  Submit a new URB for processing.
-@endverbatim
+  * @param  hhcd HCD handle
-  * @{
+  * @param  ch_num Channel number.
-  */
+  *         This parameter can be a value from 1 to 15
+  * @param  direction Channel number.
-/**
+  *          This parameter can be one of these values:
-  * @brief  Submit a new URB for processing.
+  *           0 : Output / 1 : Input
-  * @param  hhcd HCD handle
+  * @param  ep_type Endpoint Type.
-  * @param  ch_num Channel number.
+  *          This parameter can be one of these values:
-  *         This parameter can be a value from 1 to 15
+  *            EP_TYPE_CTRL: Control type/
-  * @param  direction Channel number.
+  *            EP_TYPE_ISOC: Isochronous type/
-  *          This parameter can be one of these values:
+  *            EP_TYPE_BULK: Bulk type/
-  *           0 : Output / 1 : Input
+  *            EP_TYPE_INTR: Interrupt type/
-  * @param  ep_type Endpoint Type.
+  * @param  token Endpoint Type.
   *          This parameter can be one of these values:
-  *            EP_TYPE_CTRL: Control type/
+  *            0: HC_PID_SETUP / 1: HC_PID_DATA1
-  *            EP_TYPE_ISOC: Isochronous type/
+  * @param  pbuff pointer to URB data
-  *            EP_TYPE_BULK: Bulk type/
+  * @param  length Length of URB data
-  *            EP_TYPE_INTR: Interrupt type/
+  * @param  do_ping activate do ping protocol (for high speed only).
-  * @param  token Endpoint Type.
+  *          This parameter can be one of these values:
-  *          This parameter can be one of these values:
+  *           0 : do ping inactive / 1 : do ping active
-  *            0: HC_PID_SETUP / 1: HC_PID_DATA1
+  * @retval HAL status
-  * @param  pbuff pointer to URB data
+  */
-  * @param  length Length of URB data
+HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd,
-  * @param  do_ping activate do ping protocol (for high speed only).
+                                           uint8_t ch_num,
-  *          This parameter can be one of these values:
+                                           uint8_t direction,
-  *           0 : do ping inactive / 1 : do ping active
+                                           uint8_t ep_type,
-  * @retval HAL status
+                                           uint8_t token,
-  */
+                                           uint8_t *pbuff,
-HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd,
+                                           uint16_t length,
-                                           uint8_t ch_num,
+                                           uint8_t do_ping)
-                                           uint8_t direction,
+{
-                                           uint8_t ep_type,
+  hhcd->hc[ch_num].ep_is_in = direction;
-                                           uint8_t token,
+  hhcd->hc[ch_num].ep_type  = ep_type;
-                                           uint8_t *pbuff,
-                                           uint16_t length,
+  if (token == 0U)
-                                           uint8_t do_ping)
+  {
-{
+    hhcd->hc[ch_num].data_pid = HC_PID_SETUP;
-  hhcd->hc[ch_num].ep_is_in = direction;
+    hhcd->hc[ch_num].do_ping = do_ping;
-  hhcd->hc[ch_num].ep_type  = ep_type;
+  }
+  else
-  if (token == 0U)
+  {
-  {
+    hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-    hhcd->hc[ch_num].data_pid = HC_PID_SETUP;
+  }
-    hhcd->hc[ch_num].do_ping = do_ping;
-  }
+  /* Manage Data Toggle */
-  else
+  switch (ep_type)
   {
-    hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
+    case EP_TYPE_CTRL:
-  }
+      if (token == 1U) /* send data */
+      {
-  /* Manage Data Toggle */
+        if (direction == 0U)
-  switch (ep_type)
+        {
-  {
+          if (length == 0U)
-    case EP_TYPE_CTRL:
+          {
-      if ((token == 1U) && (direction == 0U)) /*send data */
+            /* For Status OUT stage, Length == 0U, Status Out PID = 1 */
-      {
+            hhcd->hc[ch_num].toggle_out = 1U;
-        if (length == 0U)
+          }
-        {
-          /* For Status OUT stage, Length==0, Status Out PID = 1 */
+          /* Set the Data Toggle bit as per the Flag */
-          hhcd->hc[ch_num].toggle_out = 1U;
+          if (hhcd->hc[ch_num].toggle_out == 0U)
-        }
+          {
+            /* Put the PID 0 */
-        /* Set the Data Toggle bit as per the Flag */
+            hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
-        if (hhcd->hc[ch_num].toggle_out == 0U)
+          }
-        {
+          else
-          /* Put the PID 0 */
+          {
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+            /* Put the PID 1 */
-        }
+            hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        else
+          }
-        {
+        }
-          /* Put the PID 1 */
+      }
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
+      break;
-        }
-      }
+    case EP_TYPE_BULK:
-      break;
+      if (direction == 0U)
+      {
-    case EP_TYPE_BULK:
+        /* Set the Data Toggle bit as per the Flag */
-      if (direction == 0U)
+        if (hhcd->hc[ch_num].toggle_out == 0U)
-      {
+        {
-        /* Set the Data Toggle bit as per the Flag */
+          /* Put the PID 0 */
-        if (hhcd->hc[ch_num].toggle_out == 0U)
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
-        {
+        }
-          /* Put the PID 0 */
+        else
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+        {
-        }
+          /* Put the PID 1 */
-        else
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        {
+        }
-          /* Put the PID 1 */
+      }
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
+      else
-        }
+      {
-      }
+        if (hhcd->hc[ch_num].toggle_in == 0U)
-      else
+        {
-      {
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
-        if (hhcd->hc[ch_num].toggle_in == 0U)
+        }
-        {
+        else
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+        {
-        }
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        else
+        }
-        {
+      }
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        }
+      break;
-      }
+    case EP_TYPE_INTR:
+      if (direction == 0U)
-      break;
+      {
-    case EP_TYPE_INTR:
+        /* Set the Data Toggle bit as per the Flag */
-      if (direction == 0U)
+        if (hhcd->hc[ch_num].toggle_out == 0U)
-      {
+        {
-        /* Set the Data Toggle bit as per the Flag */
+          /* Put the PID 0 */
-        if (hhcd->hc[ch_num].toggle_out == 0U)
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
-        {
+        }
-          /* Put the PID 0 */
+        else
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+        {
-        }
+          /* Put the PID 1 */
-        else
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        {
+        }
-          /* Put the PID 1 */
+      }
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
+      else
-        }
+      {
-      }
+        if (hhcd->hc[ch_num].toggle_in == 0U)
-      else
+        {
-      {
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
-        if (hhcd->hc[ch_num].toggle_in == 0U)
+        }
-        {
+        else
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+        {
-        }
+          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
-        else
+        }
-        {
+      }
-          hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
+      break;
-        }
-      }
+    case EP_TYPE_ISOC:
-      break;
+      hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+      break;
-    case EP_TYPE_ISOC:
-      hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
+    default:
       break;
+  }
-    default:
-      break;
+  hhcd->hc[ch_num].xfer_buff = pbuff;
-  }
+  hhcd->hc[ch_num].xfer_len  = length;
+  hhcd->hc[ch_num].urb_state = URB_IDLE;
-  hhcd->hc[ch_num].xfer_buff = pbuff;
+  hhcd->hc[ch_num].xfer_count = 0U;
-  hhcd->hc[ch_num].xfer_len  = length;
+  hhcd->hc[ch_num].ch_num = ch_num;
-  hhcd->hc[ch_num].urb_state = URB_IDLE;
+  hhcd->hc[ch_num].state = HC_IDLE;
-  hhcd->hc[ch_num].xfer_count = 0U;
-  hhcd->hc[ch_num].ch_num = ch_num;
+  return USB_HC_StartXfer(hhcd->Instance, &hhcd->hc[ch_num]);
-  hhcd->hc[ch_num].state = HC_IDLE;
+}
-  return USB_HC_StartXfer(hhcd->Instance, &hhcd->hc[ch_num]);
+/**
-}
+  * @brief  Handle HCD interrupt request.
+  * @param  hhcd HCD handle
-/**
+  * @retval None
-  * @brief  Handle HCD interrupt request.
+  */
-  * @param  hhcd HCD handle
+void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
-  * @retval None
+{
-  */
+  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
-void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
+  uint32_t USBx_BASE = (uint32_t)USBx;
-{
+  uint32_t i;
-  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
+  uint32_t interrupt;
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t i;
+  /* Ensure that we are in device mode */
-  uint32_t interrupt;
+  if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
+  {
-  /* Ensure that we are in device mode */
+    /* Avoid spurious interrupt */
-  if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
+    if (__HAL_HCD_IS_INVALID_INTERRUPT(hhcd))
-  {
+    {
-    /* Avoid spurious interrupt */
+      return;
-    if (__HAL_HCD_IS_INVALID_INTERRUPT(hhcd))
+    }
-    {
-      return;
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
-    }
+    {
+      /* Incorrect mode, acknowledge the interrupt */
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
-    {
+    }
-      /* Incorrect mode, acknowledge the interrupt */
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
-    }
+    {
+      /* Incorrect mode, acknowledge the interrupt */
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
-    {
+    }
-      /* Incorrect mode, acknowledge the interrupt */
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
-    }
+    {
+      /* Incorrect mode, acknowledge the interrupt */
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
-    {
+    }
-      /* Incorrect mode, acknowledge the interrupt */
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
-    }
+    {
+      /* Incorrect mode, acknowledge the interrupt */
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
-    {
+    }
-      /* Incorrect mode, acknowledge the interrupt */
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
+    /* Handle Host Disconnect Interrupts */
-    }
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
+    {
-    /* Handle Host Disconnect Interrupts */
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
-    {
+      if ((USBx_HPRT0 & USB_OTG_HPRT_PCSTS) == 0U)
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
+      {
+        /* Flush USB Fifo */
-      if ((USBx_HPRT0 & USB_OTG_HPRT_PCSTS) == 0U)
+        (void)USB_FlushTxFifo(USBx, 0x10U);
-      {
+        (void)USB_FlushRxFifo(USBx);
-        /* Handle Host Port Disconnect Interrupt */
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+        if (hhcd->Init.phy_itface == USB_OTG_EMBEDDED_PHY)
-        hhcd->DisconnectCallback(hhcd);
+        {
-#else
+          /* Restore FS Clock */
-        HAL_HCD_Disconnect_Callback(hhcd);
+          (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+        }
-        (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
+        /* Handle Host Port Disconnect Interrupt */
-      }
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-    }
+        hhcd->DisconnectCallback(hhcd);
+#else
-    /* Handle Host Port Interrupts */
+        HAL_HCD_Disconnect_Callback(hhcd);
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-    {
+      }
-      HCD_Port_IRQHandler(hhcd);
+    }
-    }
+    /* Handle Host Port Interrupts */
-    /* Handle Host SOF Interrupt */
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
+    {
-    {
+      HCD_Port_IRQHandler(hhcd);
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    }
-      hhcd->SOFCallback(hhcd);
-#else
+    /* Handle Host SOF Interrupt */
-      HAL_HCD_SOF_Callback(hhcd);
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    {
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
+      hhcd->SOFCallback(hhcd);
-    }
+#else
+      HAL_HCD_SOF_Callback(hhcd);
-    /* Handle Rx Queue Level Interrupts */
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-    if ((__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL)) != 0U)
-    {
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
-      USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
+    }
-      HCD_RXQLVL_IRQHandler(hhcd);
+    /* Handle Host channel Interrupt */
+    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
-      USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
+    {
-    }
+      interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
+      for (i = 0U; i < hhcd->Init.Host_channels; i++)
-    /* Handle Host channel Interrupt */
+      {
-    if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
+        if ((interrupt & (1UL << (i & 0xFU))) != 0U)
-    {
+        {
-      interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
+          if ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_EPDIR) == USB_OTG_HCCHAR_EPDIR)
-      for (i = 0U; i < hhcd->Init.Host_channels; i++)
+          {
-      {
+            HCD_HC_IN_IRQHandler(hhcd, (uint8_t)i);
-        if ((interrupt & (1UL << (i & 0xFU))) != 0U)
+          }
-        {
+          else
-          if ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_EPDIR) == USB_OTG_HCCHAR_EPDIR)
+          {
-          {
+            HCD_HC_OUT_IRQHandler(hhcd, (uint8_t)i);
-            HCD_HC_IN_IRQHandler(hhcd, (uint8_t)i);
+          }
-          }
+        }
-          else
+      }
-          {
+      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
-            HCD_HC_OUT_IRQHandler(hhcd, (uint8_t)i);
+    }
-          }
-        }
+    /* Handle Rx Queue Level Interrupts */
-      }
+    if ((__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL)) != 0U)
-      __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
+    {
-    }
+      USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
-  }
-}
+      HCD_RXQLVL_IRQHandler(hhcd);
+      USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
-/**
+    }
-  * @brief  Handles HCD Wakeup interrupt request.
+  }
-  * @param  hhcd HCD handle
+}
-  * @retval HAL status
-  */
-void HAL_HCD_WKUP_IRQHandler(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Handles HCD Wakeup interrupt request.
-  UNUSED(hhcd);
+  * @param  hhcd HCD handle
-}
+  * @retval HAL status
+  */
+void HAL_HCD_WKUP_IRQHandler(HCD_HandleTypeDef *hhcd)
-/**
+{
-  * @brief  SOF callback.
+  UNUSED(hhcd);
-  * @param  hhcd HCD handle
+}
-  * @retval None
-  */
-__weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  SOF callback.
-  /* Prevent unused argument(s) compilation warning */
+  * @param  hhcd HCD handle
-  UNUSED(hhcd);
+  * @retval None
+  */
-  /* NOTE : This function should not be modified, when the callback is needed,
+__weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd)
-            the HAL_HCD_SOF_Callback could be implemented in the user file
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(hhcd);
-/**
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @brief Connection Event callback.
+            the HAL_HCD_SOF_Callback could be implemented in the user file
-  * @param  hhcd HCD handle
+   */
-  * @retval None
+}
-  */
-__weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief Connection Event callback.
-  /* Prevent unused argument(s) compilation warning */
+  * @param  hhcd HCD handle
-  UNUSED(hhcd);
+  * @retval None
+  */
-  /* NOTE : This function should not be modified, when the callback is needed,
+__weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd)
-            the HAL_HCD_Connect_Callback could be implemented in the user file
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(hhcd);
-/**
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @brief  Disconnection Event callback.
+            the HAL_HCD_Connect_Callback could be implemented in the user file
-  * @param  hhcd HCD handle
+   */
-  * @retval None
+}
-  */
-__weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Disconnection Event callback.
-  /* Prevent unused argument(s) compilation warning */
+  * @param  hhcd HCD handle
-  UNUSED(hhcd);
+  * @retval None
+  */
-  /* NOTE : This function should not be modified, when the callback is needed,
+__weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd)
-            the HAL_HCD_Disconnect_Callback could be implemented in the user file
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(hhcd);
-/**
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @brief  Port Enabled  Event callback.
+            the HAL_HCD_Disconnect_Callback could be implemented in the user file
-  * @param  hhcd HCD handle
+   */
-  * @retval None
+}
-  */
-__weak void HAL_HCD_PortEnabled_Callback(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Port Enabled  Event callback.
-  /* Prevent unused argument(s) compilation warning */
+  * @param  hhcd HCD handle
-  UNUSED(hhcd);
+  * @retval None
+  */
-  /* NOTE : This function should not be modified, when the callback is needed,
+__weak void HAL_HCD_PortEnabled_Callback(HCD_HandleTypeDef *hhcd)
-            the HAL_HCD_Disconnect_Callback could be implemented in the user file
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(hhcd);
-/**
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @brief  Port Disabled  Event callback.
+            the HAL_HCD_Disconnect_Callback could be implemented in the user file
-  * @param  hhcd HCD handle
+   */
-  * @retval None
+}
-  */
-__weak void HAL_HCD_PortDisabled_Callback(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Port Disabled  Event callback.
-  /* Prevent unused argument(s) compilation warning */
+  * @param  hhcd HCD handle
-  UNUSED(hhcd);
+  * @retval None
+  */
-  /* NOTE : This function should not be modified, when the callback is needed,
+__weak void HAL_HCD_PortDisabled_Callback(HCD_HandleTypeDef *hhcd)
-            the HAL_HCD_Disconnect_Callback could be implemented in the user file
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(hhcd);
-/**
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @brief  Notify URB state change callback.
+            the HAL_HCD_Disconnect_Callback could be implemented in the user file
-  * @param  hhcd HCD handle
+   */
-  * @param  chnum Channel number.
+}
-  *         This parameter can be a value from 1 to 15
-  * @param  urb_state:
+/**
-  *          This parameter can be one of these values:
+  * @brief  Notify URB state change callback.
-  *            URB_IDLE/
+  * @param  hhcd HCD handle
-  *            URB_DONE/
+  * @param  chnum Channel number.
-  *            URB_NOTREADY/
+  *         This parameter can be a value from 1 to 15
-  *            URB_NYET/
+  * @param  urb_state:
-  *            URB_ERROR/
+  *          This parameter can be one of these values:
-  *            URB_STALL/
+  *            URB_IDLE/
-  * @retval None
+  *            URB_DONE/
-  */
+  *            URB_NOTREADY/
-__weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
+  *            URB_NYET/
-{
+  *            URB_ERROR/
-  /* Prevent unused argument(s) compilation warning */
+  *            URB_STALL/
-  UNUSED(hhcd);
+  * @retval None
-  UNUSED(chnum);
+  */
-  UNUSED(urb_state);
+__weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file
+  UNUSED(hhcd);
-   */
+  UNUSED(chnum);
-}
+  UNUSED(urb_state);
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+  /* NOTE : This function should not be modified, when the callback is needed,
-/**
+            the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file
-  * @brief  Register a User USB HCD Callback
+   */
-  *         To be used instead of the weak predefined callback
+}
-  * @param  hhcd USB HCD handle
-  * @param  CallbackID ID of the callback to be registered
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-  *         This parameter can be one of the following values:
+/**
-  *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
+  * @brief  Register a User USB HCD Callback
-  *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
+  *         To be used instead of the weak predefined callback
-  *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
+  * @param  hhcd USB HCD handle
-  *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enable callback ID
+  * @param  CallbackID ID of the callback to be registered
-  *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disable callback ID
+  *         This parameter can be one of the following values:
-  *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
+  *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
-  *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
+  *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
-  * @param  pCallback pointer to the Callback function
+  *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
-  * @retval HAL status
+  *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enable callback ID
-  */
+  *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disable callback ID
-HAL_StatusTypeDef HAL_HCD_RegisterCallback(HCD_HandleTypeDef *hhcd,
+  *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
-                                           HAL_HCD_CallbackIDTypeDef CallbackID,
+  *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
-                                           pHCD_CallbackTypeDef pCallback)
+  * @param  pCallback pointer to the Callback function
-{
+  * @retval HAL status
-  HAL_StatusTypeDef status = HAL_OK;
+  */
+HAL_StatusTypeDef HAL_HCD_RegisterCallback(HCD_HandleTypeDef *hhcd,
-  if (pCallback == NULL)
+                                           HAL_HCD_CallbackIDTypeDef CallbackID,
-  {
+                                           pHCD_CallbackTypeDef pCallback)
-    /* Update the error code */
+{
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+  HAL_StatusTypeDef status = HAL_OK;
-    return HAL_ERROR;
-  }
+  if (pCallback == NULL)
-  /* Process locked */
+  {
-  __HAL_LOCK(hhcd);
+    /* Update the error code */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  if (hhcd->State == HAL_HCD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    switch (CallbackID)
+  /* Process locked */
-    {
+  __HAL_LOCK(hhcd);
-      case HAL_HCD_SOF_CB_ID :
-        hhcd->SOFCallback = pCallback;
+  if (hhcd->State == HAL_HCD_STATE_READY)
-        break;
+  {
+    switch (CallbackID)
-      case HAL_HCD_CONNECT_CB_ID :
+    {
-        hhcd->ConnectCallback = pCallback;
+      case HAL_HCD_SOF_CB_ID :
-        break;
+        hhcd->SOFCallback = pCallback;
+        break;
-      case HAL_HCD_DISCONNECT_CB_ID :
-        hhcd->DisconnectCallback = pCallback;
+      case HAL_HCD_CONNECT_CB_ID :
-        break;
+        hhcd->ConnectCallback = pCallback;
+        break;
-      case HAL_HCD_PORT_ENABLED_CB_ID :
-        hhcd->PortEnabledCallback = pCallback;
+      case HAL_HCD_DISCONNECT_CB_ID :
-        break;
+        hhcd->DisconnectCallback = pCallback;
+        break;
-      case HAL_HCD_PORT_DISABLED_CB_ID :
-        hhcd->PortDisabledCallback = pCallback;
+      case HAL_HCD_PORT_ENABLED_CB_ID :
-        break;
+        hhcd->PortEnabledCallback = pCallback;
+        break;
-      case HAL_HCD_MSPINIT_CB_ID :
-        hhcd->MspInitCallback = pCallback;
+      case HAL_HCD_PORT_DISABLED_CB_ID :
-        break;
+        hhcd->PortDisabledCallback = pCallback;
+        break;
-      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->MspDeInitCallback = pCallback;
+      case HAL_HCD_MSPINIT_CB_ID :
-        break;
+        hhcd->MspInitCallback = pCallback;
+        break;
-      default :
-        /* Update the error code */
+      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+        hhcd->MspDeInitCallback = pCallback;
-        /* Return error status */
+        break;
-        status =  HAL_ERROR;
-        break;
+      default :
-    }
+        /* Update the error code */
-  }
+        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  else if (hhcd->State == HAL_HCD_STATE_RESET)
+        /* Return error status */
-  {
+        status =  HAL_ERROR;
-    switch (CallbackID)
+        break;
-    {
+    }
-      case HAL_HCD_MSPINIT_CB_ID :
+  }
-        hhcd->MspInitCallback = pCallback;
+  else if (hhcd->State == HAL_HCD_STATE_RESET)
-        break;
+  {
+    switch (CallbackID)
-      case HAL_HCD_MSPDEINIT_CB_ID :
+    {
-        hhcd->MspDeInitCallback = pCallback;
+      case HAL_HCD_MSPINIT_CB_ID :
-        break;
+        hhcd->MspInitCallback = pCallback;
+        break;
-      default :
-        /* Update the error code */
+      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+        hhcd->MspDeInitCallback = pCallback;
-        /* Return error status */
+        break;
-        status =  HAL_ERROR;
-        break;
+      default :
-    }
+        /* Update the error code */
-  }
+        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  else
+        /* Return error status */
-  {
+        status =  HAL_ERROR;
-    /* Update the error code */
+        break;
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+    }
-    /* Return error status */
+  }
-    status =  HAL_ERROR;
+  else
-  }
+  {
+    /* Update the error code */
-  /* Release Lock */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  __HAL_UNLOCK(hhcd);
+    /* Return error status */
-  return status;
+    status =  HAL_ERROR;
-}
+  }
-/**
+  /* Release Lock */
-  * @brief  Unregister an USB HCD Callback
+  __HAL_UNLOCK(hhcd);
-  *         USB HCD callback is redirected to the weak predefined callback
+  return status;
-  * @param  hhcd USB HCD handle
+}
-  * @param  CallbackID ID of the callback to be unregistered
-  *         This parameter can be one of the following values:
+/**
-  *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
+  * @brief  Unregister an USB HCD Callback
-  *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
+  *         USB HCD callback is redirected to the weak predefined callback
-  *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
+  * @param  hhcd USB HCD handle
-  *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enabled callback ID
+  * @param  CallbackID ID of the callback to be unregistered
-  *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disabled callback ID
+  *         This parameter can be one of the following values:
-  *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
+  *          @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
-  *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
+  *          @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
-  * @retval HAL status
+  *          @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
-  */
+  *          @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enabled callback ID
-HAL_StatusTypeDef HAL_HCD_UnRegisterCallback(HCD_HandleTypeDef *hhcd, HAL_HCD_CallbackIDTypeDef CallbackID)
+  *          @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disabled callback ID
-{
+  *          @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
-  HAL_StatusTypeDef status = HAL_OK;
+  *          @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
+  * @retval HAL status
-  /* Process locked */
+  */
-  __HAL_LOCK(hhcd);
+HAL_StatusTypeDef HAL_HCD_UnRegisterCallback(HCD_HandleTypeDef *hhcd, HAL_HCD_CallbackIDTypeDef CallbackID)
+{
-  /* Setup Legacy weak Callbacks  */
+  HAL_StatusTypeDef status = HAL_OK;
-  if (hhcd->State == HAL_HCD_STATE_READY)
-  {
+  /* Process locked */
-    switch (CallbackID)
+  __HAL_LOCK(hhcd);
-    {
-      case HAL_HCD_SOF_CB_ID :
+  /* Setup Legacy weak Callbacks  */
-        hhcd->SOFCallback = HAL_HCD_SOF_Callback;
+  if (hhcd->State == HAL_HCD_STATE_READY)
-        break;
+  {
+    switch (CallbackID)
-      case HAL_HCD_CONNECT_CB_ID :
+    {
-        hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
+      case HAL_HCD_SOF_CB_ID :
-        break;
+        hhcd->SOFCallback = HAL_HCD_SOF_Callback;
+        break;
-      case HAL_HCD_DISCONNECT_CB_ID :
-        hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
+      case HAL_HCD_CONNECT_CB_ID :
-        break;
+        hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
+        break;
-      case HAL_HCD_PORT_ENABLED_CB_ID :
-        hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
+      case HAL_HCD_DISCONNECT_CB_ID :
-        break;
+        hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
+        break;
-      case HAL_HCD_PORT_DISABLED_CB_ID :
-        hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
+      case HAL_HCD_PORT_ENABLED_CB_ID :
-        break;
+        hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
+        break;
-      case HAL_HCD_MSPINIT_CB_ID :
-        hhcd->MspInitCallback = HAL_HCD_MspInit;
+      case HAL_HCD_PORT_DISABLED_CB_ID :
-        break;
+        hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
+        break;
-      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
+      case HAL_HCD_MSPINIT_CB_ID :
-        break;
+        hhcd->MspInitCallback = HAL_HCD_MspInit;
+        break;
-      default :
-        /* Update the error code */
+      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+        hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
+        break;
-        /* Return error status */
-        status =  HAL_ERROR;
+      default :
-        break;
+        /* Update the error code */
-    }
+        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  }
-  else if (hhcd->State == HAL_HCD_STATE_RESET)
+        /* Return error status */
-  {
+        status =  HAL_ERROR;
-    switch (CallbackID)
+        break;
-    {
+    }
-      case HAL_HCD_MSPINIT_CB_ID :
+  }
-        hhcd->MspInitCallback = HAL_HCD_MspInit;
+  else if (hhcd->State == HAL_HCD_STATE_RESET)
-        break;
+  {
+    switch (CallbackID)
-      case HAL_HCD_MSPDEINIT_CB_ID :
+    {
-        hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
+      case HAL_HCD_MSPINIT_CB_ID :
-        break;
+        hhcd->MspInitCallback = HAL_HCD_MspInit;
+        break;
-      default :
-        /* Update the error code */
+      case HAL_HCD_MSPDEINIT_CB_ID :
-        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+        hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
+        break;
-        /* Return error status */
-        status =  HAL_ERROR;
+      default :
-        break;
+        /* Update the error code */
-    }
+        hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  }
-  else
+        /* Return error status */
-  {
+        status =  HAL_ERROR;
-    /* Update the error code */
+        break;
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+    }
+  }
-    /* Return error status */
+  else
-    status =  HAL_ERROR;
+  {
-  }
+    /* Update the error code */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  /* Release Lock */
-  __HAL_UNLOCK(hhcd);
+    /* Return error status */
-  return status;
+    status =  HAL_ERROR;
-}
+  }
-/**
+  /* Release Lock */
-  * @brief  Register USB HCD Host Channel Notify URB Change Callback
+  __HAL_UNLOCK(hhcd);
-  *         To be used instead of the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
+  return status;
-  * @param  hhcd HCD handle
+}
-  * @param  pCallback pointer to the USB HCD Host Channel Notify URB Change Callback function
-  * @retval HAL status
+/**
-  */
+  * @brief  Register USB HCD Host Channel Notify URB Change Callback
-HAL_StatusTypeDef HAL_HCD_RegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd,
+  *         To be used instead of the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
-                                                             pHCD_HC_NotifyURBChangeCallbackTypeDef pCallback)
+  * @param  hhcd HCD handle
-{
+  * @param  pCallback pointer to the USB HCD Host Channel Notify URB Change Callback function
-  HAL_StatusTypeDef status = HAL_OK;
+  * @retval HAL status
+  */
-  if (pCallback == NULL)
+HAL_StatusTypeDef HAL_HCD_RegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd,
-  {
+                                                             pHCD_HC_NotifyURBChangeCallbackTypeDef pCallback)
-    /* Update the error code */
+{
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+  HAL_StatusTypeDef status = HAL_OK;
-    return HAL_ERROR;
+  if (pCallback == NULL)
-  }
+  {
+    /* Update the error code */
-  /* Process locked */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  __HAL_LOCK(hhcd);
+    return HAL_ERROR;
-  if (hhcd->State == HAL_HCD_STATE_READY)
+  }
-  {
-    hhcd->HC_NotifyURBChangeCallback = pCallback;
+  /* Process locked */
-  }
+  __HAL_LOCK(hhcd);
-  else
-  {
+  if (hhcd->State == HAL_HCD_STATE_READY)
-    /* Update the error code */
+  {
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+    hhcd->HC_NotifyURBChangeCallback = pCallback;
+  }
-    /* Return error status */
+  else
-    status =  HAL_ERROR;
+  {
-  }
+    /* Update the error code */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  /* Release Lock */
-  __HAL_UNLOCK(hhcd);
+    /* Return error status */
+    status =  HAL_ERROR;
-  return status;
+  }
-}
+  /* Release Lock */
-/**
+  __HAL_UNLOCK(hhcd);
-  * @brief  Unregister the USB HCD Host Channel Notify URB Change Callback
-  *         USB HCD Host Channel Notify URB Change Callback is redirected
+  return status;
-  *         to the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
+}
-  * @param  hhcd HCD handle
-  * @retval HAL status
+/**
-  */
+  * @brief  Unregister the USB HCD Host Channel Notify URB Change Callback
-HAL_StatusTypeDef HAL_HCD_UnRegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd)
+  *         USB HCD Host Channel Notify URB Change Callback is redirected
-{
+  *         to the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
-  HAL_StatusTypeDef status = HAL_OK;
+  * @param  hhcd HCD handle
+  * @retval HAL status
-  /* Process locked */
+  */
-  __HAL_LOCK(hhcd);
+HAL_StatusTypeDef HAL_HCD_UnRegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd)
+{
-  if (hhcd->State == HAL_HCD_STATE_READY)
+  HAL_StatusTypeDef status = HAL_OK;
-  {
-    hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback; /* Legacy weak DataOutStageCallback  */
+  /* Process locked */
-  }
+  __HAL_LOCK(hhcd);
-  else
-  {
+  if (hhcd->State == HAL_HCD_STATE_READY)
-    /* Update the error code */
+  {
-    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
+    hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback; /* Legacy weak DataOutStageCallback  */
+  }
-    /* Return error status */
+  else
-    status =  HAL_ERROR;
+  {
-  }
+    /* Update the error code */
+    hhcd->ErrorCode |= HAL_HCD_ERROR_INVALID_CALLBACK;
-  /* Release Lock */
-  __HAL_UNLOCK(hhcd);
+    /* Return error status */
+    status =  HAL_ERROR;
-  return status;
+  }
-}
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+  /* Release Lock */
+  __HAL_UNLOCK(hhcd);
-/**
-  * @}
+  return status;
-  */
+}
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-/** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions
-  *  @brief   Management functions
+/**
-  *
+  * @}
-@verbatim
+  */
- ===============================================================================
-                      ##### Peripheral Control functions #####
+/** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions
- ===============================================================================
+  *  @brief   Management functions
-    [..]
+  *
-    This subsection provides a set of functions allowing to control the HCD data
+@verbatim
-    transfers.
+ ===============================================================================
+                      ##### Peripheral Control functions #####
-@endverbatim
+ ===============================================================================
-  * @{
+    [..]
-  */
+    This subsection provides a set of functions allowing to control the HCD data
+    transfers.
-/**
-  * @brief  Start the host driver.
+@endverbatim
-  * @param  hhcd HCD handle
+  * @{
-  * @retval HAL status
+  */
-  */
-HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Start the host driver.
-  __HAL_LOCK(hhcd);
+  * @param  hhcd HCD handle
-  /* Enable port power */
+  * @retval HAL status
-  (void)USB_DriveVbus(hhcd->Instance, 1U);
+  */
+HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd)
-  /* Enable global interrupt */
+{
-  __HAL_HCD_ENABLE(hhcd);
+  __HAL_LOCK(hhcd);
-  __HAL_UNLOCK(hhcd);
+  /* Enable port power */
+  (void)USB_DriveVbus(hhcd->Instance, 1U);
-  return HAL_OK;
-}
+  /* Enable global interrupt */
+  __HAL_HCD_ENABLE(hhcd);
-/**
+  __HAL_UNLOCK(hhcd);
-  * @brief  Stop the host driver.
-  * @param  hhcd HCD handle
+  return HAL_OK;
-  * @retval HAL status
+}
-  */
+/**
-HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd)
+  * @brief  Stop the host driver.
-{
+  * @param  hhcd HCD handle
-  __HAL_LOCK(hhcd);
+  * @retval HAL status
-  (void)USB_StopHost(hhcd->Instance);
+  */
-  __HAL_UNLOCK(hhcd);
+HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd)
-  return HAL_OK;
+{
-}
+  __HAL_LOCK(hhcd);
+  (void)USB_StopHost(hhcd->Instance);
-/**
+  __HAL_UNLOCK(hhcd);
-  * @brief  Reset the host port.
-  * @param  hhcd HCD handle
+  return HAL_OK;
-  * @retval HAL status
+}
-  */
-HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Reset the host port.
-  return (USB_ResetPort(hhcd->Instance));
+  * @param  hhcd HCD handle
-}
+  * @retval HAL status
+  */
-/**
+HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd)
-  * @}
+{
-  */
+  return (USB_ResetPort(hhcd->Instance));
+}
-/** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions
-  *  @brief   Peripheral State functions
+/**
-  *
+  * @}
-@verbatim
+  */
- ===============================================================================
-                      ##### Peripheral State functions #####
+/** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions
- ===============================================================================
+  *  @brief   Peripheral State functions
-    [..]
+  *
-    This subsection permits to get in run-time the status of the peripheral
+@verbatim
-    and the data flow.
+ ===============================================================================
+                      ##### Peripheral State functions #####
-@endverbatim
+ ===============================================================================
-  * @{
+    [..]
-  */
+    This subsection permits to get in run-time the status of the peripheral
+    and the data flow.
-/**
-  * @brief  Return the HCD handle state.
+@endverbatim
-  * @param  hhcd HCD handle
+  * @{
-  * @retval HAL state
+  */
-  */
-HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Return the HCD handle state.
-  return hhcd->State;
+  * @param  hhcd HCD handle
-}
+  * @retval HAL state
+  */
-/**
+HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef const *hhcd)
-  * @brief  Return  URB state for a channel.
+{
-  * @param  hhcd HCD handle
+  return hhcd->State;
-  * @param  chnum Channel number.
+}
-  *         This parameter can be a value from 1 to 15
-  * @retval URB state.
+/**
-  *          This parameter can be one of these values:
+  * @brief  Return  URB state for a channel.
-  *            URB_IDLE/
+  * @param  hhcd HCD handle
-  *            URB_DONE/
+  * @param  chnum Channel number.
-  *            URB_NOTREADY/
+  *         This parameter can be a value from 1 to 15
-  *            URB_NYET/
+  * @retval URB state.
-  *            URB_ERROR/
+  *          This parameter can be one of these values:
-  *            URB_STALL
+  *            URB_IDLE/
-  */
+  *            URB_DONE/
-HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
+  *            URB_NOTREADY/
-{
+  *            URB_NYET/
-  return hhcd->hc[chnum].urb_state;
+  *            URB_ERROR/
-}
+  *            URB_STALL
+  */
+HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef const *hhcd, uint8_t chnum)
-/**
+{
-  * @brief  Return the last host transfer size.
+  return hhcd->hc[chnum].urb_state;
-  * @param  hhcd HCD handle
+}
-  * @param  chnum Channel number.
-  *         This parameter can be a value from 1 to 15
-  * @retval last transfer size in byte
+/**
-  */
+  * @brief  Return the last host transfer size.
-uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef *hhcd, uint8_t chnum)
+  * @param  hhcd HCD handle
-{
+  * @param  chnum Channel number.
-  return hhcd->hc[chnum].xfer_count;
+  *         This parameter can be a value from 1 to 15
-}
+  * @retval last transfer size in byte
+  */
-/**
+uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef const *hhcd, uint8_t chnum)
-  * @brief  Return the Host Channel state.
+{
-  * @param  hhcd HCD handle
+  return hhcd->hc[chnum].xfer_count;
-  * @param  chnum Channel number.
+}
-  *         This parameter can be a value from 1 to 15
-  * @retval Host channel state
+/**
-  *          This parameter can be one of these values:
+  * @brief  Return the Host Channel state.
-  *            HC_IDLE/
+  * @param  hhcd HCD handle
-  *            HC_XFRC/
+  * @param  chnum Channel number.
-  *            HC_HALTED/
+  *         This parameter can be a value from 1 to 15
-  *            HC_NYET/
+  * @retval Host channel state
-  *            HC_NAK/
+  *          This parameter can be one of these values:
-  *            HC_STALL/
+  *            HC_IDLE/
-  *            HC_XACTERR/
+  *            HC_XFRC/
-  *            HC_BBLERR/
+  *            HC_HALTED/
-  *            HC_DATATGLERR
+  *            HC_NYET/
-  */
+  *            HC_NAK/
-HCD_HCStateTypeDef  HAL_HCD_HC_GetState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
+  *            HC_STALL/
-{
+  *            HC_XACTERR/
-  return hhcd->hc[chnum].state;
+  *            HC_BBLERR/
-}
+  *            HC_DATATGLERR
+  */
-/**
+HCD_HCStateTypeDef  HAL_HCD_HC_GetState(HCD_HandleTypeDef const *hhcd, uint8_t chnum)
-  * @brief  Return the current Host frame number.
+{
-  * @param  hhcd HCD handle
+  return hhcd->hc[chnum].state;
-  * @retval Current Host frame number
+}
-  */
-uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Return the current Host frame number.
-  return (USB_GetCurrentFrame(hhcd->Instance));
+  * @param  hhcd HCD handle
-}
+  * @retval Current Host frame number
+  */
-/**
+uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd)
-  * @brief  Return the Host enumeration speed.
+{
-  * @param  hhcd HCD handle
+  return (USB_GetCurrentFrame(hhcd->Instance));
-  * @retval Enumeration speed
+}
-  */
-uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd)
+/**
-{
+  * @brief  Return the Host enumeration speed.
-  return (USB_GetHostSpeed(hhcd->Instance));
+  * @param  hhcd HCD handle
-}
+  * @retval Enumeration speed
+  */
-/**
+uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd)
-  * @}
+{
-  */
+  return (USB_GetHostSpeed(hhcd->Instance));
+}
-/**
-  * @}
+/**
-  */
+  * @brief  Set host channel Hub information.
+  * @param  hhcd HCD handle
-/** @addtogroup HCD_Private_Functions
+  * @param  ch_num Channel number.
-  * @{
+  *         This parameter can be a value from 1 to 15
-  */
+  * @param  addr Hub address
-/**
+  * @param  PortNbr Hub port number
-  * @brief  Handle Host Channel IN interrupt requests.
+  * @retval HAL status
-  * @param  hhcd HCD handle
+  */
-  * @param  chnum Channel number.
+HAL_StatusTypeDef HAL_HCD_HC_SetHubInfo(HCD_HandleTypeDef *hhcd, uint8_t ch_num,
-  *         This parameter can be a value from 1 to 15
+                                        uint8_t addr, uint8_t PortNbr)
-  * @retval none
+{
-  */
+  hhcd->hc[ch_num].hub_addr = addr;
-static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
+  hhcd->hc[ch_num].hub_port_nbr = PortNbr;
-{
-  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
+  return HAL_OK;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+}
-  uint32_t ch_num = (uint32_t)chnum;
-  uint32_t tmpreg;
+/**
+  * @brief  Clear host channel hub information.
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
+  * @param  hhcd HCD handle
-  {
+  * @param  ch_num Channel number.
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
+  *         This parameter can be a value from 1 to 15
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  * @retval HAL status
-  }
+  */
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR)
+HAL_StatusTypeDef HAL_HCD_HC_ClearHubInfo(HCD_HandleTypeDef *hhcd, uint8_t ch_num)
-  {
+{
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_BBERR);
+  hhcd->hc[ch_num].hub_addr = 0U;
-    hhcd->hc[ch_num].state = HC_BBLERR;
+  hhcd->hc[ch_num].hub_port_nbr = 0U;
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  return HAL_OK;
-  }
+}
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
+/**
-  {
+  * @}
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
+  */
-  }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
+/**
-  {
+  * @}
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  */
-    hhcd->hc[ch_num].state = HC_STALL;
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+/** @addtogroup HCD_Private_Functions
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
+  * @{
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  */
-  }
+/**
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
+  * @brief  Handle Host Channel IN interrupt requests.
-  {
+  * @param  hhcd HCD handle
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  * @param  chnum Channel number.
-    hhcd->hc[ch_num].state = HC_DATATGLERR;
+  *         This parameter can be a value from 1 to 15
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+  * @retval none
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
+  */
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
-  }
+{
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
+  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
-  {
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  uint32_t tmpreg;
-    hhcd->hc[ch_num].state = HC_XACTERR;
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_AHBERR))
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
+  {
-  }
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
-  else
+    hhcd->hc[chnum].state = HC_XACTERR;
-  {
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    /* ... */
+  }
-  }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_BBERR))
+  {
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_BBERR);
-  {
+    hhcd->hc[chnum].state = HC_BBLERR;
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  }
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_STALL))
-  }
+  {
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);
-  {
+    hhcd->hc[chnum].state = HC_STALL;
-    hhcd->hc[ch_num].state = HC_XFRC;
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    hhcd->hc[ch_num].ErrCnt = 0U;
+  }
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_DTERR))
+  {
-    if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) ||
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);
-        (hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
+    hhcd->hc[chnum].state = HC_DATATGLERR;
-    {
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-      __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  }
-      (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_TXERR))
-      __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+  {
-    }
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
-    else if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
+    hhcd->hc[chnum].state = HC_XACTERR;
-    {
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-      USBx_HC(ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
+  }
-      hhcd->hc[ch_num].urb_state = URB_DONE;
+  else
+  {
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    /* ... */
-      hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+  }
-#else
-      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+  if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_FRMOR))
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+  {
-    }
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    else if (hhcd->hc[ch_num].ep_type == EP_TYPE_ISOC)
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
-    {
+  }
-      hhcd->hc[ch_num].urb_state = URB_DONE;
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_XFRC))
-      hhcd->hc[ch_num].toggle_in ^= 1U;
+  {
+    hhcd->hc[chnum].state = HC_XFRC;
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    hhcd->hc[chnum].ErrCnt = 0U;
-      hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
-#else
-      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+    if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL) ||
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+        (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
-    }
+    {
-    else
+      (void)USB_HC_Halt(hhcd->Instance, chnum);
-    {
+      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
-      /* ... */
+    }
-    }
+    else if ((hhcd->hc[chnum].ep_type == EP_TYPE_INTR) ||
+             (hhcd->hc[chnum].ep_type == EP_TYPE_ISOC))
-    if (hhcd->Init.dma_enable == 1U)
+    {
-    {
+      USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
-      if (((hhcd->hc[ch_num].XferSize / hhcd->hc[ch_num].max_packet) & 1U) != 0U)
+      hhcd->hc[chnum].urb_state = URB_DONE;
-      {
-        hhcd->hc[ch_num].toggle_in ^= 1U;
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-      }
+      hhcd->HC_NotifyURBChangeCallback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-    }
+#else
-    else
+      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-    {
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-      hhcd->hc[ch_num].toggle_in ^= 1U;
+    }
-    }
+    else
-  }
+    {
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
+      /* ... */
-  {
+    }
-    __HAL_HCD_MASK_HALT_HC_INT(ch_num);
+    if (hhcd->Init.dma_enable == 1U)
-    if (hhcd->hc[ch_num].state == HC_XFRC)
+    {
-    {
+      if ((((hhcd->hc[chnum].xfer_count + hhcd->hc[chnum].max_packet - 1U) / hhcd->hc[chnum].max_packet) & 1U) != 0U)
-      hhcd->hc[ch_num].urb_state = URB_DONE;
+      {
-    }
+        hhcd->hc[chnum].toggle_in ^= 1U;
-    else if (hhcd->hc[ch_num].state == HC_STALL)
+      }
-    {
+    }
-      hhcd->hc[ch_num].urb_state = URB_STALL;
+    else
-    }
+    {
-    else if ((hhcd->hc[ch_num].state == HC_XACTERR) ||
+      hhcd->hc[chnum].toggle_in ^= 1U;
-             (hhcd->hc[ch_num].state == HC_DATATGLERR))
+    }
-    {
+  }
-      hhcd->hc[ch_num].ErrCnt++;
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_ACK))
-      if (hhcd->hc[ch_num].ErrCnt > 2U)
+  {
-      {
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
-        hhcd->hc[ch_num].ErrCnt = 0U;
+  }
-        hhcd->hc[ch_num].urb_state = URB_ERROR;
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_CHH))
-      }
+  {
-      else
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
-      {
-        hhcd->hc[ch_num].urb_state = URB_NOTREADY;
+    if (hhcd->hc[chnum].state == HC_XFRC)
+    {
-        /* re-activate the channel */
+      hhcd->hc[chnum].state = HC_HALTED;
-        tmpreg = USBx_HC(ch_num)->HCCHAR;
+      hhcd->hc[chnum].urb_state = URB_DONE;
-        tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+    }
-        tmpreg |= USB_OTG_HCCHAR_CHENA;
+    else if (hhcd->hc[chnum].state == HC_STALL)
-        USBx_HC(ch_num)->HCCHAR = tmpreg;
+    {
-      }
+      hhcd->hc[chnum].state = HC_HALTED;
-    }
+      hhcd->hc[chnum].urb_state = URB_STALL;
-    else if (hhcd->hc[ch_num].state == HC_NAK)
+    }
-    {
+    else if ((hhcd->hc[chnum].state == HC_XACTERR) ||
-      hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
+             (hhcd->hc[chnum].state == HC_DATATGLERR))
+    {
-      /* re-activate the channel */
+      hhcd->hc[chnum].state = HC_HALTED;
-      tmpreg = USBx_HC(ch_num)->HCCHAR;
+      hhcd->hc[chnum].ErrCnt++;
-      tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+      if (hhcd->hc[chnum].ErrCnt > 2U)
-      tmpreg |= USB_OTG_HCCHAR_CHENA;
+      {
-      USBx_HC(ch_num)->HCCHAR = tmpreg;
+        hhcd->hc[chnum].ErrCnt = 0U;
-    }
+        hhcd->hc[chnum].urb_state = URB_ERROR;
-    else if (hhcd->hc[ch_num].state == HC_BBLERR)
+      }
-    {
+      else
-      hhcd->hc[ch_num].ErrCnt++;
+      {
-      hhcd->hc[ch_num].urb_state = URB_ERROR;
+        hhcd->hc[chnum].urb_state = URB_NOTREADY;
-    }
-    else
+        if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL) ||
-    {
+            (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
-      /* ... */
+        {
-    }
+          /* re-activate the channel */
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
+          tmpreg = USBx_HC(chnum)->HCCHAR;
-    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+          tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
-  }
+          tmpreg |= USB_OTG_HCCHAR_CHENA;
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
+          USBx_HC(chnum)->HCCHAR = tmpreg;
-  {
+        }
-    if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
+      }
-    {
+    }
-      hhcd->hc[ch_num].ErrCnt = 0U;
+    else if (hhcd->hc[chnum].state == HC_NYET)
-      __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+    {
-      (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+      hhcd->hc[chnum].state = HC_HALTED;
     }
-    else if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) ||
+    else if (hhcd->hc[chnum].state == HC_ACK)
-             (hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
+    {
-    {
+      hhcd->hc[chnum].state = HC_HALTED;
-      hhcd->hc[ch_num].ErrCnt = 0U;
+    }
-      hhcd->hc[ch_num].state = HC_NAK;
+    else if (hhcd->hc[chnum].state == HC_NAK)
-      __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+    {
-      (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+      hhcd->hc[chnum].state = HC_HALTED;
-    }
+      hhcd->hc[chnum].urb_state = URB_NOTREADY;
-    else
-    {
+      if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL) ||
-      /* ... */
+          (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
-    }
+      {
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+        /* re-activate the channel */
-  }
+        tmpreg = USBx_HC(chnum)->HCCHAR;
-  else
+        tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
-  {
+        tmpreg |= USB_OTG_HCCHAR_CHENA;
-    /* ... */
+        USBx_HC(chnum)->HCCHAR = tmpreg;
-  }
+      }
-}
+    }
+    else if (hhcd->hc[chnum].state == HC_BBLERR)
-/**
+    {
-  * @brief  Handle Host Channel OUT interrupt requests.
+      hhcd->hc[chnum].state = HC_HALTED;
-  * @param  hhcd HCD handle
+      hhcd->hc[chnum].ErrCnt++;
-  * @param  chnum Channel number.
+      hhcd->hc[chnum].urb_state = URB_ERROR;
-  *         This parameter can be a value from 1 to 15
+    }
-  * @retval none
+    else
-  */
+    {
-static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
+      if (hhcd->hc[chnum].state == HC_HALTED)
-{
+      {
-  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
+        return;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+      }
-  uint32_t ch_num = (uint32_t)chnum;
+    }
-  uint32_t tmpreg;
-  uint32_t num_packets;
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    hhcd->HC_NotifyURBChangeCallback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
+#else
-  {
+    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  }
-  }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_NYET))
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
+  {
-  {
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NYET);
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
+    hhcd->hc[chnum].state = HC_NYET;
+    hhcd->hc[chnum].ErrCnt = 0U;
-    if (hhcd->hc[ch_num].do_ping == 1U)
-    {
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-      hhcd->hc[ch_num].do_ping = 0U;
+  }
-      hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_NAK))
-      __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  {
-      (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+    if (hhcd->hc[chnum].ep_type == EP_TYPE_INTR)
-    }
+    {
-  }
+      hhcd->hc[chnum].ErrCnt = 0U;
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
+      hhcd->hc[chnum].state = HC_NAK;
-  {
+      (void)USB_HC_Halt(hhcd->Instance, chnum);
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+    }
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+    else if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL) ||
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
+             (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
-  }
+    {
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
+      hhcd->hc[chnum].ErrCnt = 0U;
-  {
+      hhcd->hc[chnum].state = HC_NAK;
-    hhcd->hc[ch_num].ErrCnt = 0U;
+      (void)USB_HC_Halt(hhcd->Instance, chnum);
+    }
-    /* transaction completed with NYET state, update do ping state */
+    else
-    if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
+    {
-    {
+      /* ... */
-      hhcd->hc[ch_num].do_ping = 1U;
+    }
-      __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);
-    }
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  }
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  else
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
+  {
-    hhcd->hc[ch_num].state = HC_XFRC;
+    /* ... */
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
+}
-  {
-    hhcd->hc[ch_num].state = HC_NYET;
+/**
-    hhcd->hc[ch_num].do_ping = 1U;
+  * @brief  Handle Host Channel OUT interrupt requests.
-    hhcd->hc[ch_num].ErrCnt = 0U;
+  * @param  hhcd HCD handle
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  * @param  chnum Channel number.
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  *         This parameter can be a value from 1 to 15
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);
+  * @retval none
-  }
+  */
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
+static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
-  {
+{
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
+  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  uint32_t tmpreg;
-    hhcd->hc[ch_num].state = HC_STALL;
+  uint32_t num_packets;
-  }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
+  if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_AHBERR))
   {
-    hhcd->hc[ch_num].ErrCnt = 0U;
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
-    hhcd->hc[ch_num].state = HC_NAK;
+    hhcd->hc[chnum].state = HC_XACTERR;
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+  }
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_ACK))
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+  {
-  }
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
+  }
-  {
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_FRMOR))
-    hhcd->hc[ch_num].state = HC_XACTERR;
+  {
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
+  }
-  }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_XFRC))
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
+  {
-  {
+    hhcd->hc[chnum].ErrCnt = 0U;
-    __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
-    (void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
+    hhcd->hc[chnum].state = HC_XFRC;
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    hhcd->hc[ch_num].state = HC_DATATGLERR;
+  }
-  }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_STALL))
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
+  {
-  {
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);
-    __HAL_HCD_MASK_HALT_HC_INT(ch_num);
+    hhcd->hc[chnum].state = HC_STALL;
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-    if (hhcd->hc[ch_num].state == HC_XFRC)
+  }
-    {
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_NAK))
-      hhcd->hc[ch_num].urb_state  = URB_DONE;
+  {
-      if ((hhcd->hc[ch_num].ep_type == EP_TYPE_BULK) ||
+    hhcd->hc[chnum].ErrCnt = 0U;
-          (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR))
+    hhcd->hc[chnum].state = HC_NAK;
-      {
-        if (hhcd->Init.dma_enable == 0U)
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-        {
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
-          hhcd->hc[ch_num].toggle_out ^= 1U;
+  }
-        }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_TXERR))
+  {
-        if ((hhcd->Init.dma_enable == 1U) && (hhcd->hc[ch_num].xfer_len > 0U))
+    hhcd->hc[chnum].state = HC_XACTERR;
-        {
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-          num_packets = (hhcd->hc[ch_num].xfer_len + hhcd->hc[ch_num].max_packet - 1U) / hhcd->hc[ch_num].max_packet;
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
+  }
-          if ((num_packets & 1U) != 0U)
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_DTERR))
-          {
+  {
-            hhcd->hc[ch_num].toggle_out ^= 1U;
+    hhcd->hc[chnum].state = HC_DATATGLERR;
-          }
+    (void)USB_HC_Halt(hhcd->Instance, chnum);
-        }
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);
-      }
+  }
-    }
+  else if (__HAL_HCD_GET_CH_FLAG(hhcd, chnum, USB_OTG_HCINT_CHH))
-    else if (hhcd->hc[ch_num].state == HC_NAK)
+  {
-    {
+    __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
-      hhcd->hc[ch_num].urb_state = URB_NOTREADY;
-    }
+    if (hhcd->hc[chnum].state == HC_XFRC)
-    else if (hhcd->hc[ch_num].state == HC_NYET)
+    {
-    {
+      hhcd->hc[chnum].state = HC_HALTED;
-      hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
+      hhcd->hc[chnum].urb_state = URB_DONE;
-    }
-    else if (hhcd->hc[ch_num].state == HC_STALL)
+      if ((hhcd->hc[chnum].ep_type == EP_TYPE_BULK) ||
-    {
+          (hhcd->hc[chnum].ep_type == EP_TYPE_INTR))
-      hhcd->hc[ch_num].urb_state  = URB_STALL;
+      {
-    }
+        if (hhcd->Init.dma_enable == 0U)
-    else if ((hhcd->hc[ch_num].state == HC_XACTERR) ||
+        {
-             (hhcd->hc[ch_num].state == HC_DATATGLERR))
+          hhcd->hc[chnum].toggle_out ^= 1U;
-    {
+        }
-      hhcd->hc[ch_num].ErrCnt++;
-      if (hhcd->hc[ch_num].ErrCnt > 2U)
+        if ((hhcd->Init.dma_enable == 1U) && (hhcd->hc[chnum].xfer_len > 0U))
-      {
+        {
-        hhcd->hc[ch_num].ErrCnt = 0U;
+          num_packets = (hhcd->hc[chnum].xfer_len + hhcd->hc[chnum].max_packet - 1U) / hhcd->hc[chnum].max_packet;
-        hhcd->hc[ch_num].urb_state = URB_ERROR;
-      }
+          if ((num_packets & 1U) != 0U)
-      else
+          {
-      {
+            hhcd->hc[chnum].toggle_out ^= 1U;
-        hhcd->hc[ch_num].urb_state = URB_NOTREADY;
+          }
+        }
-        /* re-activate the channel  */
+      }
-        tmpreg = USBx_HC(ch_num)->HCCHAR;
+    }
-        tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+    else if (hhcd->hc[chnum].state == HC_ACK)
-        tmpreg |= USB_OTG_HCCHAR_CHENA;
+    {
-        USBx_HC(ch_num)->HCCHAR = tmpreg;
+      hhcd->hc[chnum].state = HC_HALTED;
-      }
+    }
-    }
+    else if (hhcd->hc[chnum].state == HC_NAK)
-    else
+    {
-    {
+      hhcd->hc[chnum].state = HC_HALTED;
-      /* ... */
+      hhcd->hc[chnum].urb_state = URB_NOTREADY;
     }
+    else if (hhcd->hc[chnum].state == HC_STALL)
-    __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
+    {
-    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
+      hhcd->hc[chnum].state = HC_HALTED;
-  }
+      hhcd->hc[chnum].urb_state  = URB_STALL;
-  else
+    }
-  {
+    else if ((hhcd->hc[chnum].state == HC_XACTERR) ||
-    /* ... */
+             (hhcd->hc[chnum].state == HC_DATATGLERR))
-  }
+    {
-}
+      hhcd->hc[chnum].state = HC_HALTED;
+      hhcd->hc[chnum].ErrCnt++;
-/**
+      if (hhcd->hc[chnum].ErrCnt > 2U)
-  * @brief  Handle Rx Queue Level interrupt requests.
+      {
-  * @param  hhcd HCD handle
+        hhcd->hc[chnum].ErrCnt = 0U;
-  * @retval none
+        hhcd->hc[chnum].urb_state = URB_ERROR;
-  */
+      }
-static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd)
+      else
-{
+      {
-  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
+        hhcd->hc[chnum].urb_state = URB_NOTREADY;
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t pktsts;
+        /* re-activate the channel  */
-  uint32_t pktcnt;
+        tmpreg = USBx_HC(chnum)->HCCHAR;
-  uint32_t GrxstspReg;
+        tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
-  uint32_t xferSizePktCnt;
+        tmpreg |= USB_OTG_HCCHAR_CHENA;
-  uint32_t tmpreg;
+        USBx_HC(chnum)->HCCHAR = tmpreg;
-  uint32_t ch_num;
+      }
+    }
-  GrxstspReg = hhcd->Instance->GRXSTSP;
+    else
-  ch_num = GrxstspReg & USB_OTG_GRXSTSP_EPNUM;
+    {
-  pktsts = (GrxstspReg & USB_OTG_GRXSTSP_PKTSTS) >> 17;
+      return;
-  pktcnt = (GrxstspReg & USB_OTG_GRXSTSP_BCNT) >> 4;
+    }
-  switch (pktsts)
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-  {
+    hhcd->HC_NotifyURBChangeCallback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-    case GRXSTS_PKTSTS_IN:
+#else
-      /* Read the data into the host buffer. */
+    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
-      if ((pktcnt > 0U) && (hhcd->hc[ch_num].xfer_buff != (void *)0))
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-      {
+  }
-        if ((hhcd->hc[ch_num].xfer_count + pktcnt) <= hhcd->hc[ch_num].xfer_len)
+  else
-        {
+  {
-          (void)USB_ReadPacket(hhcd->Instance,
+    return;
-                               hhcd->hc[ch_num].xfer_buff, (uint16_t)pktcnt);
+  }
+}
-          /* manage multiple Xfer */
-          hhcd->hc[ch_num].xfer_buff += pktcnt;
+/**
-          hhcd->hc[ch_num].xfer_count += pktcnt;
+  * @brief  Handle Rx Queue Level interrupt requests.
+  * @param  hhcd HCD handle
-          /* get transfer size packet count */
+  * @retval none
-          xferSizePktCnt = (USBx_HC(ch_num)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) >> 19;
+  */
+static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd)
-          if ((hhcd->hc[ch_num].max_packet == pktcnt) && (xferSizePktCnt > 0U))
+{
-          {
+  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
-            /* re-activate the channel when more packets are expected */
+  uint32_t USBx_BASE = (uint32_t)USBx;
-            tmpreg = USBx_HC(ch_num)->HCCHAR;
+  uint32_t pktsts;
-            tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+  uint32_t pktcnt;
-            tmpreg |= USB_OTG_HCCHAR_CHENA;
+  uint32_t GrxstspReg;
-            USBx_HC(ch_num)->HCCHAR = tmpreg;
+  uint32_t xferSizePktCnt;
-            hhcd->hc[ch_num].toggle_in ^= 1U;
+  uint32_t tmpreg;
-          }
+  uint32_t chnum;
-        }
-        else
+  GrxstspReg = hhcd->Instance->GRXSTSP;
-        {
+  chnum = GrxstspReg & USB_OTG_GRXSTSP_EPNUM;
-          hhcd->hc[ch_num].urb_state = URB_ERROR;
+  pktsts = (GrxstspReg & USB_OTG_GRXSTSP_PKTSTS) >> 17;
-        }
+  pktcnt = (GrxstspReg & USB_OTG_GRXSTSP_BCNT) >> 4;
-      }
-      break;
+  switch (pktsts)
+  {
-    case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
+    case GRXSTS_PKTSTS_IN:
-      break;
+      /* Read the data into the host buffer. */
+      if ((pktcnt > 0U) && (hhcd->hc[chnum].xfer_buff != (void *)0))
-    case GRXSTS_PKTSTS_IN_XFER_COMP:
+      {
-    case GRXSTS_PKTSTS_CH_HALTED:
+        if ((hhcd->hc[chnum].xfer_count + pktcnt) <= hhcd->hc[chnum].xfer_len)
-    default:
+        {
-      break;
+          (void)USB_ReadPacket(hhcd->Instance,
-  }
+                               hhcd->hc[chnum].xfer_buff, (uint16_t)pktcnt);
-}
+          /* manage multiple Xfer */
-/**
+          hhcd->hc[chnum].xfer_buff += pktcnt;
-  * @brief  Handle Host Port interrupt requests.
+          hhcd->hc[chnum].xfer_count += pktcnt;
-  * @param  hhcd HCD handle
-  * @retval None
+          /* get transfer size packet count */
-  */
+          xferSizePktCnt = (USBx_HC(chnum)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) >> 19;
-static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd)
-{
+          if ((hhcd->hc[chnum].max_packet == pktcnt) && (xferSizePktCnt > 0U))
-  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
+          {
-  uint32_t USBx_BASE = (uint32_t)USBx;
+            /* re-activate the channel when more packets are expected */
-  __IO uint32_t hprt0;
+            tmpreg = USBx_HC(chnum)->HCCHAR;
-  __IO uint32_t hprt0_dup;
+            tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+            tmpreg |= USB_OTG_HCCHAR_CHENA;
-  /* Handle Host Port Interrupts */
+            USBx_HC(chnum)->HCCHAR = tmpreg;
-  hprt0 = USBx_HPRT0;
+            hhcd->hc[chnum].toggle_in ^= 1U;
-  hprt0_dup = USBx_HPRT0;
+          }
+        }
-  hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET | \
+        else
-                 USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
+        {
+          hhcd->hc[chnum].urb_state = URB_ERROR;
-  /* Check whether Port Connect detected */
+        }
-  if ((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
+      }
-  {
+      break;
-    if ((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
-    {
+    case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      break;
-      hhcd->ConnectCallback(hhcd);
-#else
+    case GRXSTS_PKTSTS_IN_XFER_COMP:
-      HAL_HCD_Connect_Callback(hhcd);
+    case GRXSTS_PKTSTS_CH_HALTED:
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    default:
-    }
+      break;
-    hprt0_dup |= USB_OTG_HPRT_PCDET;
+  }
-  }
+}
-  /* Check whether Port Enable Changed */
+/**
-  if ((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
+  * @brief  Handle Host Port interrupt requests.
-  {
+  * @param  hhcd HCD handle
-    hprt0_dup |= USB_OTG_HPRT_PENCHNG;
+  * @retval None
+  */
-    if ((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
+static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd)
-    {
+{
-      if (hhcd->Init.phy_itface  == USB_OTG_EMBEDDED_PHY)
+  USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
-      {
+  uint32_t USBx_BASE = (uint32_t)USBx;
-        if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17))
+  __IO uint32_t hprt0;
-        {
+  __IO uint32_t hprt0_dup;
-          (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_6_MHZ);
-        }
+  /* Handle Host Port Interrupts */
-        else
+  hprt0 = USBx_HPRT0;
-        {
+  hprt0_dup = USBx_HPRT0;
-          (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
-        }
+  hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET | \
-      }
+                 USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
-      else
-      {
+  /* Check whether Port Connect detected */
-        if (hhcd->Init.speed == HCD_SPEED_FULL)
+  if ((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
-        {
+  {
-          USBx_HOST->HFIR = 60000U;
+    if ((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
-        }
+    {
-      }
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->ConnectCallback(hhcd);
-      hhcd->PortEnabledCallback(hhcd);
+#else
-#else
+      HAL_HCD_Connect_Callback(hhcd);
-      HAL_HCD_PortEnabled_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    }
+    hprt0_dup |= USB_OTG_HPRT_PCDET;
-    }
+  }
-    else
-    {
+  /* Check whether Port Enable Changed */
-#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+  if ((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
-      hhcd->PortDisabledCallback(hhcd);
+  {
-#else
+    hprt0_dup |= USB_OTG_HPRT_PENCHNG;
-      HAL_HCD_PortDisabled_Callback(hhcd);
-#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    if ((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
-    }
+    {
-  }
+      if (hhcd->Init.phy_itface == USB_OTG_EMBEDDED_PHY)
+      {
-  /* Check for an overcurrent */
+        if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17))
-  if ((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
+        {
-  {
+          (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_6_MHZ);
-    hprt0_dup |= USB_OTG_HPRT_POCCHNG;
+        }
-  }
+        else
+        {
-  /* Clear Port Interrupts */
+          (void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
-  USBx_HPRT0 = hprt0_dup;
+        }
-}
+      }
+      else
-/**
+      {
-  * @}
+        if (hhcd->Init.speed == HCD_SPEED_FULL)
-  */
+        {
+          USBx_HOST->HFIR = HFIR_60_MHZ;
-/**
+        }
-  * @}
+      }
-  */
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->PortEnabledCallback(hhcd);
-#endif /* defined (USB_OTG_FS) */
+#else
-#endif /* HAL_HCD_MODULE_ENABLED */
+      HAL_HCD_PortEnabled_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
-/**
-  * @}
+    }
-  */
+    else
+    {
-/**
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
-  * @}
+      hhcd->PortDisabledCallback(hhcd);
-  */
+#else
+      HAL_HCD_PortDisabled_Callback(hhcd);
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    }
+  }
+  /* Check for an overcurrent */
+  if ((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
+  {
+    hprt0_dup |= USB_OTG_HPRT_POCCHNG;
+  }
+  /* Clear Port Interrupts */
+  USBx_HPRT0 = hprt0_dup;
+}
+/**
+  * @}
+  */
+/**
+  * @}
+  */
+#endif /* defined (USB_OTG_FS) */
+#endif /* HAL_HCD_MODULE_ENABLED */
+/**
+  * @}
+  */
+/**
+  * @}
+  */

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_hcd.c – Rev 2 → 3