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

 /**
   ******************************************************************************
   * @file    stm32f1xx_ll_usb.c
   * @author  MCD Application Team
   * @brief   USB Low Layer HAL module driver.
   *
   *          This file provides firmware functions to manage the following
   *          functionalities of the USB Peripheral Controller:
   *           + Initialization/de-initialization functions
   *           + I/O operation functions
   *           + Peripheral Control functions
   *           + Peripheral State functions
   *
-  @verbatim
+  ******************************************************************************
-  ==============================================================================
+  * @attention
-                    ##### How to use this driver #####
+  *
-  ==============================================================================
+  * Copyright (c) 2016 STMicroelectronics.
-    [..]
+  * All rights reserved.
-      (#) Fill parameters of Init structure in USB_OTG_CfgTypeDef structure.
+  *
+  * This software is licensed under terms that can be found in the LICENSE file
-      (#) Call USB_CoreInit() API to initialize the USB Core peripheral.
+  * in the root directory of this software component.
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-      (#) The upper HAL HCD/PCD driver will call the right routines for its internal processes.
+  *
+  ******************************************************************************
-  @endverbatim
+  @verbatim
-  ******************************************************************************
+  ==============================================================================
-  * @attention
+                    ##### How to use this driver #####
-  *
+  ==============================================================================
-  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+    [..]
-  * All rights reserved.</center></h2>
+      (#) Fill parameters of Init structure in USB_CfgTypeDef structure.
-  *
-  * This software component is licensed by ST under BSD 3-Clause license,
+      (#) Call USB_CoreInit() API to initialize the USB Core peripheral.
-  * the "License"; You may not use this file except in compliance with the
-  * License. You may obtain a copy of the License at:
+      (#) The upper HAL HCD/PCD driver will call the right routines for its internal processes.
-  *                        opensource.org/licenses/BSD-3-Clause
-  *
+  @endverbatim
-  ******************************************************************************
-  */
+  ******************************************************************************
+  */
-/* Includes ------------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f1xx_hal.h"
-/** @addtogroup STM32F1xx_LL_USB_DRIVER
-  * @{
+/** @addtogroup STM32F1xx_LL_USB_DRIVER
-  */
+  * @{
+  */
-#if defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED)
-#if defined (USB) || defined (USB_OTG_FS)
+#if defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED)
-/* Private typedef -----------------------------------------------------------*/
+#if defined (USB) || defined (USB_OTG_FS)
-/* Private define ------------------------------------------------------------*/
+/* Private typedef -----------------------------------------------------------*/
-/* Private macro -------------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
-/* Private variables ---------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
-/* Private function prototypes -----------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
-/* Private functions ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
-#if defined (USB_OTG_FS)
+/* Private functions ---------------------------------------------------------*/
-static HAL_StatusTypeDef USB_CoreReset(USB_OTG_GlobalTypeDef *USBx);
+#if defined (USB_OTG_FS)
+static HAL_StatusTypeDef USB_CoreReset(USB_OTG_GlobalTypeDef *USBx);
-/* Exported functions --------------------------------------------------------*/
-/** @defgroup USB_LL_Exported_Functions USB Low Layer Exported Functions
+/* Exported functions --------------------------------------------------------*/
-  * @{
+/** @defgroup USB_LL_Exported_Functions USB Low Layer Exported Functions
-  */
+  * @{
+  */
-/** @defgroup USB_LL_Exported_Functions_Group1 Initialization/de-initialization functions
-  *  @brief    Initialization and Configuration functions
+/** @defgroup USB_LL_Exported_Functions_Group1 Initialization/de-initialization functions
-  *
+  *  @brief    Initialization and Configuration functions
-@verbatim
+  *
- ===============================================================================
+@verbatim
-                      ##### Initialization/de-initialization functions #####
+ ===============================================================================
- ===============================================================================
+                      ##### Initialization/de-initialization functions #####
+ ===============================================================================
-@endverbatim
-  * @{
+@endverbatim
-  */
+  * @{
+  */
-/**
-  * @brief  Initializes the USB Core
+/**
-  * @param  USBx USB Instance
+  * @brief  Initializes the USB Core
-  * @param  cfg pointer to a USB_OTG_CfgTypeDef structure that contains
+  * @param  USBx USB Instance
-  *         the configuration information for the specified USBx peripheral.
+  * @param  cfg pointer to a USB_OTG_CfgTypeDef structure that contains
-  * @retval HAL status
+  *         the configuration information for the specified USBx peripheral.
-  */
+  * @retval HAL status
-HAL_StatusTypeDef USB_CoreInit(USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
+  */
-{
+HAL_StatusTypeDef USB_CoreInit(USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
-  HAL_StatusTypeDef ret;
+{
+  HAL_StatusTypeDef ret;
   /* Select FS Embedded PHY */
   USBx->GUSBCFG |= USB_OTG_GUSBCFG_PHYSEL;
   /* Reset after a PHY select */
   ret = USB_CoreReset(USBx);
   /* Activate the USB Transceiver */
   USBx->GCCFG |= USB_OTG_GCCFG_PWRDWN;
   return ret;
 }
 /**
   * @brief  Set the USB turnaround time
   * @param  USBx USB Instance
   * @param  hclk: AHB clock frequency
   * @retval USB turnaround time In PHY Clocks number
   */
 HAL_StatusTypeDef USB_SetTurnaroundTime(USB_OTG_GlobalTypeDef *USBx,
                                         uint32_t hclk, uint8_t speed)
 {
   uint32_t UsbTrd;
   /* The USBTRD is configured according to the tables below, depending on AHB frequency
   used by application. In the low AHB frequency range it is used to stretch enough the USB response
   time to IN tokens, the USB turnaround time, so to compensate for the longer AHB read access
   latency to the Data FIFO */
   if (speed == USBD_FS_SPEED)
   {
     if ((hclk >= 14200000U) && (hclk < 15000000U))
     {
       /* hclk Clock Range between 14.2-15 MHz */
       UsbTrd = 0xFU;
     }
     else if ((hclk >= 15000000U) && (hclk < 16000000U))
     {
       /* hclk Clock Range between 15-16 MHz */
       UsbTrd = 0xEU;
     }
     else if ((hclk >= 16000000U) && (hclk < 17200000U))
     {
       /* hclk Clock Range between 16-17.2 MHz */
       UsbTrd = 0xDU;
     }
     else if ((hclk >= 17200000U) && (hclk < 18500000U))
     {
       /* hclk Clock Range between 17.2-18.5 MHz */
       UsbTrd = 0xCU;
     }
     else if ((hclk >= 18500000U) && (hclk < 20000000U))
     {
       /* hclk Clock Range between 18.5-20 MHz */
       UsbTrd = 0xBU;
     }
     else if ((hclk >= 20000000U) && (hclk < 21800000U))
     {
       /* hclk Clock Range between 20-21.8 MHz */
       UsbTrd = 0xAU;
     }
     else if ((hclk >= 21800000U) && (hclk < 24000000U))
     {
       /* hclk Clock Range between 21.8-24 MHz */
       UsbTrd = 0x9U;
     }
     else if ((hclk >= 24000000U) && (hclk < 27700000U))
     {
       /* hclk Clock Range between 24-27.7 MHz */
       UsbTrd = 0x8U;
     }
     else if ((hclk >= 27700000U) && (hclk < 32000000U))
     {
       /* hclk Clock Range between 27.7-32 MHz */
       UsbTrd = 0x7U;
     }
     else /* if(hclk >= 32000000) */
     {
       /* hclk Clock Range between 32-200 MHz */
       UsbTrd = 0x6U;
     }
   }
   else
   {
     UsbTrd = USBD_DEFAULT_TRDT_VALUE;
   }
   USBx->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;
   USBx->GUSBCFG |= (uint32_t)((UsbTrd << 10) & USB_OTG_GUSBCFG_TRDT);
   return HAL_OK;
 }
 /**
   * @brief  USB_EnableGlobalInt
   *         Enables the controller's Global Int in the AHB Config reg
   * @param  USBx  Selected device
   * @retval HAL status
   */
 HAL_StatusTypeDef USB_EnableGlobalInt(USB_OTG_GlobalTypeDef *USBx)
 {
   USBx->GAHBCFG |= USB_OTG_GAHBCFG_GINT;
   return HAL_OK;
 }
 /**
   * @brief  USB_DisableGlobalInt
   *         Disable the controller's Global Int in the AHB Config reg
   * @param  USBx  Selected device
   * @retval HAL status
   */
 HAL_StatusTypeDef USB_DisableGlobalInt(USB_OTG_GlobalTypeDef *USBx)
 {
   USBx->GAHBCFG &= ~USB_OTG_GAHBCFG_GINT;
   return HAL_OK;
 }
 /**
   * @brief  USB_SetCurrentMode Set functional mode
   * @param  USBx  Selected device
   * @param  mode  current core mode
   *          This parameter can be one of these values:
   *            @arg USB_DEVICE_MODE Peripheral mode
   *            @arg USB_HOST_MODE Host mode
   * @retval HAL status
   */
 HAL_StatusTypeDef USB_SetCurrentMode(USB_OTG_GlobalTypeDef *USBx, USB_ModeTypeDef mode)
 {
   uint32_t ms = 0U;
   USBx->GUSBCFG &= ~(USB_OTG_GUSBCFG_FHMOD | USB_OTG_GUSBCFG_FDMOD);
   if (mode == USB_HOST_MODE)
   {
     USBx->GUSBCFG |= USB_OTG_GUSBCFG_FHMOD;
     do
     {
       HAL_Delay(1U);
       ms++;
     } while ((USB_GetMode(USBx) != (uint32_t)USB_HOST_MODE) && (ms < 50U));
   }
   else if (mode == USB_DEVICE_MODE)
   {
     USBx->GUSBCFG |= USB_OTG_GUSBCFG_FDMOD;
     do
     {
       HAL_Delay(1U);
       ms++;
     } while ((USB_GetMode(USBx) != (uint32_t)USB_DEVICE_MODE) && (ms < 50U));
   }
   else
   {
     return HAL_ERROR;
   }
   if (ms == 50U)
   {
     return HAL_ERROR;
   }
   return HAL_OK;
 }
 /**
   * @brief  USB_DevInit Initializes the USB_OTG controller registers
   *         for device mode
   * @param  USBx  Selected device
   * @param  cfg   pointer to a USB_OTG_CfgTypeDef structure that contains
   *         the configuration information for the specified USBx peripheral.
   * @retval HAL status
   */
 HAL_StatusTypeDef USB_DevInit(USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
 {
   HAL_StatusTypeDef ret = HAL_OK;
   uint32_t USBx_BASE = (uint32_t)USBx;
   uint32_t i;
   for (i = 0U; i < 15U; i++)
   {
     USBx->DIEPTXF[i] = 0U;
   }
   /* Enable HW VBUS sensing */
   USBx->GCCFG |= USB_OTG_GCCFG_VBUSBSEN;
   /* Restart the Phy Clock */
   USBx_PCGCCTL = 0U;
-  /* Device mode configuration */
+  /* Set Core speed to Full speed mode */
-  USBx_DEVICE->DCFG |= DCFG_FRAME_INTERVAL_80;
+  (void)USB_SetDevSpeed(USBx, USB_OTG_SPEED_FULL);
-  /* Set Core speed to Full speed mode */
+  /* Flush the FIFOs */
-  (void)USB_SetDevSpeed(USBx, USB_OTG_SPEED_FULL);
+  if (USB_FlushTxFifo(USBx, 0x10U) != HAL_OK) /* all Tx FIFOs */
+  {
-  /* Flush the FIFOs */
+    ret = HAL_ERROR;
-  if (USB_FlushTxFifo(USBx, 0x10U) != HAL_OK) /* all Tx FIFOs */
+  }
-  {
-    ret = HAL_ERROR;
+  if (USB_FlushRxFifo(USBx) != HAL_OK)
-  }
+  {
+    ret = HAL_ERROR;
-  if (USB_FlushRxFifo(USBx) != HAL_OK)
+  }
-  {
-    ret = HAL_ERROR;
+  /* Clear all pending Device Interrupts */
-  }
+  USBx_DEVICE->DIEPMSK = 0U;
+  USBx_DEVICE->DOEPMSK = 0U;
-  /* Clear all pending Device Interrupts */
+  USBx_DEVICE->DAINTMSK = 0U;
-  USBx_DEVICE->DIEPMSK = 0U;
-  USBx_DEVICE->DOEPMSK = 0U;
+  for (i = 0U; i < cfg.dev_endpoints; i++)
-  USBx_DEVICE->DAINTMSK = 0U;
+  {
+    if ((USBx_INEP(i)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
-  for (i = 0U; i < cfg.dev_endpoints; i++)
+    {
-  {
+      if (i == 0U)
-    if ((USBx_INEP(i)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
+      {
-    {
+        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_SNAK;
-      if (i == 0U)
+      }
-      {
+      else
-        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_SNAK;
+      {
-      }
+        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_EPDIS | USB_OTG_DIEPCTL_SNAK;
-      else
+      }
-      {
+    }
-        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_EPDIS | USB_OTG_DIEPCTL_SNAK;
+    else
-      }
+    {
-    }
+      USBx_INEP(i)->DIEPCTL = 0U;
-    else
+    }
-    {
-      USBx_INEP(i)->DIEPCTL = 0U;
+    USBx_INEP(i)->DIEPTSIZ = 0U;
-    }
+    USBx_INEP(i)->DIEPINT  = 0xFB7FU;
+  }
-    USBx_INEP(i)->DIEPTSIZ = 0U;
-    USBx_INEP(i)->DIEPINT  = 0xFB7FU;
+  for (i = 0U; i < cfg.dev_endpoints; i++)
-  }
+  {
+    if ((USBx_OUTEP(i)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
-  for (i = 0U; i < cfg.dev_endpoints; i++)
+    {
-  {
+      if (i == 0U)
-    if ((USBx_OUTEP(i)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
+      {
-    {
+        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_SNAK;
-      if (i == 0U)
+      }
-      {
+      else
-        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_SNAK;
+      {
-      }
+        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_EPDIS | USB_OTG_DOEPCTL_SNAK;
-      else
+      }
-      {
+    }
-        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_EPDIS | USB_OTG_DOEPCTL_SNAK;
+    else
-      }
+    {
-    }
+      USBx_OUTEP(i)->DOEPCTL = 0U;
-    else
+    }
-    {
-      USBx_OUTEP(i)->DOEPCTL = 0U;
+    USBx_OUTEP(i)->DOEPTSIZ = 0U;
-    }
+    USBx_OUTEP(i)->DOEPINT  = 0xFB7FU;
+  }
-    USBx_OUTEP(i)->DOEPTSIZ = 0U;
-    USBx_OUTEP(i)->DOEPINT  = 0xFB7FU;
+  USBx_DEVICE->DIEPMSK &= ~(USB_OTG_DIEPMSK_TXFURM);
-  }
+  /* Disable all interrupts. */
-  USBx_DEVICE->DIEPMSK &= ~(USB_OTG_DIEPMSK_TXFURM);
+  USBx->GINTMSK = 0U;
-  /* Disable all interrupts. */
+  /* Clear any pending interrupts */
-  USBx->GINTMSK = 0U;
+  USBx->GINTSTS = 0xBFFFFFFFU;
-  /* Clear any pending interrupts */
+  /* Enable the common interrupts */
-  USBx->GINTSTS = 0xBFFFFFFFU;
+  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;
-  /* Enable the common interrupts */
+  /* Enable interrupts matching to the Device mode ONLY */
-  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;
+  USBx->GINTMSK |= USB_OTG_GINTMSK_USBSUSPM | USB_OTG_GINTMSK_USBRST |
+                   USB_OTG_GINTMSK_ENUMDNEM | USB_OTG_GINTMSK_IEPINT |
-  /* Enable interrupts matching to the Device mode ONLY */
+                   USB_OTG_GINTMSK_OEPINT   | USB_OTG_GINTMSK_IISOIXFRM |
-  USBx->GINTMSK |= USB_OTG_GINTMSK_USBSUSPM | USB_OTG_GINTMSK_USBRST |
+                   USB_OTG_GINTMSK_PXFRM_IISOOXFRM | USB_OTG_GINTMSK_WUIM;
-                   USB_OTG_GINTMSK_ENUMDNEM | USB_OTG_GINTMSK_IEPINT |
-                   USB_OTG_GINTMSK_OEPINT   | USB_OTG_GINTMSK_IISOIXFRM |
+  if (cfg.Sof_enable != 0U)
-                   USB_OTG_GINTMSK_PXFRM_IISOOXFRM | USB_OTG_GINTMSK_WUIM;
+  {
+    USBx->GINTMSK |= USB_OTG_GINTMSK_SOFM;
-  if (cfg.Sof_enable != 0U)
+  }
-  {
-    USBx->GINTMSK |= USB_OTG_GINTMSK_SOFM;
+  if (cfg.vbus_sensing_enable == 1U)
-  }
+  {
+    USBx->GINTMSK |= (USB_OTG_GINTMSK_SRQIM | USB_OTG_GINTMSK_OTGINT);
-  if (cfg.vbus_sensing_enable == 1U)
+  }
-  {
-    USBx->GINTMSK |= (USB_OTG_GINTMSK_SRQIM | USB_OTG_GINTMSK_OTGINT);
+  return ret;
-  }
+}
-  return ret;
+/**
-}
+  * @brief  USB_FlushTxFifo Flush a Tx FIFO
+  * @param  USBx  Selected device
-/**
+  * @param  num  FIFO number
-  * @brief  USB_OTG_FlushTxFifo : Flush a Tx FIFO
+  *         This parameter can be a value from 1 to 15
-  * @param  USBx  Selected device
+means Flush all Tx FIFOs
-  * @param  num  FIFO number
+  * @retval HAL status
-  *         This parameter can be a value from 1 to 15
+  */
-means Flush all Tx FIFOs
+HAL_StatusTypeDef USB_FlushTxFifo(USB_OTG_GlobalTypeDef *USBx, uint32_t num)
-  * @retval HAL status
+{
-  */
+  __IO uint32_t count = 0U;
-HAL_StatusTypeDef USB_FlushTxFifo(USB_OTG_GlobalTypeDef *USBx, uint32_t num)
-{
+  /* Wait for AHB master IDLE state. */
-  uint32_t count = 0U;
+  do
+  {
-  USBx->GRSTCTL = (USB_OTG_GRSTCTL_TXFFLSH | (num << 6));
+    count++;
-  do
+    if (count > 200000U)
-  {
+    {
-    if (++count > 200000U)
+      return HAL_TIMEOUT;
-    {
+    }
-      return HAL_TIMEOUT;
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_AHBIDL) == 0U);
-    }
-  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_TXFFLSH) == USB_OTG_GRSTCTL_TXFFLSH);
+  /* Flush TX Fifo */
+  count = 0U;
-  return HAL_OK;
+  USBx->GRSTCTL = (USB_OTG_GRSTCTL_TXFFLSH | (num << 6));
-}
+  do
-/**
+  {
-  * @brief  USB_FlushRxFifo : Flush Rx FIFO
+    count++;
-  * @param  USBx  Selected device
-  * @retval HAL status
+    if (count > 200000U)
-  */
+    {
-HAL_StatusTypeDef USB_FlushRxFifo(USB_OTG_GlobalTypeDef *USBx)
+      return HAL_TIMEOUT;
-{
+    }
-  uint32_t count = 0;
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_TXFFLSH) == USB_OTG_GRSTCTL_TXFFLSH);
-  USBx->GRSTCTL = USB_OTG_GRSTCTL_RXFFLSH;
+  return HAL_OK;
+}
-  do
-  {
+/**
-    if (++count > 200000U)
+  * @brief  USB_FlushRxFifo  Flush Rx FIFO
-    {
+  * @param  USBx  Selected device
-      return HAL_TIMEOUT;
+  * @retval HAL status
-    }
+  */
-  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_RXFFLSH) == USB_OTG_GRSTCTL_RXFFLSH);
+HAL_StatusTypeDef USB_FlushRxFifo(USB_OTG_GlobalTypeDef *USBx)
+{
-  return HAL_OK;
+  __IO uint32_t count = 0U;
-}
+  /* Wait for AHB master IDLE state. */
-/**
+  do
-  * @brief  USB_SetDevSpeed  Initializes the DevSpd field of DCFG register
+  {
-  *         depending the PHY type and the enumeration speed of the device.
+    count++;
-  * @param  USBx  Selected device
-  * @param  speed  device speed
+    if (count > 200000U)
-  *          This parameter can be one of these values:
+    {
-  *            @arg USB_OTG_SPEED_FULL: Full speed mode
+      return HAL_TIMEOUT;
-  * @retval  Hal status
+    }
-  */
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_AHBIDL) == 0U);
-HAL_StatusTypeDef USB_SetDevSpeed(USB_OTG_GlobalTypeDef *USBx, uint8_t speed)
-{
+  /* Flush RX Fifo */
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  count = 0U;
+  USBx->GRSTCTL = USB_OTG_GRSTCTL_RXFFLSH;
-  USBx_DEVICE->DCFG |= speed;
-  return HAL_OK;
+  do
-}
+  {
+    count++;
-/**
-  * @brief  USB_GetDevSpeed  Return the Dev Speed
+    if (count > 200000U)
-  * @param  USBx  Selected device
+    {
-  * @retval speed  device speed
+      return HAL_TIMEOUT;
-  *          This parameter can be one of these values:
+    }
-  *            @arg USBD_FS_SPEED: Full speed mode
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_RXFFLSH) == USB_OTG_GRSTCTL_RXFFLSH);
-  */
-uint8_t USB_GetDevSpeed(USB_OTG_GlobalTypeDef *USBx)
+  return HAL_OK;
-{
+}
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint8_t speed;
+/**
-  uint32_t DevEnumSpeed = USBx_DEVICE->DSTS & USB_OTG_DSTS_ENUMSPD;
+  * @brief  USB_SetDevSpeed  Initializes the DevSpd field of DCFG register
+  *         depending the PHY type and the enumeration speed of the device.
-  if ((DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ) ||
+  * @param  USBx  Selected device
-      (DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_48MHZ))
+  * @param  speed  device speed
-  {
+  *          This parameter can be one of these values:
-    speed = USBD_FS_SPEED;
+  *            @arg USB_OTG_SPEED_FULL: Full speed mode
-  }
+  * @retval  Hal status
-  else
+  */
-  {
+HAL_StatusTypeDef USB_SetDevSpeed(USB_OTG_GlobalTypeDef *USBx, uint8_t speed)
-    speed = 0xFU;
+{
-  }
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  return speed;
+  USBx_DEVICE->DCFG |= speed;
-}
+  return HAL_OK;
+}
-/**
-  * @brief  Activate and configure an endpoint
+/**
-  * @param  USBx  Selected device
+  * @brief  USB_GetDevSpeed  Return the Dev Speed
-  * @param  ep pointer to endpoint structure
+  * @param  USBx  Selected device
-  * @retval HAL status
+  * @retval speed  device speed
-  */
+  *          This parameter can be one of these values:
-HAL_StatusTypeDef USB_ActivateEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+  *            @arg USBD_FS_SPEED: Full speed mode
-{
+  */
-  uint32_t USBx_BASE = (uint32_t)USBx;
+uint8_t USB_GetDevSpeed(USB_OTG_GlobalTypeDef *USBx)
-  uint32_t epnum = (uint32_t)ep->num;
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  if (ep->is_in == 1U)
+  uint8_t speed;
-  {
+  uint32_t DevEnumSpeed = USBx_DEVICE->DSTS & USB_OTG_DSTS_ENUMSPD;
-    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));
+  if ((DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ) ||
-    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_USBAEP) == 0U)
+      (DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_48MHZ))
-    {
+  {
-      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
+    speed = USBD_FS_SPEED;
-                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
+  }
-                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
+  else
-                                   USB_OTG_DIEPCTL_USBAEP;
+  {
-    }
+    speed = 0xFU;
   }
-  else
-  {
+  return speed;
-    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);
+}
-    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
+/**
-    {
+  * @brief  Activate and configure an endpoint
-      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
+  * @param  USBx  Selected device
-                                    ((uint32_t)ep->type << 18) |
+  * @param  ep pointer to endpoint structure
-                                    USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
+  * @retval HAL status
-                                    USB_OTG_DOEPCTL_USBAEP;
+  */
-    }
+HAL_StatusTypeDef USB_ActivateEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-  }
+{
-  return HAL_OK;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-}
+  uint32_t epnum = (uint32_t)ep->num;
-/**
+  if (ep->is_in == 1U)
-  * @brief  Activate and configure a dedicated endpoint
+  {
-  * @param  USBx  Selected device
+    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));
-  * @param  ep pointer to endpoint structure
-  * @retval HAL status
+    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_USBAEP) == 0U)
-  */
+    {
-HAL_StatusTypeDef USB_ActivateDedicatedEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
-{
+                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
-  uint32_t USBx_BASE = (uint32_t)USBx;
+                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
-  uint32_t epnum = (uint32_t)ep->num;
+                                   USB_OTG_DIEPCTL_USBAEP;
+    }
-  /* Read DEPCTLn register */
+  }
-  if (ep->is_in == 1U)
+  else
   {
-    if (((USBx_INEP(epnum)->DIEPCTL) & USB_OTG_DIEPCTL_USBAEP) == 0U)
+    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);
-    {
-      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
+    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
-                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
+    {
-                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
+      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
-                                   USB_OTG_DIEPCTL_USBAEP;
+                                    ((uint32_t)ep->type << 18) |
-    }
+                                    USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
+                                    USB_OTG_DOEPCTL_USBAEP;
-    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));
+    }
   }
-  else
+  return HAL_OK;
-  {
+}
-    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
-    {
+/**
-      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
+  * @brief  Activate and configure a dedicated endpoint
-                                    ((uint32_t)ep->type << 18) | (epnum << 22) |
+  * @param  USBx  Selected device
-                                    USB_OTG_DOEPCTL_USBAEP;
+  * @param  ep pointer to endpoint structure
-    }
+  * @retval HAL status
+  */
-    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);
+HAL_StatusTypeDef USB_ActivateDedicatedEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-  }
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  return HAL_OK;
+  uint32_t epnum = (uint32_t)ep->num;
-}
+  /* Read DEPCTLn register */
-/**
+  if (ep->is_in == 1U)
-  * @brief  De-activate and de-initialize an endpoint
+  {
-  * @param  USBx  Selected device
+    if (((USBx_INEP(epnum)->DIEPCTL) & USB_OTG_DIEPCTL_USBAEP) == 0U)
-  * @param  ep pointer to endpoint structure
+    {
-  * @retval HAL status
+      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
-  */
+                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
-HAL_StatusTypeDef USB_DeactivateEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
-{
+                                   USB_OTG_DIEPCTL_USBAEP;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+    }
-  uint32_t epnum = (uint32_t)ep->num;
+    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));
-  /* Read DEPCTLn register */
+  }
-  if (ep->is_in == 1U)
+  else
   {
-    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
+    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
     {
-      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SNAK;
+      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
-      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_EPDIS;
+                                    ((uint32_t)ep->type << 18) | (epnum << 22) |
-    }
+                                    USB_OTG_DOEPCTL_USBAEP;
+    }
-    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
-    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
+    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);
-    USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_USBAEP |
+  }
-                                   USB_OTG_DIEPCTL_MPSIZ |
-                                   USB_OTG_DIEPCTL_TXFNUM |
+  return HAL_OK;
-                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
+}
-                                   USB_OTG_DIEPCTL_EPTYP);
-  }
+/**
-  else
+  * @brief  De-activate and de-initialize an endpoint
-  {
+  * @param  USBx  Selected device
-    if ((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
+  * @param  ep pointer to endpoint structure
-    {
+  * @retval HAL status
-      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SNAK;
+  */
-      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_EPDIS;
+HAL_StatusTypeDef USB_DeactivateEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-    }
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
+  uint32_t epnum = (uint32_t)ep->num;
-    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
-    USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_USBAEP |
+  /* Read DEPCTLn register */
-                                    USB_OTG_DOEPCTL_MPSIZ |
+  if (ep->is_in == 1U)
-                                    USB_OTG_DOEPCTL_SD0PID_SEVNFRM |
+  {
-                                    USB_OTG_DOEPCTL_EPTYP);
+    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
-  }
+    {
+      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SNAK;
-  return HAL_OK;
+      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_EPDIS;
-}
+    }
-/**
+    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
-  * @brief  De-activate and de-initialize a dedicated endpoint
+    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
-  * @param  USBx  Selected device
+    USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_USBAEP |
-  * @param  ep pointer to endpoint structure
+                                   USB_OTG_DIEPCTL_MPSIZ |
-  * @retval HAL status
+                                   USB_OTG_DIEPCTL_TXFNUM |
-  */
+                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
-HAL_StatusTypeDef USB_DeactivateDedicatedEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+                                   USB_OTG_DIEPCTL_EPTYP);
-{
+  }
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  else
-  uint32_t epnum = (uint32_t)ep->num;
+  {
+    if ((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
-  /* Read DEPCTLn register */
+    {
-  if (ep->is_in == 1U)
+      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SNAK;
-  {
+      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_EPDIS;
-    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
+    }
-    {
-      USBx_INEP(epnum)->DIEPCTL  |= USB_OTG_DIEPCTL_SNAK;
+    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
-      USBx_INEP(epnum)->DIEPCTL  |= USB_OTG_DIEPCTL_EPDIS;
+    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
-    }
+    USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_USBAEP |
+                                    USB_OTG_DOEPCTL_MPSIZ |
-    USBx_INEP(epnum)->DIEPCTL &= ~ USB_OTG_DIEPCTL_USBAEP;
+                                    USB_OTG_DOEPCTL_SD0PID_SEVNFRM |
-    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
+                                    USB_OTG_DOEPCTL_EPTYP);
   }
-  else
-  {
+  return HAL_OK;
-    if ((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
+}
-    {
-      USBx_OUTEP(epnum)->DOEPCTL  |= USB_OTG_DOEPCTL_SNAK;
+/**
-      USBx_OUTEP(epnum)->DOEPCTL  |= USB_OTG_DOEPCTL_EPDIS;
+  * @brief  De-activate and de-initialize a dedicated endpoint
-    }
+  * @param  USBx  Selected device
+  * @param  ep pointer to endpoint structure
-    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_USBAEP;
+  * @retval HAL status
-    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
+  */
-  }
+HAL_StatusTypeDef USB_DeactivateDedicatedEndpoint(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+{
-  return HAL_OK;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-}
+  uint32_t epnum = (uint32_t)ep->num;
-/**
+  /* Read DEPCTLn register */
-  * @brief  USB_EPStartXfer : setup and starts a transfer over an EP
+  if (ep->is_in == 1U)
-  * @param  USBx  Selected device
+  {
-  * @param  ep pointer to endpoint structure
+    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
-  * @retval HAL status
+    {
-  */
+      USBx_INEP(epnum)->DIEPCTL  |= USB_OTG_DIEPCTL_SNAK;
-HAL_StatusTypeDef USB_EPStartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+      USBx_INEP(epnum)->DIEPCTL  |= USB_OTG_DIEPCTL_EPDIS;
-{
+    }
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t epnum = (uint32_t)ep->num;
+    USBx_INEP(epnum)->DIEPCTL &= ~ USB_OTG_DIEPCTL_USBAEP;
-  uint16_t pktcnt;
+    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
+  }
-  /* IN endpoint */
+  else
-  if (ep->is_in == 1U)
+  {
-  {
+    if ((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
-    /* Zero Length Packet? */
+    {
-    if (ep->xfer_len == 0U)
+      USBx_OUTEP(epnum)->DOEPCTL  |= USB_OTG_DOEPCTL_SNAK;
-    {
+      USBx_OUTEP(epnum)->DOEPCTL  |= USB_OTG_DOEPCTL_EPDIS;
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
+    }
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
+    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_USBAEP;
-    }
+    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
-    else
+  }
-    {
-      /* Program the transfer size and packet count
+  return HAL_OK;
-      * as follows: xfersize = N * maxpacket +
+}
-      * short_packet pktcnt = N + (short_packet
-      * exist ? 1 : 0)
+/**
-      */
+  * @brief  USB_EPStartXfer : setup and starts a transfer over an EP
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
+  * @param  USBx  Selected device
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
+  * @param  ep pointer to endpoint structure
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT &
+  * @retval HAL status
-                                     (((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket) << 19));
+  */
+HAL_StatusTypeDef USB_EPStartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_XFRSIZ & ep->xfer_len);
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-      if (ep->type == EP_TYPE_ISOC)
+  uint32_t epnum = (uint32_t)ep->num;
-      {
+  uint16_t pktcnt;
-        USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_MULCNT);
-        USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_MULCNT & (1U << 29));
+  /* IN endpoint */
-      }
+  if (ep->is_in == 1U)
-    }
+  {
-    /* EP enable, IN data in FIFO */
+    /* Zero Length Packet? */
-    USBx_INEP(epnum)->DIEPCTL |= (USB_OTG_DIEPCTL_CNAK | USB_OTG_DIEPCTL_EPENA);
+    if (ep->xfer_len == 0U)
+    {
-    if (ep->type != EP_TYPE_ISOC)
+      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
-    {
+      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
-      /* Enable the Tx FIFO Empty Interrupt for this EP */
+      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
-      if (ep->xfer_len > 0U)
+    }
-      {
+    else
-        USBx_DEVICE->DIEPEMPMSK |= 1UL << (ep->num & EP_ADDR_MSK);
+    {
-      }
+      /* Program the transfer size and packet count
-    }
+      * as follows: xfersize = N * maxpacket +
-    else
+      * short_packet pktcnt = N + (short_packet
-    {
+      * exist ? 1 : 0)
-      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
+      */
-      {
+      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
-        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SODDFRM;
+      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
-      }
-      else
+      if (epnum == 0U)
       {
-        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM;
+        if (ep->xfer_len > ep->maxpacket)
-      }
+        {
+          ep->xfer_len = ep->maxpacket;
-      (void)USB_WritePacket(USBx, ep->xfer_buff, ep->num, (uint16_t)ep->xfer_len);
+        }
-    }
-  }
+        USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
-  else /* OUT endpoint */
+      }
-  {
+      else
-    /* Program the transfer size and packet count as follows:
+      {
-    * pktcnt = N
+        USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT &
-    * xfersize = N * maxpacket
+                                       (((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket) << 19));
-    */
+      }
-    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
-    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);
+      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_XFRSIZ & ep->xfer_len);
-    if (ep->xfer_len == 0U)
+      if (ep->type == EP_TYPE_ISOC)
-    {
+      {
-      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & ep->maxpacket);
+        USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_MULCNT);
-      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
+        USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_MULCNT & (1U << 29));
-    }
+      }
-    else
+    }
-    {
+    /* EP enable, IN data in FIFO */
-      pktcnt = (uint16_t)((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket);
+    USBx_INEP(epnum)->DIEPCTL |= (USB_OTG_DIEPCTL_CNAK | USB_OTG_DIEPCTL_EPENA);
-      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_PKTCNT & ((uint32_t)pktcnt << 19);
-      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_XFRSIZ & (ep->maxpacket * pktcnt);
+    if (ep->type != EP_TYPE_ISOC)
-    }
+    {
+      /* Enable the Tx FIFO Empty Interrupt for this EP */
-    if (ep->type == EP_TYPE_ISOC)
+      if (ep->xfer_len > 0U)
-    {
+      {
-      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
+        USBx_DEVICE->DIEPEMPMSK |= 1UL << (ep->num & EP_ADDR_MSK);
-      {
+      }
-        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SODDFRM;
+    }
-      }
+    else
-      else
+    {
-      {
+      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
-        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM;
+      {
-      }
+        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SODDFRM;
-    }
+      }
-    /* EP enable */
+      else
-    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
+      {
-  }
+        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM;
+      }
-  return HAL_OK;
-}
+      (void)USB_WritePacket(USBx, ep->xfer_buff, ep->num, (uint16_t)ep->xfer_len);
+    }
-/**
+  }
-  * @brief  USB_EP0StartXfer : setup and starts a transfer over the EP  0
+  else /* OUT endpoint */
-  * @param  USBx  Selected device
+  {
-  * @param  ep pointer to endpoint structure
+    /* Program the transfer size and packet count as follows:
-  * @retval HAL status
+    * pktcnt = N
-  */
+    * xfersize = N * maxpacket
-HAL_StatusTypeDef USB_EP0StartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+    */
-{
+    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
-  uint32_t USBx_BASE = (uint32_t)USBx;
+    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);
-  uint32_t epnum = (uint32_t)ep->num;
+    if (epnum == 0U)
-  /* IN endpoint */
+    {
-  if (ep->is_in == 1U)
+      if (ep->xfer_len > 0U)
-  {
+      {
-    /* Zero Length Packet? */
+        ep->xfer_len = ep->maxpacket;
-    if (ep->xfer_len == 0U)
+      }
-    {
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
+      /* Store transfer size, for EP0 this is equal to endpoint max packet size */
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
+      ep->xfer_size = ep->maxpacket;
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
-    }
+      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & ep->xfer_size);
-    else
+      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
-    {
+    }
-      /* Program the transfer size and packet count
+    else
-      * as follows: xfersize = N * maxpacket +
+    {
-      * short_packet pktcnt = N + (short_packet
+      if (ep->xfer_len == 0U)
-      * exist ? 1 : 0)
+      {
-      */
+        USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & ep->maxpacket);
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
+        USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
-      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
+      }
+      else
-      if (ep->xfer_len > ep->maxpacket)
+      {
-      {
+        pktcnt = (uint16_t)((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket);
-        ep->xfer_len = ep->maxpacket;
+        ep->xfer_size = ep->maxpacket * pktcnt;
-      }
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
+        USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_PKTCNT & ((uint32_t)pktcnt << 19);
-      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_XFRSIZ & ep->xfer_len);
+        USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_XFRSIZ & ep->xfer_size;
-    }
+      }
+    }
-    /* EP enable, IN data in FIFO */
-    USBx_INEP(epnum)->DIEPCTL |= (USB_OTG_DIEPCTL_CNAK | USB_OTG_DIEPCTL_EPENA);
+    if (ep->type == EP_TYPE_ISOC)
+    {
-    /* Enable the Tx FIFO Empty Interrupt for this EP */
+      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
-    if (ep->xfer_len > 0U)
+      {
-    {
+        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SODDFRM;
-      USBx_DEVICE->DIEPEMPMSK |= 1UL << (ep->num & EP_ADDR_MSK);
+      }
-    }
+      else
-  }
+      {
-  else /* OUT endpoint */
+        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM;
-  {
+      }
-    /* Program the transfer size and packet count as follows:
+    }
-    * pktcnt = N
+    /* EP enable */
-    * xfersize = N * maxpacket
+    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
-    */
+  }
-    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
-    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);
+  return HAL_OK;
+}
-    if (ep->xfer_len > 0U)
-    {
-      ep->xfer_len = ep->maxpacket;
+/**
-    }
+   * @brief  USB_EPStoptXfer  Stop transfer on an EP
+   * @param  USBx  usb device instance
-    USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
+   * @param  ep pointer to endpoint structure
-    USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & (ep->maxpacket));
+   * @retval HAL status
+   */
-    /* EP enable */
+HAL_StatusTypeDef USB_EPStopXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
+{
-  }
+  __IO uint32_t count = 0U;
+  HAL_StatusTypeDef ret = HAL_OK;
-  return HAL_OK;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-}
+  /* IN endpoint */
-/**
+  if (ep->is_in == 1U)
-  * @brief  USB_WritePacket : Writes a packet into the Tx FIFO associated
+  {
-  *         with the EP/channel
+    /* EP enable, IN data in FIFO */
-  * @param  USBx  Selected device
+    if (((USBx_INEP(ep->num)->DIEPCTL) & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
-  * @param  src   pointer to source buffer
+    {
-  * @param  ch_ep_num  endpoint or host channel number
+      USBx_INEP(ep->num)->DIEPCTL |= (USB_OTG_DIEPCTL_SNAK);
-  * @param  len  Number of bytes to write
+      USBx_INEP(ep->num)->DIEPCTL |= (USB_OTG_DIEPCTL_EPDIS);
-  * @retval HAL status
-  */
+      do
-HAL_StatusTypeDef USB_WritePacket(USB_OTG_GlobalTypeDef *USBx, uint8_t *src,
+      {
-                                  uint8_t ch_ep_num, uint16_t len)
+        count++;
-{
-  uint32_t USBx_BASE = (uint32_t)USBx;
+        if (count > 10000U)
-  uint8_t *pSrc = src;
+        {
-  uint32_t count32b;
+          ret = HAL_ERROR;
-  uint32_t i;
+          break;
+        }
-  count32b = ((uint32_t)len + 3U) / 4U;
+      } while (((USBx_INEP(ep->num)->DIEPCTL) & USB_OTG_DIEPCTL_EPENA) ==  USB_OTG_DIEPCTL_EPENA);
-  for (i = 0U; i < count32b; i++)
+    }
-  {
+  }
-    USBx_DFIFO((uint32_t)ch_ep_num) = __UNALIGNED_UINT32_READ(pSrc);
+  else /* OUT endpoint */
-    pSrc++;
+  {
-    pSrc++;
+    if (((USBx_OUTEP(ep->num)->DOEPCTL) & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
-    pSrc++;
+    {
-    pSrc++;
+      USBx_OUTEP(ep->num)->DOEPCTL |= (USB_OTG_DOEPCTL_SNAK);
-  }
+      USBx_OUTEP(ep->num)->DOEPCTL |= (USB_OTG_DOEPCTL_EPDIS);
-  return HAL_OK;
+      do
-}
+      {
+        count++;
-/**
-  * @brief  USB_ReadPacket : read a packet from the RX FIFO
+        if (count > 10000U)
-  * @param  USBx  Selected device
+        {
-  * @param  dest  source pointer
+          ret = HAL_ERROR;
-  * @param  len  Number of bytes to read
+          break;
-  * @retval pointer to destination buffer
+        }
-  */
+      } while (((USBx_OUTEP(ep->num)->DOEPCTL) & USB_OTG_DOEPCTL_EPENA) ==  USB_OTG_DOEPCTL_EPENA);
-void *USB_ReadPacket(USB_OTG_GlobalTypeDef *USBx, uint8_t *dest, uint16_t len)
+    }
-{
+  }
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint8_t *pDest = dest;
+  return ret;
-  uint32_t pData;
+}
-  uint32_t i;
-  uint32_t count32b = (uint32_t)len >> 2U;
-  uint16_t remaining_bytes = len % 4U;
+/**
+  * @brief  USB_WritePacket : Writes a packet into the Tx FIFO associated
-  for (i = 0U; i < count32b; i++)
+  *         with the EP/channel
-  {
+  * @param  USBx  Selected device
-    __UNALIGNED_UINT32_WRITE(pDest, USBx_DFIFO(0U));
+  * @param  src   pointer to source buffer
-    pDest++;
+  * @param  ch_ep_num  endpoint or host channel number
-    pDest++;
+  * @param  len  Number of bytes to write
-    pDest++;
+  * @retval HAL status
-    pDest++;
+  */
-  }
+HAL_StatusTypeDef USB_WritePacket(USB_OTG_GlobalTypeDef *USBx, uint8_t *src,
+                                  uint8_t ch_ep_num, uint16_t len)
-  /* When Number of data is not word aligned, read the remaining byte */
+{
-  if (remaining_bytes != 0U)
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  {
+  uint8_t *pSrc = src;
-    i = 0U;
+  uint32_t count32b;
-    __UNALIGNED_UINT32_WRITE(&pData, USBx_DFIFO(0U));
+  uint32_t i;
-    do
+  count32b = ((uint32_t)len + 3U) / 4U;
-    {
+  for (i = 0U; i < count32b; i++)
-      *(uint8_t *)pDest = (uint8_t)(pData >> (8U * (uint8_t)(i)));
+  {
-      i++;
+    USBx_DFIFO((uint32_t)ch_ep_num) = __UNALIGNED_UINT32_READ(pSrc);
-      pDest++;
+    pSrc++;
-      remaining_bytes--;
+    pSrc++;
-    } while (remaining_bytes != 0U);
+    pSrc++;
-  }
+    pSrc++;
+  }
-  return ((void *)pDest);
-}
+  return HAL_OK;
+}
-/**
-  * @brief  USB_EPSetStall : set a stall condition over an EP
+/**
-  * @param  USBx  Selected device
+  * @brief  USB_ReadPacket : read a packet from the RX FIFO
-  * @param  ep pointer to endpoint structure
+  * @param  USBx  Selected device
-  * @retval HAL status
+  * @param  dest  source pointer
-  */
+  * @param  len  Number of bytes to read
-HAL_StatusTypeDef USB_EPSetStall(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+  * @retval pointer to destination buffer
-{
+  */
-  uint32_t USBx_BASE = (uint32_t)USBx;
+void *USB_ReadPacket(USB_OTG_GlobalTypeDef *USBx, uint8_t *dest, uint16_t len)
-  uint32_t epnum = (uint32_t)ep->num;
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  if (ep->is_in == 1U)
+  uint8_t *pDest = dest;
-  {
+  uint32_t pData;
-    if (((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == 0U) && (epnum != 0U))
+  uint32_t i;
-    {
+  uint32_t count32b = (uint32_t)len >> 2U;
-      USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_EPDIS);
+  uint16_t remaining_bytes = len % 4U;
-    }
-    USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_STALL;
+  for (i = 0U; i < count32b; i++)
-  }
+  {
-  else
+    __UNALIGNED_UINT32_WRITE(pDest, USBx_DFIFO(0U));
-  {
+    pDest++;
-    if (((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == 0U) && (epnum != 0U))
+    pDest++;
-    {
+    pDest++;
-      USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_EPDIS);
+    pDest++;
-    }
+  }
-    USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_STALL;
-  }
+  /* When Number of data is not word aligned, read the remaining byte */
+  if (remaining_bytes != 0U)
-  return HAL_OK;
+  {
-}
+    i = 0U;
+    __UNALIGNED_UINT32_WRITE(&pData, USBx_DFIFO(0U));
-/**
-  * @brief  USB_EPClearStall : Clear a stall condition over an EP
+    do
-  * @param  USBx  Selected device
+    {
-  * @param  ep pointer to endpoint structure
+      *(uint8_t *)pDest = (uint8_t)(pData >> (8U * (uint8_t)(i)));
-  * @retval HAL status
+      i++;
-  */
+      pDest++;
-HAL_StatusTypeDef USB_EPClearStall(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
+      remaining_bytes--;
-{
+    } while (remaining_bytes != 0U);
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  }
-  uint32_t epnum = (uint32_t)ep->num;
+  return ((void *)pDest);
-  if (ep->is_in == 1U)
+}
-  {
-    USBx_INEP(epnum)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
+/**
-    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
+  * @brief  USB_EPSetStall : set a stall condition over an EP
-    {
+  * @param  USBx  Selected device
-      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM; /* DATA0 */
+  * @param  ep pointer to endpoint structure
-    }
+  * @retval HAL status
-  }
+  */
-  else
+HAL_StatusTypeDef USB_EPSetStall(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-  {
+{
-    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
+  uint32_t epnum = (uint32_t)ep->num;
-    {
-      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM; /* DATA0 */
+  if (ep->is_in == 1U)
-    }
+  {
-  }
+    if (((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == 0U) && (epnum != 0U))
-  return HAL_OK;
+    {
-}
+      USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_EPDIS);
+    }
-/**
+    USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_STALL;
-  * @brief  USB_StopDevice : Stop the usb device mode
+  }
-  * @param  USBx  Selected device
+  else
-  * @retval HAL status
+  {
-  */
+    if (((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == 0U) && (epnum != 0U))
-HAL_StatusTypeDef USB_StopDevice(USB_OTG_GlobalTypeDef *USBx)
+    {
-{
+      USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_EPDIS);
-  HAL_StatusTypeDef ret;
+    }
-  uint32_t USBx_BASE = (uint32_t)USBx;
+    USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_STALL;
-  uint32_t i;
+  }
-  /* Clear Pending interrupt */
+  return HAL_OK;
-  for (i = 0U; i < 15U; i++)
+}
-  {
-    USBx_INEP(i)->DIEPINT = 0xFB7FU;
+/**
-    USBx_OUTEP(i)->DOEPINT = 0xFB7FU;
+  * @brief  USB_EPClearStall : Clear a stall condition over an EP
-  }
+  * @param  USBx  Selected device
+  * @param  ep pointer to endpoint structure
-  /* Clear interrupt masks */
+  * @retval HAL status
-  USBx_DEVICE->DIEPMSK  = 0U;
+  */
-  USBx_DEVICE->DOEPMSK  = 0U;
+HAL_StatusTypeDef USB_EPClearStall(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
-  USBx_DEVICE->DAINTMSK = 0U;
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  /* Flush the FIFO */
+  uint32_t epnum = (uint32_t)ep->num;
-  ret = USB_FlushRxFifo(USBx);
-  if (ret != HAL_OK)
+  if (ep->is_in == 1U)
   {
-    return ret;
+    USBx_INEP(epnum)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
-  }
+    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
+    {
-  ret = USB_FlushTxFifo(USBx,  0x10U);
+      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM; /* DATA0 */
-  if (ret != HAL_OK)
+    }
-  {
+  }
-    return ret;
+  else
-  }
+  {
+    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
-  return ret;
+    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
-}
+    {
+      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM; /* DATA0 */
-/**
+    }
-  * @brief  USB_SetDevAddress : Stop the usb device mode
+  }
-  * @param  USBx  Selected device
+  return HAL_OK;
-  * @param  address  new device address to be assigned
+}
-  *          This parameter can be a value from 0 to 255
-  * @retval HAL status
+/**
-  */
+  * @brief  USB_StopDevice : Stop the usb device mode
-HAL_StatusTypeDef  USB_SetDevAddress(USB_OTG_GlobalTypeDef *USBx, uint8_t address)
+  * @param  USBx  Selected device
-{
+  * @retval HAL status
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  */
+HAL_StatusTypeDef USB_StopDevice(USB_OTG_GlobalTypeDef *USBx)
-  USBx_DEVICE->DCFG &= ~(USB_OTG_DCFG_DAD);
+{
-  USBx_DEVICE->DCFG |= ((uint32_t)address << 4) & USB_OTG_DCFG_DAD;
+  HAL_StatusTypeDef ret;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  return HAL_OK;
+  uint32_t i;
-}
+  /* Clear Pending interrupt */
-/**
+  for (i = 0U; i < 15U; i++)
-  * @brief  USB_DevConnect : Connect the USB device by enabling Rpu
+  {
-  * @param  USBx  Selected device
+    USBx_INEP(i)->DIEPINT = 0xFB7FU;
-  * @retval HAL status
+    USBx_OUTEP(i)->DOEPINT = 0xFB7FU;
-  */
+  }
-HAL_StatusTypeDef  USB_DevConnect(USB_OTG_GlobalTypeDef *USBx)
-{
+  /* Clear interrupt masks */
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  USBx_DEVICE->DIEPMSK  = 0U;
+  USBx_DEVICE->DOEPMSK  = 0U;
-  /* In case phy is stopped, ensure to ungate and restore the phy CLK */
+  USBx_DEVICE->DAINTMSK = 0U;
-  USBx_PCGCCTL &= ~(USB_OTG_PCGCCTL_STOPCLK | USB_OTG_PCGCCTL_GATECLK);
+  /* Flush the FIFO */
-  USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_SDIS;
+  ret = USB_FlushRxFifo(USBx);
+  if (ret != HAL_OK)
-  return HAL_OK;
+  {
-}
+    return ret;
+  }
-/**
-  * @brief  USB_DevDisconnect : Disconnect the USB device by disabling Rpu
+  ret = USB_FlushTxFifo(USBx,  0x10U);
-  * @param  USBx  Selected device
+  if (ret != HAL_OK)
-  * @retval HAL status
+  {
-  */
+    return ret;
-HAL_StatusTypeDef  USB_DevDisconnect(USB_OTG_GlobalTypeDef *USBx)
+  }
-{
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  return ret;
+}
-  /* In case phy is stopped, ensure to ungate and restore the phy CLK */
-  USBx_PCGCCTL &= ~(USB_OTG_PCGCCTL_STOPCLK | USB_OTG_PCGCCTL_GATECLK);
+/**
+  * @brief  USB_SetDevAddress : Stop the usb device mode
-  USBx_DEVICE->DCTL |= USB_OTG_DCTL_SDIS;
+  * @param  USBx  Selected device
+  * @param  address  new device address to be assigned
-  return HAL_OK;
+  *          This parameter can be a value from 0 to 255
-}
+  * @retval HAL status
+  */
-/**
+HAL_StatusTypeDef USB_SetDevAddress(USB_OTG_GlobalTypeDef *USBx, uint8_t address)
-  * @brief  USB_ReadInterrupts: return the global USB interrupt status
+{
-  * @param  USBx  Selected device
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  * @retval HAL status
-  */
+  USBx_DEVICE->DCFG &= ~(USB_OTG_DCFG_DAD);
-uint32_t  USB_ReadInterrupts(USB_OTG_GlobalTypeDef *USBx)
+  USBx_DEVICE->DCFG |= ((uint32_t)address << 4) & USB_OTG_DCFG_DAD;
-{
-  uint32_t tmpreg;
+  return HAL_OK;
+}
-  tmpreg = USBx->GINTSTS;
-  tmpreg &= USBx->GINTMSK;
+/**
+  * @brief  USB_DevConnect : Connect the USB device by enabling Rpu
-  return tmpreg;
+  * @param  USBx  Selected device
-}
+  * @retval HAL status
+  */
-/**
+HAL_StatusTypeDef USB_DevConnect(USB_OTG_GlobalTypeDef *USBx)
-  * @brief  USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status
+{
-  * @param  USBx  Selected device
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  * @retval HAL status
-  */
+  /* In case phy is stopped, ensure to ungate and restore the phy CLK */
-uint32_t USB_ReadDevAllOutEpInterrupt(USB_OTG_GlobalTypeDef *USBx)
+  USBx_PCGCCTL &= ~(USB_OTG_PCGCCTL_STOPCLK | USB_OTG_PCGCCTL_GATECLK);
-{
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_SDIS;
-  uint32_t tmpreg;
+  return HAL_OK;
-  tmpreg  = USBx_DEVICE->DAINT;
+}
-  tmpreg &= USBx_DEVICE->DAINTMSK;
+/**
-  return ((tmpreg & 0xffff0000U) >> 16);
+  * @brief  USB_DevDisconnect : Disconnect the USB device by disabling Rpu
-}
+  * @param  USBx  Selected device
+  * @retval HAL status
-/**
+  */
-  * @brief  USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status
+HAL_StatusTypeDef USB_DevDisconnect(USB_OTG_GlobalTypeDef *USBx)
-  * @param  USBx  Selected device
+{
-  * @retval HAL status
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  */
-uint32_t USB_ReadDevAllInEpInterrupt(USB_OTG_GlobalTypeDef *USBx)
+  /* In case phy is stopped, ensure to ungate and restore the phy CLK */
-{
+  USBx_PCGCCTL &= ~(USB_OTG_PCGCCTL_STOPCLK | USB_OTG_PCGCCTL_GATECLK);
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t tmpreg;
+  USBx_DEVICE->DCTL |= USB_OTG_DCTL_SDIS;
-  tmpreg  = USBx_DEVICE->DAINT;
+  return HAL_OK;
-  tmpreg &= USBx_DEVICE->DAINTMSK;
+}
-  return ((tmpreg & 0xFFFFU));
+/**
-}
+  * @brief  USB_ReadInterrupts: return the global USB interrupt status
+  * @param  USBx  Selected device
-/**
+  * @retval USB Global Interrupt status
-  * @brief  Returns Device OUT EP Interrupt register
+  */
-  * @param  USBx  Selected device
+uint32_t USB_ReadInterrupts(USB_OTG_GlobalTypeDef const *USBx)
-  * @param  epnum  endpoint number
+{
-  *          This parameter can be a value from 0 to 15
+  uint32_t tmpreg;
-  * @retval Device OUT EP Interrupt register
-  */
+  tmpreg = USBx->GINTSTS;
-uint32_t USB_ReadDevOutEPInterrupt(USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
+  tmpreg &= USBx->GINTMSK;
-{
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  return tmpreg;
-  uint32_t tmpreg;
+}
-  tmpreg  = USBx_OUTEP((uint32_t)epnum)->DOEPINT;
+/**
-  tmpreg &= USBx_DEVICE->DOEPMSK;
+  * @brief  USB_ReadChInterrupts: return USB channel interrupt status
+  * @param  USBx  Selected device
-  return tmpreg;
+  * @param  chnum Channel number
-}
+  * @retval USB Channel Interrupt status
+  */
-/**
+uint32_t USB_ReadChInterrupts(USB_OTG_GlobalTypeDef *USBx, uint8_t chnum)
-  * @brief  Returns Device IN EP Interrupt register
+{
-  * @param  USBx  Selected device
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  * @param  epnum  endpoint number
+  uint32_t tmpreg;
-  *          This parameter can be a value from 0 to 15
-  * @retval Device IN EP Interrupt register
+  tmpreg = USBx_HC(chnum)->HCINT;
-  */
+  tmpreg &= USBx_HC(chnum)->HCINTMSK;
-uint32_t USB_ReadDevInEPInterrupt(USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
-{
+  return tmpreg;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+}
-  uint32_t tmpreg;
-  uint32_t msk;
+/**
-  uint32_t emp;
+  * @brief  USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status
+  * @param  USBx  Selected device
-  msk = USBx_DEVICE->DIEPMSK;
+  * @retval USB Device OUT EP interrupt status
-  emp = USBx_DEVICE->DIEPEMPMSK;
+  */
-  msk |= ((emp >> (epnum & EP_ADDR_MSK)) & 0x1U) << 7;
+uint32_t USB_ReadDevAllOutEpInterrupt(USB_OTG_GlobalTypeDef *USBx)
-  tmpreg = USBx_INEP((uint32_t)epnum)->DIEPINT & msk;
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  return tmpreg;
+  uint32_t tmpreg;
-}
+  tmpreg  = USBx_DEVICE->DAINT;
-/**
+  tmpreg &= USBx_DEVICE->DAINTMSK;
-  * @brief  USB_ClearInterrupts: clear a USB interrupt
-  * @param  USBx  Selected device
+  return ((tmpreg & 0xffff0000U) >> 16);
-  * @param  interrupt  flag
+}
-  * @retval None
-  */
+/**
-void  USB_ClearInterrupts(USB_OTG_GlobalTypeDef *USBx, uint32_t interrupt)
+  * @brief  USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status
-{
+  * @param  USBx  Selected device
-  USBx->GINTSTS |= interrupt;
+  * @retval USB Device IN EP interrupt status
-}
+  */
+uint32_t USB_ReadDevAllInEpInterrupt(USB_OTG_GlobalTypeDef *USBx)
-/**
+{
-  * @brief  Returns USB core mode
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  * @param  USBx  Selected device
+  uint32_t tmpreg;
-  * @retval return core mode : Host or Device
-  *          This parameter can be one of these values:
+  tmpreg  = USBx_DEVICE->DAINT;
-  *           0 : Host
+  tmpreg &= USBx_DEVICE->DAINTMSK;
-  *           1 : Device
-  */
+  return ((tmpreg & 0xFFFFU));
-uint32_t USB_GetMode(USB_OTG_GlobalTypeDef *USBx)
+}
-{
-  return ((USBx->GINTSTS) & 0x1U);
+/**
-}
+  * @brief  Returns Device OUT EP Interrupt register
+  * @param  USBx  Selected device
-/**
+  * @param  epnum  endpoint number
-  * @brief  Activate EP0 for Setup transactions
+  *          This parameter can be a value from 0 to 15
-  * @param  USBx  Selected device
+  * @retval Device OUT EP Interrupt register
-  * @retval HAL status
+  */
-  */
+uint32_t USB_ReadDevOutEPInterrupt(USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
-HAL_StatusTypeDef  USB_ActivateSetup(USB_OTG_GlobalTypeDef *USBx)
+{
-{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  uint32_t tmpreg;
-  /* Set the MPS of the IN EP0 to 64 bytes */
+  tmpreg  = USBx_OUTEP((uint32_t)epnum)->DOEPINT;
-  USBx_INEP(0U)->DIEPCTL &= ~USB_OTG_DIEPCTL_MPSIZ;
+  tmpreg &= USBx_DEVICE->DOEPMSK;
-  USBx_DEVICE->DCTL |= USB_OTG_DCTL_CGINAK;
+  return tmpreg;
+}
-  return HAL_OK;
-}
+/**
+  * @brief  Returns Device IN EP Interrupt register
-/**
+  * @param  USBx  Selected device
-  * @brief  Prepare the EP0 to start the first control setup
+  * @param  epnum  endpoint number
-  * @param  USBx  Selected device
+  *          This parameter can be a value from 0 to 15
-  * @param  psetup  pointer to setup packet
+  * @retval Device IN EP Interrupt register
-  * @retval HAL status
+  */
-  */
+uint32_t USB_ReadDevInEPInterrupt(USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
-HAL_StatusTypeDef USB_EP0_OutStart(USB_OTG_GlobalTypeDef *USBx, uint8_t *psetup)
+{
-{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  uint32_t tmpreg;
-  uint32_t gSNPSiD = *(__IO uint32_t *)(&USBx->CID + 0x1U);
+  uint32_t msk;
-  UNUSED(psetup);
+  uint32_t emp;
-  if (gSNPSiD > USB_OTG_CORE_ID_300A)
+  msk = USBx_DEVICE->DIEPMSK;
-  {
+  emp = USBx_DEVICE->DIEPEMPMSK;
-    if ((USBx_OUTEP(0U)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
+  msk |= ((emp >> (epnum & EP_ADDR_MSK)) & 0x1U) << 7;
-    {
+  tmpreg = USBx_INEP((uint32_t)epnum)->DIEPINT & msk;
-      return HAL_OK;
-    }
+  return tmpreg;
-  }
+}
-  USBx_OUTEP(0U)->DOEPTSIZ = 0U;
+/**
-  USBx_OUTEP(0U)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
+  * @brief  USB_ClearInterrupts: clear a USB interrupt
-  USBx_OUTEP(0U)->DOEPTSIZ |= (3U * 8U);
+  * @param  USBx  Selected device
-  USBx_OUTEP(0U)->DOEPTSIZ |=  USB_OTG_DOEPTSIZ_STUPCNT;
+  * @param  interrupt  flag
+  * @retval None
-  return HAL_OK;
+  */
-}
+void  USB_ClearInterrupts(USB_OTG_GlobalTypeDef *USBx, uint32_t interrupt)
+{
-/**
+  USBx->GINTSTS &= interrupt;
-  * @brief  Reset the USB Core (needed after USB clock settings change)
+}
-  * @param  USBx  Selected device
-  * @retval HAL status
+/**
-  */
+  * @brief  Returns USB core mode
-static HAL_StatusTypeDef USB_CoreReset(USB_OTG_GlobalTypeDef *USBx)
+  * @param  USBx  Selected device
-{
+  * @retval return core mode : Host or Device
-  uint32_t count = 0U;
+  *          This parameter can be one of these values:
+  *           0 : Host
-  /* Wait for AHB master IDLE state. */
+  *           1 : Device
-  do
+  */
-  {
+uint32_t USB_GetMode(USB_OTG_GlobalTypeDef *USBx)
-    if (++count > 200000U)
+{
-    {
+  return ((USBx->GINTSTS) & 0x1U);
-      return HAL_TIMEOUT;
+}
-    }
-  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_AHBIDL) == 0U);
+/**
+  * @brief  Activate EP0 for Setup transactions
-  /* Core Soft Reset */
+  * @param  USBx  Selected device
-  count = 0U;
+  * @retval HAL status
-  USBx->GRSTCTL |= USB_OTG_GRSTCTL_CSRST;
+  */
+HAL_StatusTypeDef USB_ActivateSetup(USB_OTG_GlobalTypeDef *USBx)
-  do
+{
-  {
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    if (++count > 200000U)
-    {
+  /* Set the MPS of the IN EP0 to 64 bytes */
-      return HAL_TIMEOUT;
+  USBx_INEP(0U)->DIEPCTL &= ~USB_OTG_DIEPCTL_MPSIZ;
-    }
-  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_CSRST) == USB_OTG_GRSTCTL_CSRST);
+  USBx_DEVICE->DCTL |= USB_OTG_DCTL_CGINAK;
   return HAL_OK;
 }
 /**
-  * @brief  USB_HostInit : Initializes the USB OTG controller registers
+  * @brief  Prepare the EP0 to start the first control setup
-  *         for Host mode
+  * @param  USBx  Selected device
-  * @param  USBx  Selected device
+  * @param  psetup  pointer to setup packet
-  * @param  cfg   pointer to a USB_OTG_CfgTypeDef structure that contains
+  * @retval HAL status
-  *         the configuration information for the specified USBx peripheral.
+  */
-  * @retval HAL status
+HAL_StatusTypeDef USB_EP0_OutStart(USB_OTG_GlobalTypeDef *USBx, uint8_t *psetup)
-  */
+{
-HAL_StatusTypeDef USB_HostInit(USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
+  uint32_t USBx_BASE = (uint32_t)USBx;
-{
+  uint32_t gSNPSiD = *(__IO uint32_t *)(&USBx->CID + 0x1U);
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  UNUSED(psetup);
-  uint32_t i;
+  if (gSNPSiD > USB_OTG_CORE_ID_300A)
-  /* Restart the Phy Clock */
+  {
-  USBx_PCGCCTL = 0U;
+    if ((USBx_OUTEP(0U)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
+    {
-  /* Disable VBUS sensing */
+      return HAL_OK;
-  USBx->GCCFG &= ~(USB_OTG_GCCFG_VBUSASEN);
+    }
-  USBx->GCCFG &= ~(USB_OTG_GCCFG_VBUSBSEN);
+  }
-  /* Set default Max speed support */
-  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSS);
+  USBx_OUTEP(0U)->DOEPTSIZ = 0U;
+  USBx_OUTEP(0U)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
-  /* Make sure the FIFOs are flushed. */
+  USBx_OUTEP(0U)->DOEPTSIZ |= (3U * 8U);
-  (void)USB_FlushTxFifo(USBx, 0x10U); /* all Tx FIFOs */
+  USBx_OUTEP(0U)->DOEPTSIZ |=  USB_OTG_DOEPTSIZ_STUPCNT;
-  (void)USB_FlushRxFifo(USBx);
+  return HAL_OK;
-  /* Clear all pending HC Interrupts */
+}
-  for (i = 0U; i < cfg.Host_channels; i++)
-  {
+/**
-    USBx_HC(i)->HCINT = 0xFFFFFFFFU;
+  * @brief  Reset the USB Core (needed after USB clock settings change)
-    USBx_HC(i)->HCINTMSK = 0U;
+  * @param  USBx  Selected device
-  }
+  * @retval HAL status
+  */
-  /* Disable all interrupts. */
+static HAL_StatusTypeDef USB_CoreReset(USB_OTG_GlobalTypeDef *USBx)
-  USBx->GINTMSK = 0U;
+{
+  __IO uint32_t count = 0U;
-  /* Clear any pending interrupts */
-  USBx->GINTSTS = 0xFFFFFFFFU;
+  /* Wait for AHB master IDLE state. */
+  do
-  /* set Rx FIFO size */
+  {
-  USBx->GRXFSIZ  = 0x80U;
+    count++;
-  USBx->DIEPTXF0_HNPTXFSIZ = (uint32_t)(((0x60U << 16) & USB_OTG_NPTXFD) | 0x80U);
-  USBx->HPTXFSIZ = (uint32_t)(((0x40U << 16)& USB_OTG_HPTXFSIZ_PTXFD) | 0xE0U);
+    if (count > 200000U)
-  /* Enable the common interrupts */
+    {
-  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;
+      return HAL_TIMEOUT;
+    }
-  /* Enable interrupts matching to the Host mode ONLY */
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_AHBIDL) == 0U);
-  USBx->GINTMSK |= (USB_OTG_GINTMSK_PRTIM            | USB_OTG_GINTMSK_HCIM | \
-                    USB_OTG_GINTMSK_SOFM             | USB_OTG_GINTSTS_DISCINT | \
+  /* Core Soft Reset */
-                    USB_OTG_GINTMSK_PXFRM_IISOOXFRM  | USB_OTG_GINTMSK_WUIM);
+  count = 0U;
+  USBx->GRSTCTL |= USB_OTG_GRSTCTL_CSRST;
-  return HAL_OK;
-}
+  do
+  {
-/**
+    count++;
-  * @brief  USB_InitFSLSPClkSel : Initializes the FSLSPClkSel field of the
-  *         HCFG register on the PHY type and set the right frame interval
+    if (count > 200000U)
-  * @param  USBx  Selected device
+    {
-  * @param  freq  clock frequency
+      return HAL_TIMEOUT;
-  *          This parameter can be one of these values:
+    }
-  *           HCFG_48_MHZ : Full Speed 48 MHz Clock
+  } while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_CSRST) == USB_OTG_GRSTCTL_CSRST);
-  *           HCFG_6_MHZ : Low Speed 6 MHz Clock
-  * @retval HAL status
+  return HAL_OK;
-  */
+}
-HAL_StatusTypeDef USB_InitFSLSPClkSel(USB_OTG_GlobalTypeDef *USBx, uint8_t freq)
-{
+/**
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  * @brief  USB_HostInit : Initializes the USB OTG controller registers
+  *         for Host mode
-  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSPCS);
+  * @param  USBx  Selected device
-  USBx_HOST->HCFG |= (uint32_t)freq & USB_OTG_HCFG_FSLSPCS;
+  * @param  cfg   pointer to a USB_OTG_CfgTypeDef structure that contains
+  *         the configuration information for the specified USBx peripheral.
-  if (freq == HCFG_48_MHZ)
+  * @retval HAL status
-  {
+  */
-    USBx_HOST->HFIR = 48000U;
+HAL_StatusTypeDef USB_HostInit(USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
-  }
+{
-  else if (freq == HCFG_6_MHZ)
+  HAL_StatusTypeDef ret = HAL_OK;
-  {
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    USBx_HOST->HFIR = 6000U;
+  uint32_t i;
-  }
-  else
+  /* Restart the Phy Clock */
-  {
+  USBx_PCGCCTL = 0U;
-    /* ... */
-  }
+  /* Disable VBUS sensing */
+  USBx->GCCFG &= ~(USB_OTG_GCCFG_VBUSASEN);
-  return HAL_OK;
+  USBx->GCCFG &= ~(USB_OTG_GCCFG_VBUSBSEN);
-}
+  /* Set default Max speed support */
+  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSS);
-/**
-  * @brief  USB_OTG_ResetPort : Reset Host Port
+  /* Make sure the FIFOs are flushed. */
-  * @param  USBx  Selected device
+  if (USB_FlushTxFifo(USBx, 0x10U) != HAL_OK) /* all Tx FIFOs */
-  * @retval HAL status
+  {
-  * @note (1)The application must wait at least 10 ms
+    ret = HAL_ERROR;
-  *   before clearing the reset bit.
+  }
-  */
-HAL_StatusTypeDef USB_ResetPort(USB_OTG_GlobalTypeDef *USBx)
+  if (USB_FlushRxFifo(USBx) != HAL_OK)
-{
+  {
-  uint32_t USBx_BASE = (uint32_t)USBx;
+    ret = HAL_ERROR;
+  }
-  __IO uint32_t hprt0 = 0U;
+  /* Clear all pending HC Interrupts */
-  hprt0 = USBx_HPRT0;
+  for (i = 0U; i < cfg.Host_channels; i++)
+  {
-  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
+    USBx_HC(i)->HCINT = CLEAR_INTERRUPT_MASK;
-             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
+    USBx_HC(i)->HCINTMSK = 0U;
+  }
-  USBx_HPRT0 = (USB_OTG_HPRT_PRST | hprt0);
-  HAL_Delay(100U);                                 /* See Note #1 */
+  /* Disable all interrupts. */
-  USBx_HPRT0 = ((~USB_OTG_HPRT_PRST) & hprt0);
+  USBx->GINTMSK = 0U;
-  HAL_Delay(10U);
+  /* Clear any pending interrupts */
-  return HAL_OK;
+  USBx->GINTSTS = CLEAR_INTERRUPT_MASK;
-}
+  /* set Rx FIFO size */
-/**
+  USBx->GRXFSIZ  = 0x80U;
-  * @brief  USB_DriveVbus : activate or de-activate vbus
+  USBx->DIEPTXF0_HNPTXFSIZ = (uint32_t)(((0x60U << 16) & USB_OTG_NPTXFD) | 0x80U);
-  * @param  state  VBUS state
+  USBx->HPTXFSIZ = (uint32_t)(((0x40U << 16)& USB_OTG_HPTXFSIZ_PTXFD) | 0xE0U);
-  *          This parameter can be one of these values:
+  /* Enable the common interrupts */
-  *           0 : Deactivate VBUS
+  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;
-  *           1 : Activate VBUS
-  * @retval HAL status
+  /* Enable interrupts matching to the Host mode ONLY */
-  */
+  USBx->GINTMSK |= (USB_OTG_GINTMSK_PRTIM            | USB_OTG_GINTMSK_HCIM | \
-HAL_StatusTypeDef USB_DriveVbus(USB_OTG_GlobalTypeDef *USBx, uint8_t state)
+                    USB_OTG_GINTMSK_SOFM             | USB_OTG_GINTSTS_DISCINT | \
-{
+                    USB_OTG_GINTMSK_PXFRM_IISOOXFRM  | USB_OTG_GINTMSK_WUIM);
-  uint32_t USBx_BASE = (uint32_t)USBx;
-  __IO uint32_t hprt0 = 0U;
+  return ret;
+}
-  hprt0 = USBx_HPRT0;
+/**
-  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
+  * @brief  USB_InitFSLSPClkSel : Initializes the FSLSPClkSel field of the
-             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
+  *         HCFG register on the PHY type and set the right frame interval
+  * @param  USBx  Selected device
-  if (((hprt0 & USB_OTG_HPRT_PPWR) == 0U) && (state == 1U))
+  * @param  freq  clock frequency
-  {
+  *          This parameter can be one of these values:
-    USBx_HPRT0 = (USB_OTG_HPRT_PPWR | hprt0);
+  *           HCFG_48_MHZ : Full Speed 48 MHz Clock
-  }
+  *           HCFG_6_MHZ : Low Speed 6 MHz Clock
-  if (((hprt0 & USB_OTG_HPRT_PPWR) == USB_OTG_HPRT_PPWR) && (state == 0U))
+  * @retval HAL status
-  {
+  */
-    USBx_HPRT0 = ((~USB_OTG_HPRT_PPWR) & hprt0);
+HAL_StatusTypeDef USB_InitFSLSPClkSel(USB_OTG_GlobalTypeDef *USBx, uint8_t freq)
-  }
+{
-  return HAL_OK;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-}
+  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSPCS);
-/**
+  USBx_HOST->HCFG |= (uint32_t)freq & USB_OTG_HCFG_FSLSPCS;
-  * @brief  Return Host Core speed
-  * @param  USBx  Selected device
+  if (freq == HCFG_48_MHZ)
-  * @retval speed : Host speed
+  {
-  *          This parameter can be one of these values:
+    USBx_HOST->HFIR = HFIR_48_MHZ;
-  *            @arg HCD_SPEED_FULL: Full speed mode
+  }
-  *            @arg HCD_SPEED_LOW: Low speed mode
+  else if (freq == HCFG_6_MHZ)
-  */
+  {
-uint32_t USB_GetHostSpeed(USB_OTG_GlobalTypeDef *USBx)
+    USBx_HOST->HFIR = HFIR_6_MHZ;
-{
+  }
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  else
-  __IO uint32_t hprt0 = 0U;
+  {
+    return HAL_ERROR;
-  hprt0 = USBx_HPRT0;
+  }
-  return ((hprt0 & USB_OTG_HPRT_PSPD) >> 17);
-}
+  return HAL_OK;
+}
-/**
-  * @brief  Return Host Current Frame number
+/**
-  * @param  USBx  Selected device
+  * @brief  USB_OTG_ResetPort : Reset Host Port
-  * @retval current frame number
+  * @param  USBx  Selected device
-  */
+  * @retval HAL status
-uint32_t USB_GetCurrentFrame(USB_OTG_GlobalTypeDef *USBx)
+  * @note (1)The application must wait at least 10 ms
-{
+  *   before clearing the reset bit.
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  */
+HAL_StatusTypeDef USB_ResetPort(USB_OTG_GlobalTypeDef *USBx)
-  return (USBx_HOST->HFNUM & USB_OTG_HFNUM_FRNUM);
+{
-}
+  uint32_t USBx_BASE = (uint32_t)USBx;
-/**
+  __IO uint32_t hprt0 = 0U;
-  * @brief  Initialize a host channel
-  * @param  USBx  Selected device
+  hprt0 = USBx_HPRT0;
-  * @param  ch_num  Channel number
-  *         This parameter can be a value from 1 to 15
+  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
-  * @param  epnum  Endpoint number
+             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
-  *          This parameter can be a value from 1 to 15
-  * @param  dev_address  Current device address
+  USBx_HPRT0 = (USB_OTG_HPRT_PRST | hprt0);
-  *          This parameter can be a value from 0 to 255
+  HAL_Delay(100U);                                 /* See Note #1 */
-  * @param  speed  Current device speed
+  USBx_HPRT0 = ((~USB_OTG_HPRT_PRST) & hprt0);
-  *          This parameter can be one of these values:
+  HAL_Delay(10U);
-  *            @arg USB_OTG_SPEED_FULL: Full speed mode
-  *            @arg USB_OTG_SPEED_LOW: Low speed mode
+  return HAL_OK;
-  * @param  ep_type  Endpoint Type
+}
-  *          This parameter can be one of these values:
-  *            @arg EP_TYPE_CTRL: Control type
+/**
-  *            @arg EP_TYPE_ISOC: Isochronous type
+  * @brief  USB_DriveVbus : activate or de-activate vbus
-  *            @arg EP_TYPE_BULK: Bulk type
+  * @param  state  VBUS state
-  *            @arg EP_TYPE_INTR: Interrupt type
+  *          This parameter can be one of these values:
-  * @param  mps  Max Packet Size
+  *           0 : Deactivate VBUS
-  *          This parameter can be a value from 0 to 32K
+  *           1 : Activate VBUS
-  * @retval HAL state
+  * @retval HAL status
   */
-HAL_StatusTypeDef USB_HC_Init(USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num,
+HAL_StatusTypeDef USB_DriveVbus(USB_OTG_GlobalTypeDef *USBx, uint8_t state)
-                              uint8_t epnum, uint8_t dev_address, uint8_t speed,
+{
-                              uint8_t ep_type, uint16_t mps)
+  uint32_t USBx_BASE = (uint32_t)USBx;
-{
+  __IO uint32_t hprt0 = 0U;
-  HAL_StatusTypeDef ret = HAL_OK;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  hprt0 = USBx_HPRT0;
-  uint32_t HCcharEpDir;
-  uint32_t HCcharLowSpeed;
+  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
-  uint32_t HostCoreSpeed;
+             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);
-  /* Clear old interrupt conditions for this host channel. */
+  if (((hprt0 & USB_OTG_HPRT_PPWR) == 0U) && (state == 1U))
-  USBx_HC((uint32_t)ch_num)->HCINT = 0xFFFFFFFFU;
+  {
+    USBx_HPRT0 = (USB_OTG_HPRT_PPWR | hprt0);
-  /* Enable channel interrupts required for this transfer. */
+  }
-  switch (ep_type)
+  if (((hprt0 & USB_OTG_HPRT_PPWR) == USB_OTG_HPRT_PPWR) && (state == 0U))
   {
-    case EP_TYPE_CTRL:
+    USBx_HPRT0 = ((~USB_OTG_HPRT_PPWR) & hprt0);
-    case EP_TYPE_BULK:
+  }
-      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
+  return HAL_OK;
-                                            USB_OTG_HCINTMSK_STALLM |
+}
-                                            USB_OTG_HCINTMSK_TXERRM |
-                                            USB_OTG_HCINTMSK_DTERRM |
+/**
-                                            USB_OTG_HCINTMSK_AHBERR |
+  * @brief  Return Host Core speed
-                                            USB_OTG_HCINTMSK_NAKM;
+  * @param  USBx  Selected device
+  * @retval speed : Host speed
-      if ((epnum & 0x80U) == 0x80U)
+  *          This parameter can be one of these values:
-      {
+  *            @arg HCD_SPEED_FULL: Full speed mode
-        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
+  *            @arg HCD_SPEED_LOW: Low speed mode
-      }
+  */
-      break;
+uint32_t USB_GetHostSpeed(USB_OTG_GlobalTypeDef const *USBx)
+{
-    case EP_TYPE_INTR:
+  uint32_t USBx_BASE = (uint32_t)USBx;
-      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
+  __IO uint32_t hprt0 = 0U;
-                                            USB_OTG_HCINTMSK_STALLM |
-                                            USB_OTG_HCINTMSK_TXERRM |
+  hprt0 = USBx_HPRT0;
-                                            USB_OTG_HCINTMSK_DTERRM |
+  return ((hprt0 & USB_OTG_HPRT_PSPD) >> 17);
-                                            USB_OTG_HCINTMSK_NAKM   |
+}
-                                            USB_OTG_HCINTMSK_AHBERR |
-                                            USB_OTG_HCINTMSK_FRMORM;
+/**
+  * @brief  Return Host Current Frame number
-      if ((epnum & 0x80U) == 0x80U)
+  * @param  USBx  Selected device
-      {
+  * @retval current frame number
-        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
+  */
-      }
+uint32_t USB_GetCurrentFrame(USB_OTG_GlobalTypeDef const *USBx)
+{
-      break;
+  uint32_t USBx_BASE = (uint32_t)USBx;
-    case EP_TYPE_ISOC:
+  return (USBx_HOST->HFNUM & USB_OTG_HFNUM_FRNUM);
-      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
+}
-                                            USB_OTG_HCINTMSK_ACKM   |
-                                            USB_OTG_HCINTMSK_AHBERR |
+/**
-                                            USB_OTG_HCINTMSK_FRMORM;
+  * @brief  Initialize a host channel
+  * @param  USBx  Selected device
-      if ((epnum & 0x80U) == 0x80U)
+  * @param  ch_num  Channel number
-      {
+  *         This parameter can be a value from 1 to 15
-        USBx_HC((uint32_t)ch_num)->HCINTMSK |= (USB_OTG_HCINTMSK_TXERRM | USB_OTG_HCINTMSK_BBERRM);
+  * @param  epnum  Endpoint number
-      }
+  *          This parameter can be a value from 1 to 15
-      break;
+  * @param  dev_address  Current device address
+  *          This parameter can be a value from 0 to 255
-    default:
+  * @param  speed  Current device speed
-      ret = HAL_ERROR;
+  *          This parameter can be one of these values:
-      break;
+  *            @arg USB_OTG_SPEED_FULL: Full speed mode
-  }
+  *            @arg USB_OTG_SPEED_LOW: Low speed mode
+  * @param  ep_type  Endpoint Type
-  /* Enable the top level host channel interrupt. */
+  *          This parameter can be one of these values:
-  USBx_HOST->HAINTMSK |= 1UL << (ch_num & 0xFU);
+  *            @arg EP_TYPE_CTRL: Control type
+  *            @arg EP_TYPE_ISOC: Isochronous type
-  /* Make sure host channel interrupts are enabled. */
+  *            @arg EP_TYPE_BULK: Bulk type
-  USBx->GINTMSK |= USB_OTG_GINTMSK_HCIM;
+  *            @arg EP_TYPE_INTR: Interrupt type
+  * @param  mps  Max Packet Size
-  /* Program the HCCHAR register */
+  *          This parameter can be a value from 0 to 32K
-  if ((epnum & 0x80U) == 0x80U)
+  * @retval HAL state
-  {
+  */
-    HCcharEpDir = (0x1U << 15) & USB_OTG_HCCHAR_EPDIR;
+HAL_StatusTypeDef USB_HC_Init(USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num,
-  }
+                              uint8_t epnum, uint8_t dev_address, uint8_t speed,
-  else
+                              uint8_t ep_type, uint16_t mps)
-  {
+{
-    HCcharEpDir = 0U;
+  HAL_StatusTypeDef ret = HAL_OK;
-  }
+  uint32_t USBx_BASE = (uint32_t)USBx;
+  uint32_t HCcharEpDir;
-  HostCoreSpeed = USB_GetHostSpeed(USBx);
+  uint32_t HCcharLowSpeed;
+  uint32_t HostCoreSpeed;
-  /* LS device plugged to HUB */
-  if ((speed == HPRT0_PRTSPD_LOW_SPEED) && (HostCoreSpeed != HPRT0_PRTSPD_LOW_SPEED))
+  /* Clear old interrupt conditions for this host channel. */
-  {
+  USBx_HC((uint32_t)ch_num)->HCINT = CLEAR_INTERRUPT_MASK;
-    HCcharLowSpeed = (0x1U << 17) & USB_OTG_HCCHAR_LSDEV;
-  }
+  /* Enable channel interrupts required for this transfer. */
-  else
+  switch (ep_type)
   {
-    HCcharLowSpeed = 0U;
+    case EP_TYPE_CTRL:
-  }
+    case EP_TYPE_BULK:
+      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
-  USBx_HC((uint32_t)ch_num)->HCCHAR = (((uint32_t)dev_address << 22) & USB_OTG_HCCHAR_DAD) |
+                                            USB_OTG_HCINTMSK_STALLM |
-                                      ((((uint32_t)epnum & 0x7FU) << 11) & USB_OTG_HCCHAR_EPNUM) |
+                                            USB_OTG_HCINTMSK_TXERRM |
-                                      (((uint32_t)ep_type << 18) & USB_OTG_HCCHAR_EPTYP) |
+                                            USB_OTG_HCINTMSK_DTERRM |
-                                      ((uint32_t)mps & USB_OTG_HCCHAR_MPSIZ) | HCcharEpDir | HCcharLowSpeed;
+                                            USB_OTG_HCINTMSK_AHBERR |
+                                            USB_OTG_HCINTMSK_NAKM;
-  if (ep_type == EP_TYPE_INTR)
-  {
+      if ((epnum & 0x80U) == 0x80U)
-    USBx_HC((uint32_t)ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM ;
+      {
-  }
+        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
+      }
-  return ret;
+      break;
-}
+    case EP_TYPE_INTR:
-/**
+      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
-  * @brief  Start a transfer over a host channel
+                                            USB_OTG_HCINTMSK_STALLM |
-  * @param  USBx  Selected device
+                                            USB_OTG_HCINTMSK_TXERRM |
-  * @param  hc  pointer to host channel structure
+                                            USB_OTG_HCINTMSK_DTERRM |
-  * @retval HAL state
+                                            USB_OTG_HCINTMSK_NAKM   |
-  */
+                                            USB_OTG_HCINTMSK_AHBERR |
-HAL_StatusTypeDef USB_HC_StartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_HCTypeDef *hc)
+                                            USB_OTG_HCINTMSK_FRMORM;
-{
-  uint32_t USBx_BASE = (uint32_t)USBx;
+      if ((epnum & 0x80U) == 0x80U)
-  uint32_t ch_num = (uint32_t)hc->ch_num;
+      {
-  __IO uint32_t tmpreg;
+        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
-  uint8_t  is_oddframe;
+      }
-  uint16_t len_words;
-  uint16_t num_packets;
+      break;
-  uint16_t max_hc_pkt_count = 256U;
+    case EP_TYPE_ISOC:
-  /* Compute the expected number of packets associated to the transfer */
+      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
-  if (hc->xfer_len > 0U)
+                                            USB_OTG_HCINTMSK_ACKM   |
-  {
+                                            USB_OTG_HCINTMSK_AHBERR |
-    num_packets = (uint16_t)((hc->xfer_len + hc->max_packet - 1U) / hc->max_packet);
+                                            USB_OTG_HCINTMSK_FRMORM;
-    if (num_packets > max_hc_pkt_count)
+      if ((epnum & 0x80U) == 0x80U)
-    {
+      {
-      num_packets = max_hc_pkt_count;
+        USBx_HC((uint32_t)ch_num)->HCINTMSK |= (USB_OTG_HCINTMSK_TXERRM | USB_OTG_HCINTMSK_BBERRM);
-      hc->XferSize = (uint32_t)num_packets * hc->max_packet;
+      }
-    }
+      break;
-  }
-  else
+    default:
-  {
+      ret = HAL_ERROR;
-    num_packets = 1U;
+      break;
   }
-  /*
+  /* Enable host channel Halt interrupt */
-   * For IN channel HCTSIZ.XferSize is expected to be an integer multiple of
+  USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_CHHM;
-   * max_packet size.
-   */
+  /* Enable the top level host channel interrupt. */
-  if (hc->ep_is_in != 0U)
+  USBx_HOST->HAINTMSK |= 1UL << (ch_num & 0xFU);
-  {
-    hc->XferSize = (uint32_t)num_packets * hc->max_packet;
+  /* Make sure host channel interrupts are enabled. */
-  }
+  USBx->GINTMSK |= USB_OTG_GINTMSK_HCIM;
-  else
-  {
+  /* Program the HCCHAR register */
-    hc->XferSize = hc->xfer_len;
+  if ((epnum & 0x80U) == 0x80U)
-  }
+  {
+    HCcharEpDir = (0x1U << 15) & USB_OTG_HCCHAR_EPDIR;
-  /* Initialize the HCTSIZn register */
+  }
-  USBx_HC(ch_num)->HCTSIZ = (hc->XferSize & USB_OTG_HCTSIZ_XFRSIZ) |
+  else
-                            (((uint32_t)num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
+  {
-                            (((uint32_t)hc->data_pid << 29) & USB_OTG_HCTSIZ_DPID);
+    HCcharEpDir = 0U;
+  }
-  is_oddframe = (((uint32_t)USBx_HOST->HFNUM & 0x01U) != 0U) ? 0U : 1U;
-  USBx_HC(ch_num)->HCCHAR &= ~USB_OTG_HCCHAR_ODDFRM;
+  HostCoreSpeed = USB_GetHostSpeed(USBx);
-  USBx_HC(ch_num)->HCCHAR |= (uint32_t)is_oddframe << 29;
+  /* LS device plugged to HUB */
-  /* Set host channel enable */
+  if ((speed == HPRT0_PRTSPD_LOW_SPEED) && (HostCoreSpeed != HPRT0_PRTSPD_LOW_SPEED))
-  tmpreg = USBx_HC(ch_num)->HCCHAR;
+  {
-  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+    HCcharLowSpeed = (0x1U << 17) & USB_OTG_HCCHAR_LSDEV;
+  }
-  /* make sure to set the correct ep direction */
+  else
-  if (hc->ep_is_in != 0U)
+  {
-  {
+    HCcharLowSpeed = 0U;
-    tmpreg |= USB_OTG_HCCHAR_EPDIR;
+  }
-  }
-  else
+  USBx_HC((uint32_t)ch_num)->HCCHAR = (((uint32_t)dev_address << 22) & USB_OTG_HCCHAR_DAD) |
-  {
+                                      ((((uint32_t)epnum & 0x7FU) << 11) & USB_OTG_HCCHAR_EPNUM) |
-    tmpreg &= ~USB_OTG_HCCHAR_EPDIR;
+                                      (((uint32_t)ep_type << 18) & USB_OTG_HCCHAR_EPTYP) |
-  }
+                                      ((uint32_t)mps & USB_OTG_HCCHAR_MPSIZ) |
-  tmpreg |= USB_OTG_HCCHAR_CHENA;
+                                      USB_OTG_HCCHAR_MC_0 | HCcharEpDir | HCcharLowSpeed;
-  USBx_HC(ch_num)->HCCHAR = tmpreg;
+  if ((ep_type == EP_TYPE_INTR) || (ep_type == EP_TYPE_ISOC))
-  if ((hc->ep_is_in == 0U) && (hc->xfer_len > 0U))
+  {
-  {
+    USBx_HC((uint32_t)ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
-    switch (hc->ep_type)
+  }
-    {
-      /* Non periodic transfer */
+  return ret;
-      case EP_TYPE_CTRL:
+}
-      case EP_TYPE_BULK:
+/**
-        len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);
+  * @brief  Start a transfer over a host channel
+  * @param  USBx  Selected device
-        /* check if there is enough space in FIFO space */
+  * @param  hc  pointer to host channel structure
-        if (len_words > (USBx->HNPTXSTS & 0xFFFFU))
+  * @retval HAL state
-        {
+  */
-          /* need to process data in nptxfempty interrupt */
+HAL_StatusTypeDef USB_HC_StartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_HCTypeDef *hc)
-          USBx->GINTMSK |= USB_OTG_GINTMSK_NPTXFEM;
+{
-        }
+  uint32_t USBx_BASE = (uint32_t)USBx;
-        break;
+  uint32_t ch_num = (uint32_t)hc->ch_num;
+  __IO uint32_t tmpreg;
-      /* Periodic transfer */
+  uint8_t  is_oddframe;
-      case EP_TYPE_INTR:
+  uint16_t len_words;
-      case EP_TYPE_ISOC:
+  uint16_t num_packets;
-        len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);
+  uint16_t max_hc_pkt_count = HC_MAX_PKT_CNT;
-        /* check if there is enough space in FIFO space */
-        if (len_words > (USBx_HOST->HPTXSTS & 0xFFFFU)) /* split the transfer */
+  /* Compute the expected number of packets associated to the transfer */
-        {
+  if (hc->xfer_len > 0U)
-          /* need to process data in ptxfempty interrupt */
+  {
-          USBx->GINTMSK |= USB_OTG_GINTMSK_PTXFEM;
+    num_packets = (uint16_t)((hc->xfer_len + hc->max_packet - 1U) / hc->max_packet);
-        }
-        break;
+    if (num_packets > max_hc_pkt_count)
+    {
-      default:
+      num_packets = max_hc_pkt_count;
-        break;
+      hc->XferSize = (uint32_t)num_packets * hc->max_packet;
     }
+  }
-    /* Write packet into the Tx FIFO. */
+  else
-    (void)USB_WritePacket(USBx, hc->xfer_buff, hc->ch_num, (uint16_t)hc->xfer_len);
+  {
-  }
+    num_packets = 1U;
+  }
-  return HAL_OK;
-}
+  /*
+   * For IN channel HCTSIZ.XferSize is expected to be an integer multiple of
-/**
+   * max_packet size.
-  * @brief Read all host channel interrupts status
+   */
-  * @param  USBx  Selected device
+  if (hc->ep_is_in != 0U)
-  * @retval HAL state
+  {
-  */
+    hc->XferSize = (uint32_t)num_packets * hc->max_packet;
-uint32_t USB_HC_ReadInterrupt(USB_OTG_GlobalTypeDef *USBx)
+  }
-{
+  else
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  {
+    hc->XferSize = hc->xfer_len;
-  return ((USBx_HOST->HAINT) & 0xFFFFU);
+  }
-}
+  /* Initialize the HCTSIZn register */
-/**
+  USBx_HC(ch_num)->HCTSIZ = (hc->XferSize & USB_OTG_HCTSIZ_XFRSIZ) |
-  * @brief  Halt a host channel
+                            (((uint32_t)num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
-  * @param  USBx  Selected device
+                            (((uint32_t)hc->data_pid << 29) & USB_OTG_HCTSIZ_DPID);
-  * @param  hc_num  Host Channel number
-  *         This parameter can be a value from 1 to 15
+  is_oddframe = (((uint32_t)USBx_HOST->HFNUM & 0x01U) != 0U) ? 0U : 1U;
-  * @retval HAL state
+  USBx_HC(ch_num)->HCCHAR &= ~USB_OTG_HCCHAR_ODDFRM;
-  */
+  USBx_HC(ch_num)->HCCHAR |= (uint32_t)is_oddframe << 29;
-HAL_StatusTypeDef USB_HC_Halt(USB_OTG_GlobalTypeDef *USBx, uint8_t hc_num)
-{
+  /* Set host channel enable */
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  tmpreg = USBx_HC(ch_num)->HCCHAR;
-  uint32_t hcnum = (uint32_t)hc_num;
+  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
-  uint32_t count = 0U;
-  uint32_t HcEpType = (USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
+  /* make sure to set the correct ep direction */
-  uint32_t ChannelEna = (USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) >> 31;
+  if (hc->ep_is_in != 0U)
+  {
-  if (((USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN) == USB_OTG_GAHBCFG_DMAEN) &&
+    tmpreg |= USB_OTG_HCCHAR_EPDIR;
-      (ChannelEna == 0U))
+  }
-  {
+  else
-    return HAL_OK;
+  {
-  }
+    tmpreg &= ~USB_OTG_HCCHAR_EPDIR;
+  }
-  /* Check for space in the request queue to issue the halt. */
+  tmpreg |= USB_OTG_HCCHAR_CHENA;
-  if ((HcEpType == HCCHAR_CTRL) || (HcEpType == HCCHAR_BULK))
+  USBx_HC(ch_num)->HCCHAR = tmpreg;
-  {
-    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;
+  if ((hc->ep_is_in == 0U) && (hc->xfer_len > 0U))
+  {
-    if ((USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN) == 0U)
+    switch (hc->ep_type)
     {
-      if ((USBx->HNPTXSTS & (0xFFU << 16)) == 0U)
+      /* Non periodic transfer */
-      {
+      case EP_TYPE_CTRL:
-        USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
+      case EP_TYPE_BULK:
-        USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-        USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_EPDIR;
+        len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);
-        do
-        {
+        /* check if there is enough space in FIFO space */
-          if (++count > 1000U)
+        if (len_words > (USBx->HNPTXSTS & 0xFFFFU))
-          {
+        {
-            break;
+          /* need to process data in nptxfempty interrupt */
-          }
+          USBx->GINTMSK |= USB_OTG_GINTMSK_NPTXFEM;
-        } while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
+        }
-      }
+        break;
-      else
-      {
+      /* Periodic transfer */
-        USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
+      case EP_TYPE_INTR:
-      }
+      case EP_TYPE_ISOC:
-    }
+        len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);
-  }
+        /* check if there is enough space in FIFO space */
-  else
+        if (len_words > (USBx_HOST->HPTXSTS & 0xFFFFU)) /* split the transfer */
-  {
+        {
-    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;
+          /* need to process data in ptxfempty interrupt */
+          USBx->GINTMSK |= USB_OTG_GINTMSK_PTXFEM;
-    if ((USBx_HOST->HPTXSTS & (0xFFU << 16)) == 0U)
+        }
-    {
+        break;
-      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
-      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
+      default:
-      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_EPDIR;
+        break;
-      do
+    }
-      {
-        if (++count > 1000U)
+    /* Write packet into the Tx FIFO. */
-        {
+    (void)USB_WritePacket(USBx, hc->xfer_buff, hc->ch_num, (uint16_t)hc->xfer_len);
-          break;
+  }
-        }
-      } while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
+  return HAL_OK;
-    }
+}
-    else
-    {
+/**
-      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
+  * @brief Read all host channel interrupts status
-    }
+  * @param  USBx  Selected device
-  }
+  * @retval HAL state
+  */
-  return HAL_OK;
+uint32_t USB_HC_ReadInterrupt(USB_OTG_GlobalTypeDef *USBx)
-}
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-/**
-  * @brief  Initiate Do Ping protocol
+  return ((USBx_HOST->HAINT) & 0xFFFFU);
-  * @param  USBx  Selected device
+}
-  * @param  hc_num  Host Channel number
-  *         This parameter can be a value from 1 to 15
+/**
-  * @retval HAL state
+  * @brief  Halt a host channel
-  */
+  * @param  USBx  Selected device
-HAL_StatusTypeDef USB_DoPing(USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num)
+  * @param  hc_num  Host Channel number
-{
+  *         This parameter can be a value from 1 to 15
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  * @retval HAL state
-  uint32_t chnum = (uint32_t)ch_num;
+  */
-  uint32_t num_packets = 1U;
+HAL_StatusTypeDef USB_HC_Halt(USB_OTG_GlobalTypeDef *USBx, uint8_t hc_num)
-  uint32_t tmpreg;
+{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  USBx_HC(chnum)->HCTSIZ = ((num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
+  uint32_t hcnum = (uint32_t)hc_num;
-                           USB_OTG_HCTSIZ_DOPING;
+  __IO uint32_t count = 0U;
+  uint32_t HcEpType = (USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
-  /* Set host channel enable */
+  uint32_t ChannelEna = (USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) >> 31;
-  tmpreg = USBx_HC(chnum)->HCCHAR;
+  uint32_t SplitEna = (USBx_HC(hcnum)->HCSPLT & USB_OTG_HCSPLT_SPLITEN) >> 31;
-  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
-  tmpreg |= USB_OTG_HCCHAR_CHENA;
+  /* In buffer DMA, Channel disable must not be programmed for non-split periodic channels.
-  USBx_HC(chnum)->HCCHAR = tmpreg;
+     At the end of the next uframe/frame (in the worst case), the core generates a channel halted
+     and disables the channel automatically. */
-  return HAL_OK;
-}
+  if ((((USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN) == USB_OTG_GAHBCFG_DMAEN) && (SplitEna == 0U)) &&
+      ((ChannelEna == 0U) || (((HcEpType == HCCHAR_ISOC) || (HcEpType == HCCHAR_INTR)))))
-/**
+  {
-  * @brief  Stop Host Core
+    return HAL_OK;
-  * @param  USBx  Selected device
+  }
-  * @retval HAL state
-  */
+  /* Check for space in the request queue to issue the halt. */
-HAL_StatusTypeDef USB_StopHost(USB_OTG_GlobalTypeDef *USBx)
+  if ((HcEpType == HCCHAR_CTRL) || (HcEpType == HCCHAR_BULK))
-{
+  {
-  uint32_t USBx_BASE = (uint32_t)USBx;
+    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;
-  uint32_t count = 0U;
-  uint32_t value;
+    if ((USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN) == 0U)
-  uint32_t i;
+    {
+      if ((USBx->HNPTXSTS & (0xFFU << 16)) == 0U)
-  (void)USB_DisableGlobalInt(USBx);
+      {
+        USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
-  /* Flush FIFO */
+        USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-  (void)USB_FlushTxFifo(USBx, 0x10U);
+        do
-  (void)USB_FlushRxFifo(USBx);
+        {
+          count++;
-  /* Flush out any leftover queued requests. */
-  for (i = 0U; i <= 15U; i++)
+          if (count > 1000U)
-  {
+          {
-    value = USBx_HC(i)->HCCHAR;
+            break;
-    value |=  USB_OTG_HCCHAR_CHDIS;
+          }
-    value &= ~USB_OTG_HCCHAR_CHENA;
+        } while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
-    value &= ~USB_OTG_HCCHAR_EPDIR;
+      }
-    USBx_HC(i)->HCCHAR = value;
+      else
-  }
+      {
+        USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-  /* Halt all channels to put them into a known state. */
+      }
-  for (i = 0U; i <= 15U; i++)
+    }
-  {
+    else
-    value = USBx_HC(i)->HCCHAR;
+    {
-    value |= USB_OTG_HCCHAR_CHDIS;
+      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-    value |= USB_OTG_HCCHAR_CHENA;
+    }
-    value &= ~USB_OTG_HCCHAR_EPDIR;
+  }
-    USBx_HC(i)->HCCHAR = value;
+  else
+  {
-    do
+    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;
-    {
-      if (++count > 1000U)
+    if ((USBx_HOST->HPTXSTS & (0xFFU << 16)) == 0U)
-      {
+    {
-        break;
+      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
-      }
+      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-    } while ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
+      do
-  }
+      {
+        count++;
-  /* Clear any pending Host interrupts */
-  USBx_HOST->HAINT = 0xFFFFFFFFU;
+        if (count > 1000U)
-  USBx->GINTSTS = 0xFFFFFFFFU;
+        {
+          break;
-  return HAL_OK;
+        }
-}
+      } while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
+    }
-/**
+    else
-  * @brief  USB_ActivateRemoteWakeup active remote wakeup signalling
+    {
-  * @param  USBx Selected device
+      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
-  * @retval HAL status
+    }
-  */
+  }
-HAL_StatusTypeDef USB_ActivateRemoteWakeup(USB_OTG_GlobalTypeDef *USBx)
-{
+  return HAL_OK;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+}
-  if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
+/**
-  {
+  * @brief  Initiate Do Ping protocol
-    /* active Remote wakeup signalling */
+  * @param  USBx  Selected device
-    USBx_DEVICE->DCTL |= USB_OTG_DCTL_RWUSIG;
+  * @param  hc_num  Host Channel number
-  }
+  *         This parameter can be a value from 1 to 15
+  * @retval HAL state
-  return HAL_OK;
+  */
-}
+HAL_StatusTypeDef USB_DoPing(USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num)
+{
-/**
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  * @brief  USB_DeActivateRemoteWakeup de-active remote wakeup signalling
+  uint32_t chnum = (uint32_t)ch_num;
-  * @param  USBx Selected device
+  uint32_t num_packets = 1U;
-  * @retval HAL status
+  uint32_t tmpreg;
-  */
-HAL_StatusTypeDef USB_DeActivateRemoteWakeup(USB_OTG_GlobalTypeDef *USBx)
+  USBx_HC(chnum)->HCTSIZ = ((num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
-{
+                           USB_OTG_HCTSIZ_DOPING;
-  uint32_t USBx_BASE = (uint32_t)USBx;
+  /* Set host channel enable */
-  /* active Remote wakeup signalling */
+  tmpreg = USBx_HC(chnum)->HCCHAR;
-  USBx_DEVICE->DCTL &= ~(USB_OTG_DCTL_RWUSIG);
+  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
+  tmpreg |= USB_OTG_HCCHAR_CHENA;
-  return HAL_OK;
+  USBx_HC(chnum)->HCCHAR = tmpreg;
-}
-#endif /* defined (USB_OTG_FS) */
+  return HAL_OK;
+}
-#if defined (USB)
 /**
-  * @brief  Initializes the USB Core
+  * @brief  Stop Host Core
-  * @param  USBx USB Instance
+  * @param  USBx  Selected device
-  * @param  cfg pointer to a USB_CfgTypeDef structure that contains
+  * @retval HAL state
-  *         the configuration information for the specified USBx peripheral.
+  */
-  * @retval HAL status
+HAL_StatusTypeDef USB_StopHost(USB_OTG_GlobalTypeDef *USBx)
-  */
+{
-HAL_StatusTypeDef USB_CoreInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
+  HAL_StatusTypeDef ret = HAL_OK;
-{
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  /* Prevent unused argument(s) compilation warning */
+  __IO uint32_t count = 0U;
-  UNUSED(USBx);
+  uint32_t value;
-  UNUSED(cfg);
+  uint32_t i;
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  (void)USB_DisableGlobalInt(USBx);
-              only by USB OTG FS peripheral.
-            - This function is added to ensure compatibility across platforms.
+  /* Flush USB FIFO */
-   */
+  if (USB_FlushTxFifo(USBx, 0x10U) != HAL_OK) /* all Tx FIFOs */
+  {
-  return HAL_OK;
+    ret = HAL_ERROR;
-}
+  }
-/**
+  if (USB_FlushRxFifo(USBx) != HAL_OK)
-  * @brief  USB_EnableGlobalInt
+  {
-  *         Enables the controller's Global Int in the AHB Config reg
+    ret = HAL_ERROR;
-  * @param  USBx Selected device
+  }
-  * @retval HAL status
-  */
+  /* Flush out any leftover queued requests. */
-HAL_StatusTypeDef USB_EnableGlobalInt(USB_TypeDef *USBx)
+  for (i = 0U; i <= 15U; i++)
-{
+  {
-  uint32_t winterruptmask;
+    value = USBx_HC(i)->HCCHAR;
+    value |=  USB_OTG_HCCHAR_CHDIS;
-  /* Clear pending interrupts */
+    value &= ~USB_OTG_HCCHAR_CHENA;
-  USBx->ISTR = 0U;
+    value &= ~USB_OTG_HCCHAR_EPDIR;
+    USBx_HC(i)->HCCHAR = value;
-  /* Set winterruptmask variable */
+  }
-  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
-                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
+  /* Halt all channels to put them into a known state. */
-                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
+  for (i = 0U; i <= 15U; i++)
-                   USB_CNTR_RESETM;
+  {
+    value = USBx_HC(i)->HCCHAR;
-  /* Set interrupt mask */
+    value |= USB_OTG_HCCHAR_CHDIS;
-  USBx->CNTR = (uint16_t)winterruptmask;
+    value |= USB_OTG_HCCHAR_CHENA;
+    value &= ~USB_OTG_HCCHAR_EPDIR;
-  return HAL_OK;
+    USBx_HC(i)->HCCHAR = value;
-}
+    do
-/**
+    {
-  * @brief  USB_DisableGlobalInt
+      count++;
-  *         Disable the controller's Global Int in the AHB Config reg
-  * @param  USBx Selected device
+      if (count > 1000U)
-  * @retval HAL status
+      {
-  */
+        break;
-HAL_StatusTypeDef USB_DisableGlobalInt(USB_TypeDef *USBx)
+      }
-{
+    } while ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
-  uint32_t winterruptmask;
+  }
-  /* Set winterruptmask variable */
+  /* Clear any pending Host interrupts */
-  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
+  USBx_HOST->HAINT = CLEAR_INTERRUPT_MASK;
-                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
+  USBx->GINTSTS = CLEAR_INTERRUPT_MASK;
-                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
-                   USB_CNTR_RESETM;
+  (void)USB_EnableGlobalInt(USBx);
-  /* Clear interrupt mask */
+  return ret;
-  USBx->CNTR &= (uint16_t)(~winterruptmask);
+}
-  return HAL_OK;
+/**
-}
+  * @brief  USB_ActivateRemoteWakeup active remote wakeup signalling
+  * @param  USBx Selected device
-/**
+  * @retval HAL status
-  * @brief  USB_SetCurrentMode Set functional mode
+  */
-  * @param  USBx Selected device
+HAL_StatusTypeDef USB_ActivateRemoteWakeup(USB_OTG_GlobalTypeDef *USBx)
-  * @param  mode current core mode
+{
-  *          This parameter can be one of the these values:
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  *            @arg USB_DEVICE_MODE Peripheral mode
-  * @retval HAL status
+  if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
-  */
+  {
-HAL_StatusTypeDef USB_SetCurrentMode(USB_TypeDef *USBx, USB_ModeTypeDef mode)
+    /* active Remote wakeup signalling */
-{
+    USBx_DEVICE->DCTL |= USB_OTG_DCTL_RWUSIG;
-  /* Prevent unused argument(s) compilation warning */
+  }
-  UNUSED(USBx);
-  UNUSED(mode);
+  return HAL_OK;
+}
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-              only by USB OTG FS peripheral.
+/**
-            - This function is added to ensure compatibility across platforms.
+  * @brief  USB_DeActivateRemoteWakeup de-active remote wakeup signalling
-   */
+  * @param  USBx Selected device
-  return HAL_OK;
+  * @retval HAL status
-}
+  */
+HAL_StatusTypeDef USB_DeActivateRemoteWakeup(USB_OTG_GlobalTypeDef *USBx)
-/**
+{
-  * @brief  USB_DevInit Initializes the USB controller registers
+  uint32_t USBx_BASE = (uint32_t)USBx;
-  *         for device mode
-  * @param  USBx Selected device
+  /* active Remote wakeup signalling */
-  * @param  cfg  pointer to a USB_CfgTypeDef structure that contains
+  USBx_DEVICE->DCTL &= ~(USB_OTG_DCTL_RWUSIG);
-  *         the configuration information for the specified USBx peripheral.
-  * @retval HAL status
+  return HAL_OK;
-  */
+}
-HAL_StatusTypeDef USB_DevInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
+#endif /* defined (USB_OTG_FS) */
-{
-  /* Prevent unused argument(s) compilation warning */
+#if defined (USB)
-  UNUSED(cfg);
+/**
+  * @brief  Initializes the USB Core
-  /* Init Device */
+  * @param  USBx USB Instance
-  /* CNTR_FRES = 1 */
+  * @param  cfg pointer to a USB_CfgTypeDef structure that contains
-  USBx->CNTR = (uint16_t)USB_CNTR_FRES;
+  *         the configuration information for the specified USBx peripheral.
+  * @retval HAL status
-  /* CNTR_FRES = 0 */
+  */
-  USBx->CNTR = 0U;
+HAL_StatusTypeDef USB_CoreInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
+{
-  /* Clear pending interrupts */
+  /* Prevent unused argument(s) compilation warning */
-  USBx->ISTR = 0U;
+  UNUSED(USBx);
+  UNUSED(cfg);
-  /*Set Btable Address*/
-  USBx->BTABLE = BTABLE_ADDRESS;
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+              only by USB OTG FS peripheral.
-  return HAL_OK;
+            - This function is added to ensure compatibility across platforms.
-}
+   */
-/**
+  return HAL_OK;
-  * @brief  USB_FlushTxFifo : Flush a Tx FIFO
+}
-  * @param  USBx : Selected device
-  * @param  num : FIFO number
+/**
-  *         This parameter can be a value from 1 to 15
+  * @brief  USB_EnableGlobalInt
-means Flush all Tx FIFOs
+  *         Enables the controller's Global Int in the AHB Config reg
-  * @retval HAL status
+  * @param  USBx Selected device
-  */
+  * @retval HAL status
-HAL_StatusTypeDef USB_FlushTxFifo(USB_TypeDef *USBx, uint32_t num)
+  */
-{
+HAL_StatusTypeDef USB_EnableGlobalInt(USB_TypeDef *USBx)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(USBx);
+  uint32_t winterruptmask;
-  UNUSED(num);
+  /* Clear pending interrupts */
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  USBx->ISTR = 0U;
-              only by USB OTG FS peripheral.
-            - This function is added to ensure compatibility across platforms.
+  /* Set winterruptmask variable */
-   */
+  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
+                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
-  return HAL_OK;
+                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
-}
+                   USB_CNTR_RESETM;
-/**
+  /* Set interrupt mask */
-  * @brief  USB_FlushRxFifo : Flush Rx FIFO
+  USBx->CNTR = (uint16_t)winterruptmask;
-  * @param  USBx : Selected device
-  * @retval HAL status
+  return HAL_OK;
-  */
+}
-HAL_StatusTypeDef USB_FlushRxFifo(USB_TypeDef *USBx)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  USB_DisableGlobalInt
-  UNUSED(USBx);
+  *         Disable the controller's Global Int in the AHB Config reg
+  * @param  USBx Selected device
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  * @retval HAL status
-              only by USB OTG FS peripheral.
+  */
-            - This function is added to ensure compatibility across platforms.
+HAL_StatusTypeDef USB_DisableGlobalInt(USB_TypeDef *USBx)
-   */
+{
+  uint32_t winterruptmask;
-  return HAL_OK;
-}
+  /* Set winterruptmask variable */
+  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
-#if defined (HAL_PCD_MODULE_ENABLED)
+                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
-/**
+                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
-  * @brief  Activate and configure an endpoint
+                   USB_CNTR_RESETM;
-  * @param  USBx Selected device
-  * @param  ep pointer to endpoint structure
+  /* Clear interrupt mask */
-  * @retval HAL status
+  USBx->CNTR &= (uint16_t)(~winterruptmask);
-  */
-HAL_StatusTypeDef USB_ActivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
+  return HAL_OK;
-{
+}
-  HAL_StatusTypeDef ret = HAL_OK;
-  uint16_t wEpRegVal;
+/**
+  * @brief  USB_SetCurrentMode Set functional mode
-  wEpRegVal = PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_T_MASK;
+  * @param  USBx Selected device
+  * @param  mode current core mode
-  /* initialize Endpoint */
+  *          This parameter can be one of the these values:
-  switch (ep->type)
+  *            @arg USB_DEVICE_MODE Peripheral mode
-  {
+  * @retval HAL status
-    case EP_TYPE_CTRL:
+  */
-      wEpRegVal |= USB_EP_CONTROL;
+HAL_StatusTypeDef USB_SetCurrentMode(USB_TypeDef *USBx, USB_ModeTypeDef mode)
-      break;
+{
+  /* Prevent unused argument(s) compilation warning */
-    case EP_TYPE_BULK:
+  UNUSED(USBx);
-      wEpRegVal |= USB_EP_BULK;
+  UNUSED(mode);
-      break;
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-    case EP_TYPE_INTR:
+              only by USB OTG FS peripheral.
-      wEpRegVal |= USB_EP_INTERRUPT;
+            - This function is added to ensure compatibility across platforms.
-      break;
+   */
+  return HAL_OK;
-    case EP_TYPE_ISOC:
+}
-      wEpRegVal |= USB_EP_ISOCHRONOUS;
-      break;
+/**
+  * @brief  USB_DevInit Initializes the USB controller registers
-    default:
+  *         for device mode
-      ret = HAL_ERROR;
+  * @param  USBx Selected device
-      break;
+  * @param  cfg  pointer to a USB_CfgTypeDef structure that contains
-  }
+  *         the configuration information for the specified USBx peripheral.
+  * @retval HAL status
-  PCD_SET_ENDPOINT(USBx, ep->num, (wEpRegVal | USB_EP_CTR_RX | USB_EP_CTR_TX));
+  */
+HAL_StatusTypeDef USB_DevInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
-  PCD_SET_EP_ADDRESS(USBx, ep->num, ep->num);
+{
+  /* Prevent unused argument(s) compilation warning */
-  if (ep->doublebuffer == 0U)
+  UNUSED(cfg);
-  {
-    if (ep->is_in != 0U)
+  /* Init Device */
-    {
+  /* CNTR_FRES = 1 */
-      /*Set the endpoint Transmit buffer address */
+  USBx->CNTR = (uint16_t)USB_CNTR_FRES;
-      PCD_SET_EP_TX_ADDRESS(USBx, ep->num, ep->pmaadress);
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+  /* CNTR_FRES = 0 */
+  USBx->CNTR = 0U;
-      if (ep->type != EP_TYPE_ISOC)
-      {
+  /* Clear pending interrupts */
-        /* Configure NAK status for the Endpoint */
+  USBx->ISTR = 0U;
-        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
-      }
+  /*Set Btable Address*/
-      else
+  USBx->BTABLE = BTABLE_ADDRESS;
-      {
-        /* Configure TX Endpoint to disabled state */
+  return HAL_OK;
-        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+}
-      }
-    }
+/**
-    else
+  * @brief  USB_FlushTxFifo : Flush a Tx FIFO
-    {
+  * @param  USBx : Selected device
-      /*Set the endpoint Receive buffer address */
+  * @param  num : FIFO number
-      PCD_SET_EP_RX_ADDRESS(USBx, ep->num, ep->pmaadress);
+  *         This parameter can be a value from 1 to 15
+means Flush all Tx FIFOs
-      /*Set the endpoint Receive buffer counter*/
+  * @retval HAL status
-      PCD_SET_EP_RX_CNT(USBx, ep->num, ep->maxpacket);
+  */
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+HAL_StatusTypeDef USB_FlushTxFifo(USB_TypeDef const *USBx, uint32_t num)
+{
-      /* Configure VALID status for the Endpoint*/
+  /* Prevent unused argument(s) compilation warning */
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
+  UNUSED(USBx);
-    }
+  UNUSED(num);
-  }
-  /*Double Buffer*/
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-  else
+              only by USB OTG FS peripheral.
-  {
+            - This function is added to ensure compatibility across platforms.
-    /* Set the endpoint as double buffered */
+   */
-    PCD_SET_EP_DBUF(USBx, ep->num);
+  return HAL_OK;
-    /* Set buffer address for double buffered mode */
+}
-    PCD_SET_EP_DBUF_ADDR(USBx, ep->num, ep->pmaaddr0, ep->pmaaddr1);
+/**
-    if (ep->is_in == 0U)
+  * @brief  USB_FlushRxFifo : Flush Rx FIFO
-    {
+  * @param  USBx : Selected device
-      /* Clear the data toggle bits for the endpoint IN/OUT */
+  * @retval HAL status
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+  */
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+HAL_StatusTypeDef USB_FlushRxFifo(USB_TypeDef const *USBx)
+{
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
+  /* Prevent unused argument(s) compilation warning */
-      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+  UNUSED(USBx);
-    }
-    else
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-    {
+              only by USB OTG FS peripheral.
-      /* Clear the data toggle bits for the endpoint IN/OUT */
+            - This function is added to ensure compatibility across platforms.
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+   */
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+  return HAL_OK;
-      if (ep->type != EP_TYPE_ISOC)
+}
-      {
-        /* Configure NAK status for the Endpoint */
-        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
+#if defined (HAL_PCD_MODULE_ENABLED)
-      }
+/**
-      else
+  * @brief  Activate and configure an endpoint
-      {
+  * @param  USBx Selected device
-        /* Configure TX Endpoint to disabled state */
+  * @param  ep pointer to endpoint structure
-        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+  * @retval HAL status
-      }
+  */
+HAL_StatusTypeDef USB_ActivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
+{
-    }
+  HAL_StatusTypeDef ret = HAL_OK;
-  }
+  uint16_t wEpRegVal;
-  return ret;
+  wEpRegVal = PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_T_MASK;
-}
+  /* initialize Endpoint */
-/**
+  switch (ep->type)
-  * @brief  De-activate and de-initialize an endpoint
+  {
-  * @param  USBx Selected device
+    case EP_TYPE_CTRL:
-  * @param  ep pointer to endpoint structure
+      wEpRegVal |= USB_EP_CONTROL;
-  * @retval HAL status
+      break;
-  */
-HAL_StatusTypeDef USB_DeactivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
+    case EP_TYPE_BULK:
-{
+      wEpRegVal |= USB_EP_BULK;
-  if (ep->doublebuffer == 0U)
+      break;
-  {
-    if (ep->is_in != 0U)
+    case EP_TYPE_INTR:
-    {
+      wEpRegVal |= USB_EP_INTERRUPT;
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+      break;
-      /* Configure DISABLE status for the Endpoint*/
+    case EP_TYPE_ISOC:
-      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+      wEpRegVal |= USB_EP_ISOCHRONOUS;
-    }
+      break;
-    else
-    {
+    default:
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+      ret = HAL_ERROR;
+      break;
-      /* Configure DISABLE status for the Endpoint*/
+  }
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-    }
+  PCD_SET_ENDPOINT(USBx, ep->num, (wEpRegVal | USB_EP_CTR_RX | USB_EP_CTR_TX));
-  }
-  /*Double Buffer*/
+  PCD_SET_EP_ADDRESS(USBx, ep->num, ep->num);
-  else
-  {
+  if (ep->doublebuffer == 0U)
-    if (ep->is_in == 0U)
+  {
-    {
+    if (ep->is_in != 0U)
-      /* Clear the data toggle bits for the endpoint IN/OUT*/
+    {
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+      /*Set the endpoint Transmit buffer address */
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+      PCD_SET_EP_TX_ADDRESS(USBx, ep->num, ep->pmaadress);
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-      /* Reset value of the data toggle bits for the endpoint out*/
-      PCD_TX_DTOG(USBx, ep->num);
+      if (ep->type != EP_TYPE_ISOC)
+      {
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
+        /* Configure NAK status for the Endpoint */
-      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
-    }
+      }
-    else
+      else
-    {
+      {
-      /* Clear the data toggle bits for the endpoint IN/OUT*/
+        /* Configure TX Endpoint to disabled state */
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+      }
-      PCD_RX_DTOG(USBx, ep->num);
+    }
+    else
-      /* Configure DISABLE status for the Endpoint*/
+    {
-      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+      /* Set the endpoint Receive buffer address */
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
+      PCD_SET_EP_RX_ADDRESS(USBx, ep->num, ep->pmaadress);
-    }
-  }
+      /* Set the endpoint Receive buffer counter */
+      PCD_SET_EP_RX_CNT(USBx, ep->num, ep->maxpacket);
-  return HAL_OK;
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-}
+      if (ep->num == 0U)
-/**
+      {
-  * @brief  USB_EPStartXfer setup and starts a transfer over an EP
+        /* Configure VALID status for EP0 */
-  * @param  USBx Selected device
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
-  * @param  ep pointer to endpoint structure
+      }
-  * @retval HAL status
+      else
-  */
+      {
-HAL_StatusTypeDef USB_EPStartXfer(USB_TypeDef *USBx, USB_EPTypeDef *ep)
+        /* Configure NAK status for OUT Endpoint */
-{
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_NAK);
-  uint32_t len;
+      }
-  uint16_t pmabuffer;
+    }
-  uint16_t wEPVal;
+  }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
-  /* IN endpoint */
+  /* Double Buffer */
-  if (ep->is_in == 1U)
+  else
   {
-    /*Multi packet transfer*/
+    if (ep->type == EP_TYPE_BULK)
-    if (ep->xfer_len > ep->maxpacket)
+    {
-    {
+      /* Set bulk endpoint as double buffered */
-      len = ep->maxpacket;
+      PCD_SET_BULK_EP_DBUF(USBx, ep->num);
     }
     else
     {
-      len = ep->xfer_len;
+      /* Set the ISOC endpoint in double buffer mode */
-    }
+      PCD_CLEAR_EP_KIND(USBx, ep->num);
+    }
-    /* configure and validate Tx endpoint */
-    if (ep->doublebuffer == 0U)
+    /* Set buffer address for double buffered mode */
-    {
+    PCD_SET_EP_DBUF_ADDR(USBx, ep->num, ep->pmaaddr0, ep->pmaaddr1);
-      USB_WritePMA(USBx, ep->xfer_buff, ep->pmaadress, (uint16_t)len);
-      PCD_SET_EP_TX_CNT(USBx, ep->num, len);
+    if (ep->is_in == 0U)
-    }
+    {
-    else
+      /* Clear the data toggle bits for the endpoint IN/OUT */
-    {
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-      /* double buffer bulk management */
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-      if (ep->type == EP_TYPE_BULK)
-      {
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
-        if (ep->xfer_len_db > ep->maxpacket)
+      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-        {
+    }
-          /* enable double buffer */
+    else
-          PCD_SET_EP_DBUF(USBx, ep->num);
+    {
+      /* Clear the data toggle bits for the endpoint IN/OUT */
-          /* each Time to write in PMA xfer_len_db will */
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-          ep->xfer_len_db -= len;
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-          /* Fill the two first buffer in the Buffer0 & Buffer1 */
+      if (ep->type != EP_TYPE_ISOC)
-          if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
+      {
-          {
+        /* Configure NAK status for the Endpoint */
-            /* Set the Double buffer counter for pmabuffer1 */
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
-            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
+      }
-            pmabuffer = ep->pmaaddr1;
+      else
+      {
-            /* Write the user buffer to USB PMA */
+        /* Configure TX Endpoint to disabled state */
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-            ep->xfer_buff += len;
+      }
-            if (ep->xfer_len_db > ep->maxpacket)
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-            {
+    }
-              ep->xfer_len_db -= len;
+  }
-            }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
-            else
-            {
+  return ret;
-              len = ep->xfer_len_db;
+}
-              ep->xfer_len_db = 0U;
-            }
+/**
+  * @brief  De-activate and de-initialize an endpoint
-            /* Set the Double buffer counter for pmabuffer0 */
+  * @param  USBx Selected device
-            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
+  * @param  ep pointer to endpoint structure
-            pmabuffer = ep->pmaaddr0;
+  * @retval HAL status
+  */
-            /* Write the user buffer to USB PMA */
+HAL_StatusTypeDef USB_DeactivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+{
-          }
+  if (ep->doublebuffer == 0U)
-          else
+  {
-          {
+    if (ep->is_in != 0U)
-            /* Set the Double buffer counter for pmabuffer0 */
+    {
-            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-            pmabuffer = ep->pmaaddr0;
+      /* Configure DISABLE status for the Endpoint */
-            /* Write the user buffer to USB PMA */
+      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+    }
-            ep->xfer_buff += len;
+    else
-            if (ep->xfer_len_db > ep->maxpacket)
+    {
-            {
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-              ep->xfer_len_db -= len;
-            }
+      /* Configure DISABLE status for the Endpoint */
-            else
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-            {
+    }
-              len = ep->xfer_len_db;
+  }
-              ep->xfer_len_db = 0U;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
-            }
+  /* Double Buffer */
+  else
-            /* Set the Double buffer counter for pmabuffer1 */
+  {
-            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
+    if (ep->is_in == 0U)
-            pmabuffer = ep->pmaaddr1;
+    {
+      /* Clear the data toggle bits for the endpoint IN/OUT*/
-            /* Write the user buffer to USB PMA */
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-          }
-        }
+      /* Reset value of the data toggle bits for the endpoint out*/
-        /* auto Switch to single buffer mode when transfer <Mps no need to manage in double buffer */
+      PCD_TX_DTOG(USBx, ep->num);
-        else
-        {
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-          len = ep->xfer_len_db;
+      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+    }
-          /* disable double buffer mode */
+    else
-          PCD_CLEAR_EP_DBUF(USBx, ep->num);
+    {
+      /* Clear the data toggle bits for the endpoint IN/OUT*/
-          /* Set Tx count with nbre of byte to be transmitted */
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-          PCD_SET_EP_TX_CNT(USBx, ep->num, len);
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-          pmabuffer = ep->pmaaddr0;
+      PCD_RX_DTOG(USBx, ep->num);
-          /* Write the user buffer to USB PMA */
+      /* Configure DISABLE status for the Endpoint*/
-          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-        }
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-      }/* end if bulk double buffer */
+    }
+  }
-      /* manage isochronous double buffer IN mode */
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
-      else
-      {
+  return HAL_OK;
-        /* enable double buffer */
+}
-        PCD_SET_EP_DBUF(USBx, ep->num);
+/**
-        /* each Time to write in PMA xfer_len_db will */
+  * @brief  USB_EPStartXfer setup and starts a transfer over an EP
-        ep->xfer_len_db -= len;
+  * @param  USBx Selected device
+  * @param  ep pointer to endpoint structure
-        /* Fill the data buffer */
+  * @retval HAL status
-        if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
+  */
-        {
+HAL_StatusTypeDef USB_EPStartXfer(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-          /* Set the Double buffer counter for pmabuffer1 */
+{
-          PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
+  uint32_t len;
-          pmabuffer = ep->pmaaddr1;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+  uint16_t pmabuffer;
-          /* Write the user buffer to USB PMA */
+  uint16_t wEPVal;
-          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
-          ep->xfer_buff += len;
+  /* IN endpoint */
-          if (ep->xfer_len_db > ep->maxpacket)
+  if (ep->is_in == 1U)
-          {
+  {
-            ep->xfer_len_db -= len;
+    /*Multi packet transfer*/
-          }
+    if (ep->xfer_len > ep->maxpacket)
-          else
+    {
-          {
+      len = ep->maxpacket;
-            len = ep->xfer_len_db;
+    }
-            ep->xfer_len_db = 0U;
+    else
-          }
+    {
+      len = ep->xfer_len;
-          if (len > 0U)
+    }
-          {
-            /* Set the Double buffer counter for pmabuffer0 */
+    /* configure and validate Tx endpoint */
-            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
+    if (ep->doublebuffer == 0U)
-            pmabuffer = ep->pmaaddr0;
+    {
+      USB_WritePMA(USBx, ep->xfer_buff, ep->pmaadress, (uint16_t)len);
-            /* Write the user buffer to USB PMA */
+      PCD_SET_EP_TX_CNT(USBx, ep->num, len);
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+    }
-          }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
-        }
+    else
-        else
+    {
-        {
+      /* double buffer bulk management */
-          /* Set the Double buffer counter for pmabuffer0 */
+      if (ep->type == EP_TYPE_BULK)
-          PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
+      {
-          pmabuffer = ep->pmaaddr0;
+        if (ep->xfer_len_db > ep->maxpacket)
+        {
-          /* Write the user buffer to USB PMA */
+          /* enable double buffer */
-          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+          PCD_SET_BULK_EP_DBUF(USBx, ep->num);
-          ep->xfer_buff += len;
+          /* each Time to write in PMA xfer_len_db will */
-          if (ep->xfer_len_db > ep->maxpacket)
+          ep->xfer_len_db -= len;
-          {
-            ep->xfer_len_db -= len;
+          /* Fill the two first buffer in the Buffer0 & Buffer1 */
-          }
+          if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
-          else
+          {
-          {
+            /* Set the Double buffer counter for pmabuffer1 */
-            len = ep->xfer_len_db;
+            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
-            ep->xfer_len_db = 0U;
+            pmabuffer = ep->pmaaddr1;
-          }
+            /* Write the user buffer to USB PMA */
-          if (len > 0U)
+            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          {
+            ep->xfer_buff += len;
-            /* Set the Double buffer counter for pmabuffer1 */
-            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
+            if (ep->xfer_len_db > ep->maxpacket)
-            pmabuffer = ep->pmaaddr1;
+            {
+              ep->xfer_len_db -= len;
-            /* Write the user buffer to USB PMA */
+            }
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+            else
-          }
+            {
-        }
+              len = ep->xfer_len_db;
-      }
+              ep->xfer_len_db = 0U;
-    }
+            }
-    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_VALID);
+            /* Set the Double buffer counter for pmabuffer0 */
-  }
+            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
-  else /* OUT endpoint */
+            pmabuffer = ep->pmaaddr0;
-  {
-    if (ep->doublebuffer == 0U)
+            /* Write the user buffer to USB PMA */
-    {
+            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-      /* Multi packet transfer */
+          }
-      if (ep->xfer_len > ep->maxpacket)
+          else
-      {
+          {
-        len = ep->maxpacket;
+            /* Set the Double buffer counter for pmabuffer0 */
-        ep->xfer_len -= len;
+            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
-      }
+            pmabuffer = ep->pmaaddr0;
-      else
-      {
+            /* Write the user buffer to USB PMA */
-        len = ep->xfer_len;
+            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-        ep->xfer_len = 0U;
+            ep->xfer_buff += len;
-      }
-      /* configure and validate Rx endpoint */
+            if (ep->xfer_len_db > ep->maxpacket)
-      PCD_SET_EP_RX_CNT(USBx, ep->num, len);
+            {
-    }
+              ep->xfer_len_db -= len;
-    else
+            }
-    {
+            else
-      /* First Transfer Coming From HAL_PCD_EP_Receive & From ISR */
+            {
-      /* Set the Double buffer counter */
+              len = ep->xfer_len_db;
-      if (ep->type == EP_TYPE_BULK)
+              ep->xfer_len_db = 0U;
-      {
+            }
-        PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, ep->maxpacket);
+            /* Set the Double buffer counter for pmabuffer1 */
-        /* Coming from ISR */
+            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
-        if (ep->xfer_count != 0U)
+            pmabuffer = ep->pmaaddr1;
-        {
-          /* update last value to check if there is blocking state */
+            /* Write the user buffer to USB PMA */
-          wEPVal = PCD_GET_ENDPOINT(USBx, ep->num);
+            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
+          }
-          /*Blocking State */
+        }
-          if ((((wEPVal & USB_EP_DTOG_RX) != 0U) && ((wEPVal & USB_EP_DTOG_TX) != 0U)) ||
+        /* auto Switch to single buffer mode when transfer <Mps no need to manage in double buffer */
-              (((wEPVal & USB_EP_DTOG_RX) == 0U) && ((wEPVal & USB_EP_DTOG_TX) == 0U)))
+        else
-          {
+        {
-            PCD_FreeUserBuffer(USBx, ep->num, 0U);
+          len = ep->xfer_len_db;
-          }
-        }
+          /* disable double buffer mode for Bulk endpoint */
-      }
+          PCD_CLEAR_BULK_EP_DBUF(USBx, ep->num);
-      /* iso out double */
-      else if (ep->type == EP_TYPE_ISOC)
+          /* Set Tx count with nbre of byte to be transmitted */
-      {
+          PCD_SET_EP_TX_CNT(USBx, ep->num, len);
-        /* Multi packet transfer */
+          pmabuffer = ep->pmaaddr0;
-        if (ep->xfer_len > ep->maxpacket)
-        {
+          /* Write the user buffer to USB PMA */
-          len = ep->maxpacket;
+          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          ep->xfer_len -= len;
+        }
-        }
+      }
-        else
+      else /* manage isochronous double buffer IN mode */
-        {
+      {
-          len = ep->xfer_len;
+        /* each Time to write in PMA xfer_len_db will */
-          ep->xfer_len = 0U;
+        ep->xfer_len_db -= len;
-        }
-        PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, len);
+        /* Fill the data buffer */
-      }
+        if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
-      else
+        {
-      {
+          /* Set the Double buffer counter for pmabuffer1 */
-        return HAL_ERROR;
+          PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
-      }
+          pmabuffer = ep->pmaaddr1;
-    }
+          /* Write the user buffer to USB PMA */
-    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
+          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-  }
+        }
+        else
-  return HAL_OK;
+        {
-}
+          /* Set the Double buffer counter for pmabuffer0 */
+          PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
+          pmabuffer = ep->pmaaddr0;
-/**
-  * @brief  USB_EPSetStall set a stall condition over an EP
+          /* Write the user buffer to USB PMA */
-  * @param  USBx Selected device
+          USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-  * @param  ep pointer to endpoint structure
+        }
-  * @retval HAL status
+      }
-  */
+    }
-HAL_StatusTypeDef USB_EPSetStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
-{
-  if (ep->is_in != 0U)
+    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_VALID);
-  {
+  }
-    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_STALL);
+  else /* OUT endpoint */
-  }
+  {
-  else
+    if (ep->doublebuffer == 0U)
-  {
+    {
-    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_STALL);
+      /* Multi packet transfer */
-  }
+      if (ep->xfer_len > ep->maxpacket)
+      {
-  return HAL_OK;
+        len = ep->maxpacket;
-}
+        ep->xfer_len -= len;
+      }
-/**
+      else
-  * @brief  USB_EPClearStall Clear a stall condition over an EP
+      {
-  * @param  USBx Selected device
+        len = ep->xfer_len;
-  * @param  ep pointer to endpoint structure
+        ep->xfer_len = 0U;
-  * @retval HAL status
+      }
-  */
+      /* configure and validate Rx endpoint */
-HAL_StatusTypeDef USB_EPClearStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
+      PCD_SET_EP_RX_CNT(USBx, ep->num, len);
-{
+    }
-  if (ep->doublebuffer == 0U)
+#if (USE_USB_DOUBLE_BUFFER == 1U)
-  {
+    else
-    if (ep->is_in != 0U)
+    {
-    {
+      /* First Transfer Coming From HAL_PCD_EP_Receive & From ISR */
-      PCD_CLEAR_TX_DTOG(USBx, ep->num);
+      /* Set the Double buffer counter */
+      if (ep->type == EP_TYPE_BULK)
-      if (ep->type != EP_TYPE_ISOC)
+      {
-      {
+        PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, ep->maxpacket);
-        /* Configure NAK status for the Endpoint */
-        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
+        /* Coming from ISR */
-      }
+        if (ep->xfer_count != 0U)
-    }
+        {
-    else
+          /* update last value to check if there is blocking state */
-    {
+          wEPVal = PCD_GET_ENDPOINT(USBx, ep->num);
-      PCD_CLEAR_RX_DTOG(USBx, ep->num);
+          /*Blocking State */
-      /* Configure VALID status for the Endpoint */
+          if ((((wEPVal & USB_EP_DTOG_RX) != 0U) && ((wEPVal & USB_EP_DTOG_TX) != 0U)) ||
-      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
+              (((wEPVal & USB_EP_DTOG_RX) == 0U) && ((wEPVal & USB_EP_DTOG_TX) == 0U)))
-    }
+          {
-  }
+            PCD_FREE_USER_BUFFER(USBx, ep->num, 0U);
+          }
-  return HAL_OK;
+        }
-}
+      }
-#endif
+      /* iso out double */
+      else if (ep->type == EP_TYPE_ISOC)
-/**
+      {
-  * @brief  USB_StopDevice Stop the usb device mode
+        /* Multi packet transfer */
-  * @param  USBx Selected device
+        if (ep->xfer_len > ep->maxpacket)
-  * @retval HAL status
+        {
-  */
+          len = ep->maxpacket;
-HAL_StatusTypeDef USB_StopDevice(USB_TypeDef *USBx)
+          ep->xfer_len -= len;
-{
+        }
-  /* disable all interrupts and force USB reset */
+        else
-  USBx->CNTR = (uint16_t)USB_CNTR_FRES;
+        {
+          len = ep->xfer_len;
-  /* clear interrupt status register */
+          ep->xfer_len = 0U;
-  USBx->ISTR = 0U;
+        }
+        PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, len);
-  /* switch-off device */
+      }
-  USBx->CNTR = (uint16_t)(USB_CNTR_FRES | USB_CNTR_PDWN);
+      else
+      {
-  return HAL_OK;
+        return HAL_ERROR;
-}
+      }
+    }
-/**
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
-  * @brief  USB_SetDevAddress Stop the usb device mode
-  * @param  USBx Selected device
+    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
-  * @param  address new device address to be assigned
+  }
-  *          This parameter can be a value from 0 to 255
-  * @retval HAL status
+  return HAL_OK;
-  */
+}
-HAL_StatusTypeDef  USB_SetDevAddress(USB_TypeDef *USBx, uint8_t address)
-{
-  if (address == 0U)
+/**
-  {
+  * @brief  USB_EPSetStall set a stall condition over an EP
-    /* set device address and enable function */
+  * @param  USBx Selected device
-    USBx->DADDR = (uint16_t)USB_DADDR_EF;
+  * @param  ep pointer to endpoint structure
-  }
+  * @retval HAL status
+  */
-  return HAL_OK;
+HAL_StatusTypeDef USB_EPSetStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-}
+{
+  if (ep->is_in != 0U)
-/**
+  {
-  * @brief  USB_DevConnect Connect the USB device by enabling the pull-up/pull-down
+    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_STALL);
-  * @param  USBx Selected device
+  }
-  * @retval HAL status
+  else
-  */
+  {
-HAL_StatusTypeDef  USB_DevConnect(USB_TypeDef *USBx)
+    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_STALL);
-{
+  }
-  /* Prevent unused argument(s) compilation warning */
-  UNUSED(USBx);
+  return HAL_OK;
+}
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-              only by USB OTG FS peripheral.
+/**
-            - This function is added to ensure compatibility across platforms.
+  * @brief  USB_EPClearStall Clear a stall condition over an EP
-   */
+  * @param  USBx Selected device
+  * @param  ep pointer to endpoint structure
-  return HAL_OK;
+  * @retval HAL status
-}
+  */
+HAL_StatusTypeDef USB_EPClearStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-/**
+{
-  * @brief  USB_DevDisconnect Disconnect the USB device by disabling the pull-up/pull-down
+  if (ep->doublebuffer == 0U)
-  * @param  USBx Selected device
+  {
-  * @retval HAL status
+    if (ep->is_in != 0U)
-  */
+    {
-HAL_StatusTypeDef  USB_DevDisconnect(USB_TypeDef *USBx)
+      PCD_CLEAR_TX_DTOG(USBx, ep->num);
-{
-  /* Prevent unused argument(s) compilation warning */
+      if (ep->type != EP_TYPE_ISOC)
-  UNUSED(USBx);
+      {
+        /* Configure NAK status for the Endpoint */
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
-              only by USB OTG FS peripheral.
+      }
-            - This function is added to ensure compatibility across platforms.
+    }
-   */
+    else
+    {
-  return HAL_OK;
+      PCD_CLEAR_RX_DTOG(USBx, ep->num);
-}
+      /* Configure VALID status for the Endpoint */
-/**
+      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
-  * @brief  USB_ReadInterrupts return the global USB interrupt status
+    }
-  * @param  USBx Selected device
+  }
-  * @retval HAL status
-  */
+  return HAL_OK;
-uint32_t  USB_ReadInterrupts(USB_TypeDef *USBx)
+}
-{
-  uint32_t tmpreg;
+/**
+   * @brief  USB_EPStoptXfer  Stop transfer on an EP
-  tmpreg = USBx->ISTR;
+   * @param  USBx  usb device instance
-  return tmpreg;
+   * @param  ep pointer to endpoint structure
-}
+   * @retval HAL status
+   */
-/**
+HAL_StatusTypeDef USB_EPStopXfer(USB_TypeDef *USBx, USB_EPTypeDef *ep)
-  * @brief  USB_ReadDevAllOutEpInterrupt return the USB device OUT endpoints interrupt status
+{
-  * @param  USBx Selected device
+  /* IN endpoint */
-  * @retval HAL status
+  if (ep->is_in == 1U)
-  */
+  {
-uint32_t USB_ReadDevAllOutEpInterrupt(USB_TypeDef *USBx)
+    if (ep->doublebuffer == 0U)
-{
+    {
-  /* Prevent unused argument(s) compilation warning */
+      if (ep->type != EP_TYPE_ISOC)
-  UNUSED(USBx);
+      {
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+        /* Configure NAK status for the Endpoint */
-              only by USB OTG FS peripheral.
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
-            - This function is added to ensure compatibility across platforms.
+      }
-   */
+      else
-  return (0);
+      {
-}
+        /* Configure TX Endpoint to disabled state */
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
-/**
+      }
-  * @brief  USB_ReadDevAllInEpInterrupt return the USB device IN endpoints interrupt status
+    }
-  * @param  USBx Selected device
+  }
-  * @retval HAL status
+  else /* OUT endpoint */
-  */
+  {
-uint32_t USB_ReadDevAllInEpInterrupt(USB_TypeDef *USBx)
+    if (ep->doublebuffer == 0U)
-{
+    {
-  /* Prevent unused argument(s) compilation warning */
+      if (ep->type != EP_TYPE_ISOC)
-  UNUSED(USBx);
+      {
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+        /* Configure NAK status for the Endpoint */
-              only by USB OTG FS peripheral.
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_NAK);
-            - This function is added to ensure compatibility across platforms.
+      }
-   */
+      else
-  return (0);
+      {
-}
+        /* Configure RX Endpoint to disabled state */
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
-/**
+      }
-  * @brief  Returns Device OUT EP Interrupt register
+    }
-  * @param  USBx Selected device
+  }
-  * @param  epnum endpoint number
-  *          This parameter can be a value from 0 to 15
+  return HAL_OK;
-  * @retval Device OUT EP Interrupt register
+}
-  */
+#endif /* defined (HAL_PCD_MODULE_ENABLED) */
-uint32_t USB_ReadDevOutEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  USB_StopDevice Stop the usb device mode
-  UNUSED(USBx);
+  * @param  USBx Selected device
-  UNUSED(epnum);
+  * @retval HAL status
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  */
-              only by USB OTG FS peripheral.
+HAL_StatusTypeDef USB_StopDevice(USB_TypeDef *USBx)
-            - This function is added to ensure compatibility across platforms.
+{
-   */
+  /* disable all interrupts and force USB reset */
-  return (0);
+  USBx->CNTR = (uint16_t)USB_CNTR_FRES;
-}
+  /* clear interrupt status register */
-/**
+  USBx->ISTR = 0U;
-  * @brief  Returns Device IN EP Interrupt register
-  * @param  USBx Selected device
+  /* switch-off device */
-  * @param  epnum endpoint number
+  USBx->CNTR = (uint16_t)(USB_CNTR_FRES | USB_CNTR_PDWN);
-  *          This parameter can be a value from 0 to 15
-  * @retval Device IN EP Interrupt register
+  return HAL_OK;
-  */
+}
-uint32_t USB_ReadDevInEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  USB_SetDevAddress Stop the usb device mode
-  UNUSED(USBx);
+  * @param  USBx Selected device
-  UNUSED(epnum);
+  * @param  address new device address to be assigned
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  *          This parameter can be a value from 0 to 255
-              only by USB OTG FS peripheral.
+  * @retval HAL status
-            - This function is added to ensure compatibility across platforms.
+  */
-   */
+HAL_StatusTypeDef  USB_SetDevAddress(USB_TypeDef *USBx, uint8_t address)
-  return (0);
+{
-}
+  if (address == 0U)
+  {
-/**
+    /* set device address and enable function */
-  * @brief  USB_ClearInterrupts: clear a USB interrupt
+    USBx->DADDR = (uint16_t)USB_DADDR_EF;
-  * @param  USBx Selected device
+  }
-  * @param  interrupt  flag
-  * @retval None
+  return HAL_OK;
-  */
+}
-void  USB_ClearInterrupts(USB_TypeDef *USBx, uint32_t interrupt)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  USB_DevConnect Connect the USB device by enabling the pull-up/pull-down
-  UNUSED(USBx);
+  * @param  USBx Selected device
-  UNUSED(interrupt);
+  * @retval HAL status
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  */
-              only by USB OTG FS peripheral.
+HAL_StatusTypeDef  USB_DevConnect(USB_TypeDef *USBx)
-            - This function is added to ensure compatibility across platforms.
+{
-   */
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(USBx);
-/**
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-  * @brief  Prepare the EP0 to start the first control setup
+              only by USB OTG FS peripheral.
-  * @param  USBx Selected device
+            - This function is added to ensure compatibility across platforms.
-  * @param  psetup pointer to setup packet
+   */
-  * @retval HAL status
-  */
+  return HAL_OK;
-HAL_StatusTypeDef USB_EP0_OutStart(USB_TypeDef *USBx, uint8_t *psetup)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(USBx);
+  * @brief  USB_DevDisconnect Disconnect the USB device by disabling the pull-up/pull-down
-  UNUSED(psetup);
+  * @param  USBx Selected device
-  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+  * @retval HAL status
-              only by USB OTG FS peripheral.
+  */
-            - This function is added to ensure compatibility across platforms.
+HAL_StatusTypeDef  USB_DevDisconnect(USB_TypeDef *USBx)
-   */
+{
-  return HAL_OK;
+  /* Prevent unused argument(s) compilation warning */
-}
+  UNUSED(USBx);
-/**
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-  * @brief  USB_ActivateRemoteWakeup : active remote wakeup signalling
+              only by USB OTG FS peripheral.
-  * @param  USBx Selected device
+            - This function is added to ensure compatibility across platforms.
-  * @retval HAL status
+   */
-  */
-HAL_StatusTypeDef USB_ActivateRemoteWakeup(USB_TypeDef *USBx)
+  return HAL_OK;
-{
+}
-  USBx->CNTR |= (uint16_t)USB_CNTR_RESUME;
+/**
-  return HAL_OK;
+  * @brief  USB_ReadInterrupts return the global USB interrupt status
-}
+  * @param  USBx Selected device
+  * @retval USB Global Interrupt status
-/**
+  */
-  * @brief  USB_DeActivateRemoteWakeup de-active remote wakeup signalling
+uint32_t USB_ReadInterrupts(USB_TypeDef const *USBx)
-  * @param  USBx Selected device
+{
-  * @retval HAL status
+  uint32_t tmpreg;
-  */
-HAL_StatusTypeDef USB_DeActivateRemoteWakeup(USB_TypeDef *USBx)
+  tmpreg = USBx->ISTR;
-{
+  return tmpreg;
-  USBx->CNTR &= (uint16_t)(~USB_CNTR_RESUME);
+}
-  return HAL_OK;
+/**
-}
+  * @brief  USB_ReadDevAllOutEpInterrupt return the USB device OUT endpoints interrupt status
+  * @param  USBx Selected device
-/**
+  * @retval HAL status
-  * @brief Copy a buffer from user memory area to packet memory area (PMA)
+  */
-  * @param   USBx USB peripheral instance register address.
+uint32_t USB_ReadDevAllOutEpInterrupt(USB_TypeDef *USBx)
-  * @param   pbUsrBuf pointer to user memory area.
+{
-  * @param   wPMABufAddr address into PMA.
+  /* Prevent unused argument(s) compilation warning */
-  * @param   wNBytes no. of bytes to be copied.
+  UNUSED(USBx);
-  * @retval None
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-  */
+              only by USB OTG FS peripheral.
-void USB_WritePMA(USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+            - This function is added to ensure compatibility across platforms.
-{
+   */
-  uint32_t n = ((uint32_t)wNBytes + 1U) >> 1;
+  return (0);
-  uint32_t BaseAddr = (uint32_t)USBx;
+}
-  uint32_t i, temp1, temp2;
-  __IO uint16_t *pdwVal;
+/**
-  uint8_t *pBuf = pbUsrBuf;
+  * @brief  USB_ReadDevAllInEpInterrupt return the USB device IN endpoints interrupt status
+  * @param  USBx Selected device
-  pdwVal = (__IO uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
+  * @retval HAL status
+  */
-  for (i = n; i != 0U; i--)
+uint32_t USB_ReadDevAllInEpInterrupt(USB_TypeDef *USBx)
-  {
+{
-    temp1 = *pBuf;
+  /* Prevent unused argument(s) compilation warning */
-    pBuf++;
+  UNUSED(USBx);
-    temp2 = temp1 | ((uint16_t)((uint16_t) *pBuf << 8));
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-    *pdwVal = (uint16_t)temp2;
+              only by USB OTG FS peripheral.
-    pdwVal++;
+            - This function is added to ensure compatibility across platforms.
+   */
-#if PMA_ACCESS > 1U
+  return (0);
-    pdwVal++;
+}
-#endif
+/**
-    pBuf++;
+  * @brief  Returns Device OUT EP Interrupt register
-  }
+  * @param  USBx Selected device
-}
+  * @param  epnum endpoint number
+  *          This parameter can be a value from 0 to 15
-/**
+  * @retval Device OUT EP Interrupt register
-  * @brief Copy data from packet memory area (PMA) to user memory buffer
+  */
-  * @param   USBx USB peripheral instance register address.
+uint32_t USB_ReadDevOutEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
-  * @param   pbUsrBuf pointer to user memory area.
+{
-  * @param   wPMABufAddr address into PMA.
+  /* Prevent unused argument(s) compilation warning */
-  * @param   wNBytes no. of bytes to be copied.
+  UNUSED(USBx);
-  * @retval None
+  UNUSED(epnum);
-  */
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-void USB_ReadPMA(USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+              only by USB OTG FS peripheral.
-{
+            - This function is added to ensure compatibility across platforms.
-  uint32_t n = (uint32_t)wNBytes >> 1;
+   */
-  uint32_t BaseAddr = (uint32_t)USBx;
+  return (0);
-  uint32_t i, temp;
+}
-  __IO uint16_t *pdwVal;
-  uint8_t *pBuf = pbUsrBuf;
+/**
+  * @brief  Returns Device IN EP Interrupt register
-  pdwVal = (__IO uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
+  * @param  USBx Selected device
+  * @param  epnum endpoint number
-  for (i = n; i != 0U; i--)
+  *          This parameter can be a value from 0 to 15
-  {
+  * @retval Device IN EP Interrupt register
-    temp = *(__IO uint16_t *)pdwVal;
+  */
-    pdwVal++;
+uint32_t USB_ReadDevInEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
-    *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
+{
-    pBuf++;
+  /* Prevent unused argument(s) compilation warning */
-    *pBuf = (uint8_t)((temp >> 8) & 0xFFU);
+  UNUSED(USBx);
-    pBuf++;
+  UNUSED(epnum);
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-#if PMA_ACCESS > 1U
+              only by USB OTG FS peripheral.
-    pdwVal++;
+            - This function is added to ensure compatibility across platforms.
-#endif
+   */
-  }
+  return (0);
+}
-  if ((wNBytes % 2U) != 0U)
-  {
+/**
-    temp = *pdwVal;
+  * @brief  USB_ClearInterrupts: clear a USB interrupt
-    *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
+  * @param  USBx Selected device
-  }
+  * @param  interrupt  flag
-}
+  * @retval None
-#endif /* defined (USB) */
+  */
+void  USB_ClearInterrupts(USB_TypeDef *USBx, uint32_t interrupt)
-/**
+{
-  * @}
+  /* Prevent unused argument(s) compilation warning */
-  */
+  UNUSED(USBx);
+  UNUSED(interrupt);
-/**
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
-  * @}
+              only by USB OTG FS peripheral.
-  */
+            - This function is added to ensure compatibility across platforms.
-#endif /* defined (USB) || defined (USB_OTG_FS) */
+   */
-#endif /* defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED) */
+}
 /**
-  * @}
+  * @brief  Prepare the EP0 to start the first control setup
-  */
+  * @param  USBx Selected device
+  * @param  psetup pointer to setup packet
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+  * @retval HAL status
+  */
+HAL_StatusTypeDef USB_EP0_OutStart(USB_TypeDef *USBx, uint8_t *psetup)
+{
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(USBx);
+  UNUSED(psetup);
+  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
+              only by USB OTG FS peripheral.
+            - This function is added to ensure compatibility across platforms.
+   */
+  return HAL_OK;
+}
+/**
+  * @brief  USB_ActivateRemoteWakeup : active remote wakeup signalling
+  * @param  USBx Selected device
+  * @retval HAL status
+  */
+HAL_StatusTypeDef USB_ActivateRemoteWakeup(USB_TypeDef *USBx)
+{
+  USBx->CNTR |= (uint16_t)USB_CNTR_RESUME;
+  return HAL_OK;
+}
+/**
+  * @brief  USB_DeActivateRemoteWakeup de-active remote wakeup signalling
+  * @param  USBx Selected device
+  * @retval HAL status
+  */
+HAL_StatusTypeDef USB_DeActivateRemoteWakeup(USB_TypeDef *USBx)
+{
+  USBx->CNTR &= (uint16_t)(~USB_CNTR_RESUME);
+  return HAL_OK;
+}
+/**
+  * @brief Copy a buffer from user memory area to packet memory area (PMA)
+  * @param   USBx USB peripheral instance register address.
+  * @param   pbUsrBuf pointer to user memory area.
+  * @param   wPMABufAddr address into PMA.
+  * @param   wNBytes no. of bytes to be copied.
+  * @retval None
+  */
+void USB_WritePMA(USB_TypeDef const *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
+  uint32_t n = ((uint32_t)wNBytes + 1U) >> 1;
+  uint32_t BaseAddr = (uint32_t)USBx;
+  uint32_t count;
+  uint16_t WrVal;
+  __IO uint16_t *pdwVal;
+  uint8_t *pBuf = pbUsrBuf;
+  pdwVal = (__IO uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
+  for (count = n; count != 0U; count--)
+  {
+    WrVal = pBuf[0];
+    WrVal |= (uint16_t)pBuf[1] << 8;
+    *pdwVal = (WrVal & 0xFFFFU);
+    pdwVal++;
+#if PMA_ACCESS > 1U
+    pdwVal++;
+#endif /* PMA_ACCESS */
+    pBuf++;
+    pBuf++;
+  }
+}
+/**
+  * @brief Copy data from packet memory area (PMA) to user memory buffer
+  * @param   USBx USB peripheral instance register address.
+  * @param   pbUsrBuf pointer to user memory area.
+  * @param   wPMABufAddr address into PMA.
+  * @param   wNBytes no. of bytes to be copied.
+  * @retval None
+  */
+void USB_ReadPMA(USB_TypeDef const *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
+  uint32_t n = (uint32_t)wNBytes >> 1;
+  uint32_t BaseAddr = (uint32_t)USBx;
+  uint32_t count;
+  uint32_t RdVal;
+  __IO uint16_t *pdwVal;
+  uint8_t *pBuf = pbUsrBuf;
+  pdwVal = (__IO uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
+  for (count = n; count != 0U; count--)
+  {
+    RdVal = *(__IO uint16_t *)pdwVal;
+    pdwVal++;
+    *pBuf = (uint8_t)((RdVal >> 0) & 0xFFU);
+    pBuf++;
+    *pBuf = (uint8_t)((RdVal >> 8) & 0xFFU);
+    pBuf++;
+#if PMA_ACCESS > 1U
+    pdwVal++;
+#endif /* PMA_ACCESS */
+  }
+  if ((wNBytes % 2U) != 0U)
+  {
+    RdVal = *pdwVal;
+    *pBuf = (uint8_t)((RdVal >> 0) & 0xFFU);
+  }
+}
+#endif /* defined (USB) */
+/**
+  * @}
+  */
+/**
+  * @}
+  */
+#endif /* defined (USB) || defined (USB_OTG_FS) */
+#endif /* defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED) */
+/**
+  * @}
+  */

Subversion Repositories canSerial

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