USBHALHost2_F401RE.cpp

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