Simple USBHost library for Nucleo F446RE/F411RE/F401RE FRDM-KL46Z/KL25Z/F64F LPC4088/LPC1768
Dependents: F401RE-BTstack_example F401RE-USBHostMSD_HelloWorld
Fork of KL46Z-USBHost by
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
Generated on Wed Jul 13 2022 05:41:27 by 1.7.2