USBHALHost2_F401RE.cpp

00001 #if defined(TARGET_NUCLEO_F401RE)||defined(TARGET_NUCLEO_F411RE)||defined(TARGET_NUCLEO_F446RE)
00002 #include "USBHALHost.h"
00003 
00004 // usbh_conf.c
00005 HCD_HandleTypeDef hhcd_USB_OTG_FS;
00006 
00007 static void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd);
00008 
00009 // stm32f4xx_it.c
00010 extern "C" {
00011 void OTG_FS_IRQHandler(void)
00012 {
00013   HAL_NVIC_ClearPendingIRQ(OTG_FS_IRQn);
00014   HAL_HCD_IRQHandler(&hhcd_USB_OTG_FS);
00015 }
00016 }
00017 
00018 // stm32f4xx_hal_hcd.c
00019 static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
00020 static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum); 
00021 static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd);
00022 static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd);
00023 
00024 /**
00025   * @brief  This function handles HCD interrupt request.
00026   * @param  hhcd: HCD handle
00027   * @retval none
00028   */
00029 static void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
00030 {
00031   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
00032   uint32_t i = 0 , interrupt = 0;
00033   
00034   /* ensure that we are in device mode */
00035   if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
00036   {
00037     /* avoid spurious interrupt */
00038     if(__HAL_HCD_IS_INVALID_INTERRUPT(hhcd)) 
00039     {
00040       return;
00041     }
00042     
00043     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
00044     {
00045      /* incorrect mode, acknowledge the interrupt */
00046       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
00047     }
00048     
00049     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
00050     {
00051      /* incorrect mode, acknowledge the interrupt */
00052       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
00053     }
00054 
00055     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
00056     {
00057      /* incorrect mode, acknowledge the interrupt */
00058       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
00059     }   
00060     
00061     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
00062     {
00063      /* incorrect mode, acknowledge the interrupt */
00064       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
00065     }     
00066     
00067     /* Handle Host Disconnect Interrupts */
00068     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
00069     {
00070       
00071       /* Cleanup HPRT */
00072       USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
00073         USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
00074        
00075       /* Handle Host Port Interrupts */
00076       HAL_HCD_Disconnect_Callback(hhcd);
00077        USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ );
00078       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
00079     }
00080     
00081     /* Handle Host Port Interrupts */
00082     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
00083     {
00084       HCD_Port_IRQHandler (hhcd);
00085     }
00086     
00087     /* Handle Host SOF Interrupts */
00088     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
00089     {
00090       HAL_HCD_SOF_Callback(hhcd);
00091       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
00092     }
00093           
00094     /* Handle Host channel Interrupts */
00095     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
00096     {
00097       
00098       interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
00099       for (i = 0; i < hhcd->Init.Host_channels ; i++)
00100       {
00101         if (interrupt & (1 << i))
00102         {
00103           if ((USBx_HC(i)->HCCHAR) &  USB_OTG_HCCHAR_EPDIR)
00104           {
00105             HCD_HC_IN_IRQHandler (hhcd, i);
00106           }
00107           else
00108           {
00109             HCD_HC_OUT_IRQHandler (hhcd, i);
00110           }
00111         }
00112       }
00113       __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
00114     } 
00115     
00116         /* Handle Rx Queue Level Interrupts */
00117     if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL))
00118     {
00119       USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
00120       
00121       HCD_RXQLVL_IRQHandler (hhcd);
00122       
00123       USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
00124     }
00125     
00126   }
00127 }
00128 /**
00129   * @brief  This function handles Host Channel IN interrupt requests.
00130   * @param  hhcd: HCD handle
00131   * @param  chnum : Channel number
00132   *         This parameter can be a value from 1 to 15
00133   * @retval none
00134   */
00135 static void HCD_HC_IN_IRQHandler   (HCD_HandleTypeDef *hhcd, uint8_t chnum)
00136 {
00137   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
00138     
00139   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_AHBERR)
00140   {
00141     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
00142     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00143   }  
00144   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_ACK)
00145   {
00146     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
00147   }
00148   
00149   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_STALL)  
00150   {
00151     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00152     hhcd->hc[chnum].state = HC_STALL;
00153     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00154     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);    
00155     USB_HC_Halt(hhcd->Instance, chnum);    
00156   }
00157   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_DTERR)
00158   {
00159     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00160     USB_HC_Halt(hhcd->Instance, chnum);  
00161     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);    
00162     hhcd->hc[chnum].state = HC_DATATGLERR;
00163     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);
00164   }    
00165   
00166   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_FRMOR)
00167   {
00168     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00169     USB_HC_Halt(hhcd->Instance, chnum);  
00170     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
00171   }
00172   
00173   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_XFRC)
00174   {
00175     
00176     if (hhcd->Init.dma_enable)
00177     {
00178       hhcd->hc[chnum].xfer_count = hhcd->hc[chnum].xfer_len - \
00179                                (USBx_HC(chnum)->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ);
00180     }
00181     
00182     hhcd->hc[chnum].state = HC_XFRC;
00183     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
00184     
00185     
00186     if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)||
00187         (hhcd->hc[chnum].ep_type == EP_TYPE_BULK))
00188     {
00189       __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00190       USB_HC_Halt(hhcd->Instance, chnum); 
00191       __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00192       
00193     }
00194     else if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR)
00195     {
00196       USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
00197       __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00198       USB_HC_Halt(hhcd->Instance, chnum); 
00199       __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00200     }
00201     else if(hhcd->hc[chnum].ep_type == EP_TYPE_ISOC)
00202     {
00203       USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
00204       hhcd->hc[chnum].urb_state = URB_DONE; 
00205       HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
00206     }
00207     hhcd->hc[chnum].toggle_in ^= 1;
00208     
00209   }
00210   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_CHH)
00211   {
00212     __HAL_HCD_MASK_HALT_HC_INT(chnum); 
00213     
00214     if(hhcd->hc[chnum].state == HC_XFRC)
00215     {
00216       hhcd->hc[chnum].urb_state  = URB_DONE;      
00217     }
00218 
00219     else if (hhcd->hc[chnum].state == HC_NAK)
00220     {
00221       hhcd->hc[chnum].urb_state  = URB_DONE;
00222     }
00223     
00224     else if (hhcd->hc[chnum].state == HC_STALL) 
00225     {
00226       hhcd->hc[chnum].urb_state  = URB_STALL;
00227     }   
00228     
00229     else if (hhcd->hc[chnum].state == HC_XACTERR)
00230     {
00231         hhcd->hc[chnum].urb_state = URB_NOTREADY;
00232     }
00233 
00234     else if (hhcd->hc[chnum].state == HC_DATATGLERR)
00235     {
00236         hhcd->hc[chnum].urb_state = URB_ERROR;
00237     }
00238 
00239     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
00240     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);
00241   }  
00242   
00243   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_TXERR)
00244   {
00245     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00246      hhcd->hc[chnum].state = HC_XACTERR;
00247      USB_HC_Halt(hhcd->Instance, chnum);     
00248      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
00249   }
00250   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NAK)
00251   {  
00252     if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR)
00253     {
00254       __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00255       USB_HC_Halt(hhcd->Instance, chnum);  
00256     }
00257     else if (hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)
00258     {
00259       /* re-activate the channel  */
00260       USBx_HC(chnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHDIS;         
00261       USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
00262    
00263     }
00264     
00265     else if (hhcd->hc[chnum].ep_type == EP_TYPE_BULK)
00266     {
00267       __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00268       USB_HC_Halt(hhcd->Instance, chnum); 
00269     }
00270 
00271     hhcd->hc[chnum].state = HC_NAK;
00272      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00273   }
00274 }
00275 
00276 /**
00277   * @brief  This function handles Host Channel OUT interrupt requests.
00278   * @param  hhcd: HCD handle
00279   * @param  chnum : Channel number
00280   *         This parameter can be a value from 1 to 15
00281   * @retval none
00282   */
00283 static void HCD_HC_OUT_IRQHandler  (HCD_HandleTypeDef *hhcd, uint8_t chnum)
00284 {
00285   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
00286   
00287   if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_AHBERR)
00288   {
00289     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR);
00290     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00291   }  
00292   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_ACK)
00293   {
00294     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK);
00295     
00296     if( hhcd->hc[chnum].do_ping == 1)
00297     {
00298       hhcd->hc[chnum].state = HC_NYET;     
00299       __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00300       USB_HC_Halt(hhcd->Instance, chnum); 
00301       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
00302     }
00303   }
00304   
00305   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NYET)
00306   {
00307     hhcd->hc[chnum].state = HC_NYET;
00308     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00309     USB_HC_Halt(hhcd->Instance, chnum);      
00310     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NYET);
00311     
00312   }  
00313   
00314   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_FRMOR)
00315   {
00316     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00317     USB_HC_Halt(hhcd->Instance, chnum);  
00318     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR);
00319   }
00320   
00321   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_XFRC)
00322   {
00323     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00324     USB_HC_Halt(hhcd->Instance, chnum);   
00325     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC);
00326     hhcd->hc[chnum].state = HC_XFRC;
00327 
00328   }  
00329 
00330   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_STALL)  
00331   {
00332     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL);  
00333     __HAL_HCD_UNMASK_HALT_HC_INT(chnum);
00334     USB_HC_Halt(hhcd->Instance, chnum);   
00335     hhcd->hc[chnum].state = HC_STALL;    
00336   }
00337 
00338   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_NAK)
00339   {  
00340     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00341     USB_HC_Halt(hhcd->Instance, chnum);   
00342     hhcd->hc[chnum].state = HC_NAK;
00343     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00344   }
00345 
00346   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_TXERR)
00347   {
00348     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00349     USB_HC_Halt(hhcd->Instance, chnum);      
00350     hhcd->hc[chnum].state = HC_XACTERR;  
00351      __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR);
00352   }
00353   
00354   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_DTERR)
00355   {
00356     __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 
00357     USB_HC_Halt(hhcd->Instance, chnum);      
00358     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK);
00359     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR);    
00360     hhcd->hc[chnum].state = HC_DATATGLERR;
00361   }
00362   
00363   
00364   else if ((USBx_HC(chnum)->HCINT) &  USB_OTG_HCINT_CHH)
00365   {
00366     __HAL_HCD_MASK_HALT_HC_INT(chnum); 
00367     
00368     if(hhcd->hc[chnum].state == HC_XFRC)
00369     {
00370       hhcd->hc[chnum].urb_state  = URB_DONE;
00371       if (hhcd->hc[chnum].ep_type == EP_TYPE_BULK)
00372       {
00373         hhcd->hc[chnum].toggle_out ^= 1; 
00374       }      
00375     }
00376     else if (hhcd->hc[chnum].state == HC_NAK) 
00377     {
00378       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
00379     }  
00380     
00381     else if (hhcd->hc[chnum].state == HC_NYET) 
00382     {
00383       hhcd->hc[chnum].urb_state  = URB_NOTREADY;
00384       hhcd->hc[chnum].do_ping = 0;
00385     }   
00386     
00387     else if (hhcd->hc[chnum].state == HC_STALL) 
00388     {
00389       hhcd->hc[chnum].urb_state  = URB_STALL;
00390     } 
00391     
00392     else if(hhcd->hc[chnum].state == HC_XACTERR)
00393     {
00394       hhcd->hc[chnum].urb_state = URB_NOTREADY;
00395     }
00396     
00397     else if (hhcd->hc[chnum].state == HC_DATATGLERR)
00398     {
00399       hhcd->hc[chnum].urb_state = URB_ERROR;
00400     }
00401 
00402     __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH);
00403     HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state);  
00404   }
00405 } 
00406 
00407 /**
00408   * @brief  This function handles Rx Queue Level interrupt requests.
00409   * @param  hhcd: HCD handle
00410   * @retval none
00411   */
00412 static void HCD_RXQLVL_IRQHandler  (HCD_HandleTypeDef *hhcd)
00413 {
00414   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;  
00415   uint8_t                       channelnum =0;  
00416   uint32_t                      pktsts;
00417   uint32_t                      pktcnt; 
00418   uint32_t                      temp = 0;
00419   
00420   temp = hhcd->Instance->GRXSTSP ;
00421   channelnum = temp &  USB_OTG_GRXSTSP_EPNUM;  
00422   pktsts = (temp &  USB_OTG_GRXSTSP_PKTSTS) >> 17;
00423   pktcnt = (temp &  USB_OTG_GRXSTSP_BCNT) >> 4;
00424     
00425   switch (pktsts)
00426   {
00427   case GRXSTS_PKTSTS_IN:
00428     /* Read the data into the host buffer. */
00429     if ((pktcnt > 0) && (hhcd->hc[channelnum].xfer_buff != (void  *)0))
00430     {  
00431       
00432       USB_ReadPacket(hhcd->Instance, hhcd->hc[channelnum].xfer_buff, pktcnt);
00433      
00434       /*manage multiple Xfer */
00435       hhcd->hc[channelnum].xfer_buff += pktcnt;           
00436       hhcd->hc[channelnum].xfer_count  += pktcnt;
00437         
00438       if((USBx_HC(channelnum)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) > 0)
00439       {
00440         /* re-activate the channel when more packets are expected */
00441         USBx_HC(channelnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHDIS; 
00442         USBx_HC(channelnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
00443         hhcd->hc[channelnum].toggle_in ^= 1;
00444       }
00445     }
00446     break;
00447 
00448   case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
00449     break;
00450   case GRXSTS_PKTSTS_IN_XFER_COMP:
00451   case GRXSTS_PKTSTS_CH_HALTED:
00452   default:
00453     break;
00454   }
00455 }
00456 
00457 /**
00458   * @brief  This function handles Host Port interrupt requests.
00459   * @param  hhcd: HCD handle
00460   * @retval none
00461   */
00462 static void HCD_Port_IRQHandler  (HCD_HandleTypeDef *hhcd)
00463 {
00464   USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;  
00465   __IO uint32_t hprt0, hprt0_dup;
00466   
00467   /* Handle Host Port Interrupts */
00468   hprt0 = USBx_HPRT0;
00469   hprt0_dup = USBx_HPRT0;
00470   
00471   hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
00472                  USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
00473   
00474   /* Check wether Port Connect Detected */
00475   if((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
00476   {  
00477     if((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
00478     {
00479       USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT);
00480       HAL_HCD_Connect_Callback(hhcd);
00481     }
00482     hprt0_dup  |= USB_OTG_HPRT_PCDET;
00483     
00484   }
00485   
00486   /* Check whether Port Enable Changed */
00487   if((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
00488   {
00489     hprt0_dup |= USB_OTG_HPRT_PENCHNG;
00490     
00491     if((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
00492     {    
00493       if(hhcd->Init.phy_itface  == USB_OTG_EMBEDDED_PHY)
00494       {
00495         if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17))
00496         {
00497           USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_6_MHZ );
00498         }
00499         else
00500         {
00501           USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ );
00502         }
00503       }
00504       else
00505       {
00506         if(hhcd->Init.speed == HCD_SPEED_FULL)
00507         {
00508           USBx_HOST->HFIR = (uint32_t)60000;
00509         }
00510       }
00511       HAL_HCD_Connect_Callback(hhcd);
00512       
00513       if(hhcd->Init.speed == HCD_SPEED_HIGH)
00514       {
00515         USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT); 
00516       }
00517     }
00518     else
00519     {
00520       /* Cleanup HPRT */
00521       USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\
00522         USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG );
00523       
00524       USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT); 
00525     }    
00526   }
00527   
00528   /* Check For an overcurrent */
00529   if((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
00530   {
00531     hprt0_dup |= USB_OTG_HPRT_POCCHNG;
00532   }
00533 
00534   /* Clear Port Interrupts */
00535   USBx_HPRT0 = hprt0_dup;
00536 }
00537 
00538 #endif
00539