lib/main/STM32F1/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_hcd.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f1xx_hal_hcd.c
   4   * @author  MCD Application Team
   5   * @version V1.1.1
   6   * @date    12-May-2017
   7   * @brief   HCD HAL module driver.
   8   *          This file provides firmware functions to manage the following
   9   *          functionalities of the USB Peripheral Controller:
  10   *           + Initialization and de-initialization functions
  11   *           + IO operation functions
  12   *           + Peripheral Control functions
  13   *           + Peripheral State functions
  14   *
  15   @verbatim
  16   ==============================================================================
  17                     ##### How to use this driver #####
  18   ==============================================================================
  19   [..]
  20     (#)Declare a HCD_HandleTypeDef handle structure, for example:
  21        HCD_HandleTypeDef  hhcd;
  22
  23     (#)Fill parameters of Init structure in HCD handle
  24
  25     (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)
  26
  27     (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
  28         (##) Enable the HCD/USB Low Level interface clock using the following macro
  29              (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE()
  30
  31         (##) Initialize the related GPIO clocks
  32         (##) Configure HCD pin-out
  33         (##) Configure HCD NVIC interrupt
  34
  35     (#)Associate the Upper USB Host stack to the HAL HCD Driver:
  36         (##) hhcd.pData = phost;
  37
  38     (#)Enable HCD transmission and reception:
  39         (##) HAL_HCD_Start();
  40
  41   @endverbatim
  42   ******************************************************************************
  43   * @attention
  44   *
  45   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
  46   *
  47   * Redistribution and use in source and binary forms, with or without modification,
  48   * are permitted provided that the following conditions are met:
  49   *   1. Redistributions of source code must retain the above copyright notice,
  50   *      this list of conditions and the following disclaimer.
  51   *   2. Redistributions in binary form must reproduce the above copyright notice,
  52   *      this list of conditions and the following disclaimer in the documentation
  53   *      and/or other materials provided with the distribution.
  54   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  55   *      may be used to endorse or promote products derived from this software
  56   *      without specific prior written permission.
  57   *
  58   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  59   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  60   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  61   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  62   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  63   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  64   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  65   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  66   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  67   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  68   *
  69   ******************************************************************************
  70   */
  71
  72 /* Includes ------------------------------------------------------------------*/
  73 #include "stm32f1xx_hal.h"
  74 /** @addtogroup STM32F1xx_HAL_Driver
  75   * @{
  76   */
  77
  78
  79 #ifdef HAL_HCD_MODULE_ENABLED
  80
  81 #if defined(STM32F105xC) || defined(STM32F107xC)
  82
  83 /** @defgroup HCD HCD
  84   * @brief HCD HAL module driver
  85   * @{
  86   */
  87
  88 /* Private types -------------------------------------------------------------*/
  89 /* Private variables ---------------------------------------------------------*/
  90 /* Private constants ---------------------------------------------------------*/
  91 /* Private macros ------------------------------------------------------------*/
  92 /* Private function ----------------------------------------------------------*/
  93 /** @defgroup HCD_Private_Functions HCD Private Functions
  94   * @{
  95   */
  96 static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
  97 static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
  98 static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd);
  99 static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd);
 100 /**
 101   * @}
 102   */
 103
 104 /* Exported functions --------------------------------------------------------*/
 105 /** @defgroup HCD_Exported_Functions HCD Exported Functions
 106   * @{
 107   */
 108
 109 /** @defgroup HCD_Exported_Functions_Group1 Initialization and de-initialization functions
 110  *  @brief    Initialization and Configuration functions
 111  *
 112 @verbatim
 113  ===============================================================================
 114           ##### Initialization and de-initialization functions #####
 115  ===============================================================================
 116     [..]  This section provides functions allowing to:
 117
 118 @endverbatim
 119   * @{
 120   */
 121
 122 /**
 123   * @brief  Initialize the host driver
 124   * @param  hhcd: HCD handle
 125   * @retval HAL status
 126   */
 127 HAL_StatusTypeDef HAL_HCD_Init(HCD_HandleTypeDef *hhcd)
 128 {
 129   /* Check the HCD handle allocation */
 130   if(hhcd == NULL)
 131   {
 132     return HAL_ERROR;
 133   }
 134
 135   /* Check the parameters */
 136   assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance));
 137
 138   if(hhcd->State == HAL_HCD_STATE_RESET)
 139   {
 140     /* Allocate lock resource and initialize it */
 141     hhcd->Lock = HAL_UNLOCKED;
 142
 143     /* Init the low level hardware : GPIO, CLOCK, NVIC... */
 144     HAL_HCD_MspInit(hhcd);
 145   }
 146
 147   hhcd->State = HAL_HCD_STATE_BUSY;
 148
 149   /* Disable the Interrupts */
 150   __HAL_HCD_DISABLE(hhcd);
 151
 152   /* Init the Core (common init.) */
 153   USB_CoreInit(hhcd->Instance, hhcd->Init);
 154
 155   /* Force Host Mode*/
 156   USB_SetCurrentMode(hhcd->Instance , USB_HOST_MODE);
 157
 158   /* Init Host */
 159   USB_HostInit(hhcd->Instance, hhcd->Init);
 160
 161   hhcd->State= HAL_HCD_STATE_READY;
 162
 163   return HAL_OK;
 164 }
 165
 166 /**
 167   * @brief  Initialize a host channel
 168   * @param  hhcd: HCD handle
 169   * @param  ch_num: Channel number.
 170   *         This parameter can be a value from 1 to 15
 171   * @param  epnum: Endpoint number.
 172   *          This parameter can be a value from 1 to 15
 173   * @param  dev_address : Current device address
 174   *          This parameter can be a value from 0 to 255
 175   * @param  speed: Current device speed.
 176   *          This parameter can be one of these values:
 177   *            HCD_SPEED_FULL: Full speed mode,
 178   *            HCD_SPEED_LOW: Low speed mode
 179   * @param  ep_type: Endpoint Type.
 180   *          This parameter can be one of these values:
 181   *            EP_TYPE_CTRL: Control type,
 182   *            EP_TYPE_ISOC: Isochronous type,
 183   *            EP_TYPE_BULK: Bulk type,
 184   *            EP_TYPE_INTR: Interrupt type
 185   * @param  mps: Max Packet Size.
 186   *          This parameter can be a value from 0 to32K
 187   * @retval HAL status
 188   */
 189 HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd,
 190                                   uint8_t ch_num,
 191                                   uint8_t epnum,
 192                                   uint8_t dev_address,
 193                                   uint8_t speed,
 194                                   uint8_t ep_type,
 195                                   uint16_t mps)
 196 {
 197   HAL_StatusTypeDef status = HAL_OK;
 198
 199   __HAL_LOCK(hhcd);
 200
 201   hhcd->hc[ch_num].dev_addr = dev_address;
 202   hhcd->hc[ch_num].max_packet = mps;
 203   hhcd->hc[ch_num].ch_num = ch_num;
 204   hhcd->hc[ch_num].ep_type = ep_type;
 205   hhcd->hc[ch_num].ep_num = epnum & 0x7FU;
 206   hhcd->hc[ch_num].ep_is_in = ((epnum & 0x80U) == 0x80U);
 207   hhcd->hc[ch_num].speed = speed;
 208
 209   status =  USB_HC_Init(hhcd->Instance,
 210                         ch_num,
 211                         epnum,
 212                         dev_address,
 213                         speed,
 214                         ep_type,
 215                         mps);
 216   __HAL_UNLOCK(hhcd);
 217
 218   return status;
 219 }
 220
 221 /**
 222   * @brief  Halt a host channel
 223   * @param  hhcd: HCD handle
 224   * @param  ch_num: Channel number.
 225   *         This parameter can be a value from 1 to 15
 226   * @retval HAL status
 227   */
 228 HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd,
 229                                   uint8_t ch_num)
 230 {
 231   __HAL_LOCK(hhcd);
 232   USB_HC_Halt(hhcd->Instance, ch_num);
 233   __HAL_UNLOCK(hhcd);
 234
 235   return HAL_OK;
 236 }
 237
 238 /**
 239   * @brief  DeInitialize the host driver
 240   * @param  hhcd: HCD handle
 241   * @retval HAL status
 242   */
 243 HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd)
 244 {
 245   /* Check the HCD handle allocation */
 246   if(hhcd == NULL)
 247   {
 248     return HAL_ERROR;
 249   }
 250
 251   hhcd->State = HAL_HCD_STATE_BUSY;
 252
 253   /* DeInit the low level hardware */
 254   HAL_HCD_MspDeInit(hhcd);
 255
 256   __HAL_HCD_DISABLE(hhcd);
 257
 258   hhcd->State = HAL_HCD_STATE_RESET;
 259
 260   return HAL_OK;
 261 }
 262
 263 /**
 264   * @brief  Initializes the HCD MSP.
 265   * @param  hhcd: HCD handle
 266   * @retval None
 267   */
 268 __weak void  HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd)
 269 {
 270   /* Prevent unused argument(s) compilation warning */
 271   UNUSED(hhcd);
 272   /* NOTE : This function Should not be modified, when the callback is needed,
 273             the HAL_HCD_MspInit could be implemented in the user file
 274    */
 275 }
 276
 277 /**
 278   * @brief  DeInitializes HCD MSP.
 279   * @param  hhcd: HCD handle
 280   * @retval None
 281   */
 282 __weak void  HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd)
 283 {
 284   /* Prevent unused argument(s) compilation warning */
 285   UNUSED(hhcd);
 286   /* NOTE : This function Should not be modified, when the callback is needed,
 287             the HAL_HCD_MspDeInit could be implemented in the user file
 288    */
 289 }
 290
 291 /**
 292   * @}
 293   */
 294
 295 /** @defgroup HCD_Exported_Functions_Group2 IO operation functions
 296   *  @brief   HCD IO operation functions
 297   *
 298 @verbatim
 299  ===============================================================================
 300                       ##### IO operation functions #####
 301  ===============================================================================
 302     This subsection provides a set of functions allowing to manage the USB Host Data
 303     Transfer
 304
 305 @endverbatim
 306   * @{
 307   */
 308
 309 /**
 310   * @brief  Submit a new URB for processing
 311   * @param  hhcd: HCD handle
 312   * @param  ch_num: Channel number.
 313   *         This parameter can be a value from 1 to 15
 314   * @param  direction: Channel number.
 315   *          This parameter can be one of these values:
 316   *           0 : Output / 1 : Input
 317   * @param  ep_type: Endpoint Type.
 318   *          This parameter can be one of these values:
 319   *            EP_TYPE_CTRL: Control type/
 320   *            EP_TYPE_ISOC: Isochronous type/
 321   *            EP_TYPE_BULK: Bulk type/
 322   *            EP_TYPE_INTR: Interrupt type/
 323   * @param  token: Endpoint Type.
 324   *          This parameter can be one of these values:
 325   *            0: HC_PID_SETUP / 1: HC_PID_DATA1
 326   * @param  pbuff: pointer to URB data
 327   * @param  length: Length of URB data
 328   * @param  do_ping: activate do ping protocol (for high speed only).
 329   *          This parameter can be one of these values:
 330   *           0 : do ping inactive / 1 : do ping active
 331   * @retval HAL status
 332   */
 333 HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd,
 334                                            uint8_t ch_num,
 335                                            uint8_t direction,
 336                                            uint8_t ep_type,
 337                                            uint8_t token,
 338                                            uint8_t* pbuff,
 339                                            uint16_t length,
 340                                            uint8_t do_ping)
 341 {
 342   hhcd->hc[ch_num].ep_is_in = direction;
 343   hhcd->hc[ch_num].ep_type  = ep_type;
 344
 345   if(token == 0U)
 346   {
 347     hhcd->hc[ch_num].data_pid = HC_PID_SETUP;
 348   }
 349   else
 350   {
 351     hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 352   }
 353
 354   /* Manage Data Toggle */
 355   switch(ep_type)
 356   {
 357   case EP_TYPE_CTRL:
 358     if((token == 1U) && (direction == 0U)) /*send data */
 359     {
 360       if (length == 0U)
 361       { /* For Status OUT stage, Length==0, Status Out PID = 1 */
 362         hhcd->hc[ch_num].toggle_out = 1U;
 363       }
 364
 365       /* Set the Data Toggle bit as per the Flag */
 366       if ( hhcd->hc[ch_num].toggle_out == 0U)
 367       { /* Put the PID 0 */
 368         hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 369       }
 370       else
 371       { /* Put the PID 1 */
 372         hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 373       }
 374       if(hhcd->hc[ch_num].urb_state  != URB_NOTREADY)
 375       {
 376         hhcd->hc[ch_num].do_ping = do_ping;
 377       }
 378     }
 379     break;
 380
 381   case EP_TYPE_BULK:
 382     if(direction == 0U)
 383     {
 384       /* Set the Data Toggle bit as per the Flag */
 385       if ( hhcd->hc[ch_num].toggle_out == 0U)
 386       { /* Put the PID 0 */
 387         hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 388       }
 389       else
 390       { /* Put the PID 1 */
 391         hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 392       }
 393       if(hhcd->hc[ch_num].urb_state  != URB_NOTREADY)
 394       {
 395         hhcd->hc[ch_num].do_ping = do_ping;
 396       }
 397     }
 398     else
 399     {
 400       if( hhcd->hc[ch_num].toggle_in == 0U)
 401       {
 402         hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 403       }
 404       else
 405       {
 406         hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 407       }
 408     }
 409     break;
 410
 411   case EP_TYPE_INTR:
 412     if(direction == 0U)
 413     {
 414       /* Set the Data Toggle bit as per the Flag */
 415       if ( hhcd->hc[ch_num].toggle_out == 0U)
 416       { /* Put the PID 0 */
 417         hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 418       }
 419       else
 420       { /* Put the PID 1 */
 421         hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 422       }
 423     }
 424     else
 425     {
 426       if( hhcd->hc[ch_num].toggle_in == 0U)
 427       {
 428         hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 429       }
 430       else
 431       {
 432         hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
 433       }
 434     }
 435     break;
 436
 437   case EP_TYPE_ISOC:
 438     hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
 439     break;
 440   }
 441
 442   hhcd->hc[ch_num].xfer_buff = pbuff;
 443   hhcd->hc[ch_num].xfer_len  = length;
 444   hhcd->hc[ch_num].urb_state = URB_IDLE;
 445   hhcd->hc[ch_num].xfer_count = 0U;
 446   hhcd->hc[ch_num].ch_num = ch_num;
 447   hhcd->hc[ch_num].state = HC_IDLE;
 448
 449   return USB_HC_StartXfer(hhcd->Instance, &(hhcd->hc[ch_num]));
 450 }
 451
 452 /**
 453   * @brief  handle HCD interrupt request.
 454   * @param  hhcd: HCD handle
 455   * @retval None
 456   */
 457 void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
 458 {
 459   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
 460
 461   uint32_t index = 0U, interrupt = 0U;
 462
 463   /* ensure that we are in device mode */
 464   if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
 465   {
 466     /* Avoid spurious interrupt */
 467     if(__HAL_HCD_IS_INVALID_INTERRUPT(hhcd))
 468     {
 469       return;
 470     }
 471
 472     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
 473     {
 474      /* Incorrect mode, acknowledge the interrupt */
 475       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
 476     }
 477
 478     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
 479     {
 480      /* Incorrect mode, acknowledge the interrupt */
 481       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
 482     }
 483
 484     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
 485     {
 486      /* Incorrect mode, acknowledge the interrupt */
 487       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
 488     }
 489
 490     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
 491     {
 492      /* Incorrect mode, acknowledge the interrupt */
 493       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
 494     }
 495
 496     /* Handle Host Disconnect Interrupts */
 497     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
 498     {
 499
 500       /* Cleanup HPRT */
 501       USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
 502         USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
 503
 504       /* Handle Host Port Interrupts */
 505       HAL_HCD_Disconnect_Callback(hhcd);
 506       USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ);
 507       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
 508     }
 509
 510     /* Handle Host Port Interrupts */
 511     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
 512     {
 513       HCD_Port_IRQHandler (hhcd);
 514     }
 515
 516     /* Handle Host SOF Interrupts */
 517     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
 518     {
 519       HAL_HCD_SOF_Callback(hhcd);
 520       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
 521     }
 522
 523     /* Handle Host channel Interrupts */
 524     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
 525     {
 526       interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
 527       for (index = 0U; index < hhcd->Init.Host_channels ; index++)
 528       {
 529         if (interrupt & (1 << index))
 530         {
 531           if ((USBx_HC(index)->HCCHAR) &  USB_OTG_HCCHAR_EPDIR)
 532           {
 533             HCD_HC_IN_IRQHandler (hhcd, index);
 534           }
 535           else
 536           {
 537             HCD_HC_OUT_IRQHandler (hhcd, index);
 538           }
 539         }
 540       }
 541       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
 542     }
 543
 544     /* Handle Rx Queue Level Interrupts */
 545     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL))
 546     {
 547       USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
 548
 549       HCD_RXQLVL_IRQHandler (hhcd);
 550
 551       USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
 552     }
 553   }
 554 }
 555
 556 /**
 557   * @brief  SOF callback.
 558   * @param  hhcd: HCD handle
 559   * @retval None
 560   */
 561 __weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd)
 562 {
 563   /* Prevent unused argument(s) compilation warning */
 564   UNUSED(hhcd);
 565   /* NOTE : This function Should not be modified, when the callback is needed,
 566             the HAL_HCD_SOF_Callback could be implemented in the user file
 567    */
 568 }
 569
 570 /**
 571   * @brief Connexion Event callback.
 572   * @param  hhcd: HCD handle
 573   * @retval None
 574   */
 575 __weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd)
 576 {
 577   /* Prevent unused argument(s) compilation warning */
 578   UNUSED(hhcd);
 579   /* NOTE : This function Should not be modified, when the callback is needed,
 580             the HAL_HCD_Connect_Callback could be implemented in the user file
 581    */
 582 }
 583
 584 /**
 585   * @brief  Disonnection Event callback.
 586   * @param  hhcd: HCD handle
 587   * @retval None
 588   */
 589 __weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd)
 590 {
 591   /* Prevent unused argument(s) compilation warning */
 592   UNUSED(hhcd);
 593   /* NOTE : This function Should not be modified, when the callback is needed,
 594             the HAL_HCD_Disconnect_Callback could be implemented in the user file
 595    */
 596 }
 597
 598 /**
 599   * @brief  Notify URB state change callback.
 600   * @param  hhcd: HCD handle
 601   * @param  chnum: Channel number.
 602   *         This parameter can be a value from 1 to 15
 603   * @param  urb_state:
 604   *          This parameter can be one of these values:
 605   *            URB_IDLE/
 606   *            URB_DONE/
 607   *            URB_NOTREADY/
 608   *            URB_NYET/
 609   *            URB_ERROR/
 610   *            URB_STALL/
 611   * @retval None
 612   */
 613 __weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
 614 {
 615   /* Prevent unused argument(s) compilation warning */
 616   UNUSED(hhcd);
 617   UNUSED(chnum);
 618   UNUSED(urb_state);
 619   /* NOTE : This function Should not be modified, when the callback is needed,
 620             the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file
 621    */
 622 }
 623
 624 /**
 625   * @}
 626   */
 627
 628 /** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions
 629  *  @brief   management functions
 630  *
 631 @verbatim
 632  ===============================================================================
 633                       ##### Peripheral Control functions #####
 634  ===============================================================================
 635     [..]
 636     This subsection provides a set of functions allowing to control the HCD data
 637     transfers.
 638
 639 @endverbatim
 640   * @{
 641   */
 642
 643 /**
 644   * @brief  Start the host driver
 645   * @param  hhcd: HCD handle
 646   * @retval HAL status
 647   */
 648 HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd)
 649 {
 650   __HAL_LOCK(hhcd);
 651   __HAL_HCD_ENABLE(hhcd);
 652   USB_DriveVbus(hhcd->Instance, 1U);
 653   __HAL_UNLOCK(hhcd);
 654   return HAL_OK;
 655 }
 656
 657 /**
 658   * @brief  Stop the host driver
 659   * @param  hhcd: HCD handle
 660   * @retval HAL status
 661   */
 662
 663 HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd)
 664 {
 665   __HAL_LOCK(hhcd);
 666   USB_StopHost(hhcd->Instance);
 667   __HAL_UNLOCK(hhcd);
 668   return HAL_OK;
 669 }
 670
 671 /**
 672   * @brief  Reset the host port
 673   * @param  hhcd: HCD handle
 674   * @retval HAL status
 675   */
 676 HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd)
 677 {
 678   return (USB_ResetPort(hhcd->Instance));
 679 }
 680
 681 /**
 682   * @}
 683   */
 684
 685 /** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions
 686  *  @brief   Peripheral State functions
 687  *
 688 @verbatim
 689  ===============================================================================
 690                       ##### Peripheral State functions #####
 691  ===============================================================================
 692     [..]
 693     This subsection permits to get in run-time the status of the peripheral
 694     and the data flow.
 695
 696 @endverbatim
 697   * @{
 698   */
 699
 700 /**
 701   * @brief  Return the HCD handle state
 702   * @param  hhcd: HCD handle
 703   * @retval HAL state
 704   */
 705 HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef *hhcd)
 706 {
 707   return hhcd->State;
 708 }
 709
 710 /**
 711   * @brief  Return  URB state for a channel
 712   * @param  hhcd: HCD handle
 713   * @param  chnum: Channel number.
 714   *         This parameter can be a value from 1 to 15
 715   * @retval URB state.
 716   *          This parameter can be one of these values:
 717   *            URB_IDLE/
 718   *            URB_DONE/
 719   *            URB_NOTREADY/
 720   *            URB_NYET/
 721   *            URB_ERROR/
 722   *            URB_STALL/
 723   */
 724 HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
 725 {
 726   return hhcd->hc[chnum].urb_state;
 727 }
 728
 729
 730 /**
 731   * @brief  Return the last host transfer size
 732   * @param  hhcd: HCD handle
 733   * @param  chnum: Channel number.
 734   *         This parameter can be a value from 1 to 15
 735   * @retval last transfer size in byte
 736   */
 737 uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef *hhcd, uint8_t chnum)
 738 {
 739   return hhcd->hc[chnum].xfer_count;
 740 }
 741
 742 /**
 743   * @brief  Return the Host Channel state
 744   * @param  hhcd: HCD handle
 745   * @param  chnum: Channel number.
 746   *         This parameter can be a value from 1 to 15
 747   * @retval Host channel state
 748   *          This parameter can be one of the these values:
 749   *            HC_IDLE/
 750   *            HC_XFRC/
 751   *            HC_HALTED/
 752   *            HC_NYET/
 753   *            HC_NAK/
 754   *            HC_STALL/
 755   *            HC_XACTERR/
 756   *            HC_BBLERR/
 757   *            HC_DATATGLERR/
 758   */
 759 HCD_HCStateTypeDef  HAL_HCD_HC_GetState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
 760 {
 761   return hhcd->hc[chnum].state;
 762 }
 763
 764 /**
 765   * @brief  Return the current Host frame number
 766   * @param  hhcd: HCD handle
 767   * @retval Current Host frame number
 768   */
 769 uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd)
 770 {
 771   return (USB_GetCurrentFrame(hhcd->Instance));
 772 }
 773
 774 /**
 775   * @brief  Return the Host enumeration speed
 776   * @param  hhcd: HCD handle
 777   * @retval Enumeration speed
 778   */
 779 uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd)
 780 {
 781   return (USB_GetHostSpeed(hhcd->Instance));
 782 }
 783
 784 /**
 785   * @}
 786   */
 787 /**
 788   * @}
 789   */
 790
 791 /** @addtogroup HCD_Private_Functions
 792   * @{
 793   */
 794 /**
 795   * @brief  This function handles Host Channel IN interrupt requests.
 796   * @param  hhcd: HCD handle
 797   * @param  chnum: Channel number.
 798   *         This parameter can be a value from 1 to 15
 799   * @retval none
 800   */
 801 static void HCD_HC_IN_IRQHandler (HCD_HandleTypeDef *hhcd, uint8_t chnum)
 802 {
 803   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
 804   uint32_t tmpreg = 0U;
 805
 806   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_AHBERR)
 807   {
 808     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
 809     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 810   }
 811   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_ACK)
 812   {
 813     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
 814   }
 815
 816   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_STALL)
 817   {
 818     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 819     hhcd->hc[chnum].state = HC_STALL;
 820     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
 821     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);
 822     USB_HC_Halt(hhcd->Instance, chnum);
 823   }
 824   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_DTERR)
 825   {
 826     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 827     USB_HC_Halt(hhcd->Instance, chnum);
 828     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
 829     hhcd->hc[chnum].state = HC_DATATGLERR;
 830     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);
 831   }
 832
 833   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_FRMOR)
 834   {
 835     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 836     USB_HC_Halt(hhcd->Instance, chnum);
 837     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
 838   }
 839
 840   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_XFRC)
 841   {
 842     hhcd->hc[chnum].state = HC_XFRC;
 843     hhcd->hc[chnum].ErrCnt = 0U;
 844     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
 845
 846     if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)||
 847         (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
 848     {
 849       __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 850       USB_HC_Halt(hhcd->Instance, chnum);
 851       __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
 852
 853     }
 854     else if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR)
 855     {
 856       USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
 857       hhcd->hc[chnum].urb_state = URB_DONE;
 858       HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
 859     }
 860     hhcd->hc[chnum].toggle_in ^= 1U;
 861
 862   }
 863   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_CHH)
 864   {
 865     __HAL_HCD_MASK_HALT_HC_INT(chnum);
 866
 867     if(hhcd->hc[chnum].state == HC_XFRC)
 868     {
 869       hhcd->hc[chnum].urb_state  = URB_DONE;
 870     }
 871     else if (hhcd->hc[chnum].state == HC_STALL)
 872     {
 873       hhcd->hc[chnum].urb_state  = URB_STALL;
 874     }
 875     else if((hhcd->hc[chnum].state == HC_XACTERR) ||
 876             (hhcd->hc[chnum].state == HC_DATATGLERR))
 877     {
 878       if(hhcd->hc[chnum].ErrCnt++ > 3U)
 879       {
 880         hhcd->hc[chnum].ErrCnt = 0U;
 881         hhcd->hc[chnum].urb_state = URB_ERROR;
 882       }
 883       else
 884       {
 885         hhcd->hc[chnum].urb_state = URB_NOTREADY;
 886       }
 887
 888       /* re-activate the channel  */
 889       tmpreg = USBx_HC(chnum)->HCCHAR;
 890       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
 891       tmpreg |= USB_OTG_HCCHAR_CHENA;
 892       USBx_HC(chnum)->HCCHAR = tmpreg;
 893     }
 894     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
 895     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
 896   }
 897
 898   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_TXERR)
 899   {
 900     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 901      hhcd->hc[chnum].ErrCnt++;
 902      hhcd->hc[chnum].state = HC_XACTERR;
 903      USB_HC_Halt(hhcd->Instance, chnum);
 904      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
 905   }
 906   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NAK)
 907   {
 908     if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR)
 909     {
 910       __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 911       USB_HC_Halt(hhcd->Instance, chnum);
 912     }
 913     else if  ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)||
 914               (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
 915     {
 916       /* re-activate the channel  */
 917       tmpreg = USBx_HC(chnum)->HCCHAR;
 918       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
 919       tmpreg |= USB_OTG_HCCHAR_CHENA;
 920       USBx_HC(chnum)->HCCHAR = tmpreg;
 921     }
 922     hhcd->hc[chnum].state = HC_NAK;
 923      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
 924   }
 925 }
 926
 927 /**
 928   * @brief  This function handles Host Channel OUT interrupt requests.
 929   * @param  hhcd: HCD handle
 930   * @param  chnum: Channel number.
 931   *         This parameter can be a value from 1 to 15
 932   * @retval none
 933   */
 934 static void HCD_HC_OUT_IRQHandler (HCD_HandleTypeDef *hhcd, uint8_t chnum)
 935 {
 936   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
 937   uint32_t tmpreg = 0U;
 938
 939   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_AHBERR)
 940   {
 941     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
 942     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 943   }
 944   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_ACK)
 945   {
 946     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
 947
 948     if( hhcd->hc[chnum].do_ping == 1U)
 949     {
 950       hhcd->hc[chnum].state = HC_NYET;
 951       __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 952       USB_HC_Halt(hhcd->Instance, chnum);
 953       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
 954     }
 955   }
 956
 957   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NYET)
 958   {
 959     hhcd->hc[chnum].state = HC_NYET;
 960     hhcd->hc[chnum].ErrCnt= 0U;
 961     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 962     USB_HC_Halt(hhcd->Instance, chnum);
 963     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NYET);
 964
 965   }
 966
 967   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_FRMOR)
 968   {
 969     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 970     USB_HC_Halt(hhcd->Instance, chnum);
 971     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
 972   }
 973
 974   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_XFRC)
 975   {
 976     hhcd->hc[chnum].ErrCnt = 0U;
 977     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 978     USB_HC_Halt(hhcd->Instance, chnum);
 979     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
 980     hhcd->hc[chnum].state = HC_XFRC;
 981   }
 982   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_STALL)
 983   {
 984     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);
 985     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 986     USB_HC_Halt(hhcd->Instance, chnum);
 987     hhcd->hc[chnum].state = HC_STALL;
 988   }
 989   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NAK)
 990   {
 991     hhcd->hc[chnum].ErrCnt = 0U;
 992     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
 993     USB_HC_Halt(hhcd->Instance, chnum);
 994     hhcd->hc[chnum].state = HC_NAK;
 995     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
 996   }
 997   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_TXERR)
 998   {
 999     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
1000     USB_HC_Halt(hhcd->Instance, chnum);
1001     hhcd->hc[chnum].state = HC_XACTERR;
1002      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
1003   }
1004   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_DTERR)
1005   {
1006     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
1007     USB_HC_Halt(hhcd->Instance, chnum);
1008     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
1009     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);
1010     hhcd->hc[chnum].state = HC_DATATGLERR;
1011   }
1012   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_CHH)
1013   {
1014     __HAL_HCD_MASK_HALT_HC_INT(chnum);
1015
1016     if(hhcd->hc[chnum].state == HC_XFRC)
1017     {
1018       hhcd->hc[chnum].urb_state  = URB_DONE;
1019       if (hhcd->hc[chnum].ep_type == EP_TYPE_BULK)
1020       {
1021         hhcd->hc[chnum].toggle_out ^= 1U;
1022       }
1023     }
1024     else if (hhcd->hc[chnum].state == HC_NAK)
1025     {
1026       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
1027     }
1028     else if (hhcd->hc[chnum].state == HC_NYET)
1029     {
1030       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
1031       hhcd->hc[chnum].do_ping = 0U;
1032     }
1033     else if (hhcd->hc[chnum].state == HC_STALL)
1034     {
1035       hhcd->hc[chnum].urb_state  = URB_STALL;
1036     }
1037     else if((hhcd->hc[chnum].state == HC_XACTERR) ||
1038             (hhcd->hc[chnum].state == HC_DATATGLERR))
1039     {
1040       if(hhcd->hc[chnum].ErrCnt++ > 3U)
1041       {
1042         hhcd->hc[chnum].ErrCnt = 0U;
1043         hhcd->hc[chnum].urb_state = URB_ERROR;
1044       }
1045       else
1046       {
1047         hhcd->hc[chnum].urb_state = URB_NOTREADY;
1048       }
1049
1050       /* re-activate the channel  */
1051       tmpreg = USBx_HC(chnum)->HCCHAR;
1052       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
1053       tmpreg |= USB_OTG_HCCHAR_CHENA;
1054       USBx_HC(chnum)->HCCHAR = tmpreg;
1055     }
1056
1057     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
1058     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
1059   }
1060 }
1061
1062 /**
1063   * @brief  This function handles Rx Queue Level interrupt requests.
1064   * @param  hhcd: HCD handle
1065   * @retval none
1066   */
1067 static void HCD_RXQLVL_IRQHandler  (HCD_HandleTypeDef *hhcd)
1068 {
1069   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
1070   uint8_t                       channelnum =0U;
1071   uint32_t                      pktsts;
1072   uint32_t                      pktcnt;
1073   uint32_t                      temp = 0U;
1074   uint32_t tmpreg = 0U;
1075
1076   temp = hhcd->Instance->GRXSTSP;
1077   channelnum = temp &  USB_OTG_GRXSTSP_EPNUM;
1078   pktsts = (temp &  USB_OTG_GRXSTSP_PKTSTS) >> 17U;
1079   pktcnt = (temp &  USB_OTG_GRXSTSP_BCNT) >> 4U;
1080
1081   switch (pktsts)
1082   {
1083   case GRXSTS_PKTSTS_IN:
1084     /* Read the data into the host buffer. */
1085     if ((pktcnt > 0U) && (hhcd->hc[channelnum].xfer_buff != (void  *)0U))
1086     {
1087       USB_ReadPacket(hhcd->Instance, hhcd->hc[channelnum].xfer_buff, pktcnt);
1088
1089       /*manage multiple Xfer */
1090       hhcd->hc[channelnum].xfer_buff += pktcnt;
1091       hhcd->hc[channelnum].xfer_count  += pktcnt;
1092
1093       if((USBx_HC(channelnum)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) > 0U)
1094       {
1095         /* re-activate the channel when more packets are expected */
1096         tmpreg = USBx_HC(channelnum)->HCCHAR;
1097         tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
1098         tmpreg |= USB_OTG_HCCHAR_CHENA;
1099         USBx_HC(channelnum)->HCCHAR = tmpreg;
1100         hhcd->hc[channelnum].toggle_in ^= 1U;
1101       }
1102     }
1103     break;
1104
1105   case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
1106     break;
1107
1108   case GRXSTS_PKTSTS_IN_XFER_COMP:
1109   case GRXSTS_PKTSTS_CH_HALTED:
1110   default:
1111     break;
1112   }
1113 }
1114
1115 /**
1116   * @brief  This function handles Host Port interrupt requests.
1117   * @param  hhcd: HCD handle
1118   * @retval None
1119   */
1120 static void HCD_Port_IRQHandler (HCD_HandleTypeDef *hhcd)
1121 {
1122   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
1123   __IO uint32_t hprt0 = 0, hprt0_dup = 0U;
1124
1125   /* Handle Host Port Interrupts */
1126   hprt0 = USBx_HPRT0;
1127   hprt0_dup = USBx_HPRT0;
1128
1129   hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
1130                  USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
1131
1132   /* Check whether Port Connect Detected */
1133   if((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
1134   {
1135     if((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
1136     {
1137       USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT);
1138       HAL_HCD_Connect_Callback(hhcd);
1139     }
1140     hprt0_dup  |= USB_OTG_HPRT_PCDET;
1141   }
1142
1143   /* Check whether Port Enable Changed */
1144   if((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
1145   {
1146     hprt0_dup |= USB_OTG_HPRT_PENCHNG;
1147
1148     if((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
1149     {
1150       if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17U))
1151       {
1152         USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_6_MHZ );
1153       }
1154       else
1155       {
1156         USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ );
1157       }
1158       HAL_HCD_Connect_Callback(hhcd);
1159     }
1160     else
1161     {
1162       /* Cleanup HPRT */
1163       USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
1164         USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
1165
1166       USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT);
1167     }
1168   }
1169
1170   /* Check For an over current */
1171   if((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
1172   {
1173     hprt0_dup |= USB_OTG_HPRT_POCCHNG;
1174   }
1175
1176   /* Clear Port Interrupts */
1177   USBx_HPRT0 = hprt0_dup;
1178 }
1179
1180 /**
1181   * @}
1182   */
1183
1184 /**
1185   * @}
1186   */
1187
1188 #endif /* STM32F105xC || STM32F107xC */
1189
1190 #endif /* HAL_HCD_MODULE_ENABLED */
1191
1192 /**
1193   * @}
1194   */
1195
1196 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/