TUKS MCU Introductory course
/
TUKS-COURSE-2-LED
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Embed:
(wiki syntax)
Show/hide line numbers
stm32l4xx_hal_hcd.c
Go to the documentation of this file.
00001 /** 00002 ****************************************************************************** 00003 * @file stm32l4xx_hal_hcd.c 00004 * @author MCD Application Team 00005 * @version V1.5.1 00006 * @date 31-May-2016 00007 * @brief HCD HAL module driver. 00008 * This file provides firmware functions to manage the following 00009 * functionalities of the USB Peripheral Controller: 00010 * + Initialization and de-initialization functions 00011 * + IO operation functions 00012 * + Peripheral Control functions 00013 * + Peripheral State functions 00014 * 00015 @verbatim 00016 ============================================================================== 00017 ##### How to use this driver ##### 00018 ============================================================================== 00019 [..] 00020 (#)Declare a HCD_HandleTypeDef handle structure, for example: 00021 HCD_HandleTypeDef hhcd; 00022 00023 (#)Fill parameters of Init structure in HCD handle 00024 00025 (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...) 00026 00027 (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API: 00028 (##) Enable the HCD/USB Low Level interface clock using the following macro 00029 (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE() 00030 00031 (##) Initialize the related GPIO clocks 00032 (##) Configure HCD pin-out 00033 (##) Configure HCD NVIC interrupt 00034 00035 (#)Associate the Upper USB Host stack to the HAL HCD Driver: 00036 (##) hhcd.pData = phost; 00037 00038 (#)Enable HCD transmission and reception: 00039 (##) HAL_HCD_Start(); 00040 00041 @endverbatim 00042 ****************************************************************************** 00043 * @attention 00044 * 00045 * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2> 00046 * 00047 * Redistribution and use in source and binary forms, with or without modification, 00048 * are permitted provided that the following conditions are met: 00049 * 1. Redistributions of source code must retain the above copyright notice, 00050 * this list of conditions and the following disclaimer. 00051 * 2. Redistributions in binary form must reproduce the above copyright notice, 00052 * this list of conditions and the following disclaimer in the documentation 00053 * and/or other materials provided with the distribution. 00054 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00055 * may be used to endorse or promote products derived from this software 00056 * without specific prior written permission. 00057 * 00058 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00059 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00060 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00061 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00062 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00063 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00064 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00065 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00066 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00067 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00068 * 00069 ****************************************************************************** 00070 */ 00071 00072 /* Includes ------------------------------------------------------------------*/ 00073 #include "stm32l4xx_hal.h" 00074 00075 #if defined(STM32L475xx) || defined(STM32L476xx) || defined(STM32L485xx) || defined(STM32L486xx) 00076 00077 /** @addtogroup STM32L4xx_HAL_Driver 00078 * @{ 00079 */ 00080 00081 /** @defgroup HCD HCD 00082 * @brief HCD HAL module driver 00083 * @{ 00084 */ 00085 00086 #ifdef HAL_HCD_MODULE_ENABLED 00087 00088 /* Private typedef -----------------------------------------------------------*/ 00089 /* Private define ------------------------------------------------------------*/ 00090 /* Private macro -------------------------------------------------------------*/ 00091 /* Private variables ---------------------------------------------------------*/ 00092 /* Private function prototypes -----------------------------------------------*/ 00093 /** @defgroup HCD_Private_Functions HCD Private Functions 00094 * @{ 00095 */ 00096 static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum); 00097 static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum); 00098 static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd); 00099 static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd); 00100 /** 00101 * @} 00102 */ 00103 00104 /* Exported functions --------------------------------------------------------*/ 00105 /** @defgroup HCD_Exported_Functions HCD Exported Functions 00106 * @{ 00107 */ 00108 00109 /** @defgroup HCD_Exported_Functions_Group1 Initialization and de-initialization functions 00110 * @brief Initialization and Configuration functions 00111 * 00112 @verbatim 00113 =============================================================================== 00114 ##### Initialization and de-initialization functions ##### 00115 =============================================================================== 00116 [..] This section provides functions allowing to: 00117 00118 @endverbatim 00119 * @{ 00120 */ 00121 00122 /** 00123 * @brief Initialize the Host driver. 00124 * @param hhcd: HCD handle 00125 * @retval HAL status 00126 */ 00127 HAL_StatusTypeDef HAL_HCD_Init(HCD_HandleTypeDef *hhcd) 00128 { 00129 /* Check the HCD handle allocation */ 00130 if(hhcd == NULL) 00131 { 00132 return HAL_ERROR; 00133 } 00134 00135 /* Check the parameters */ 00136 assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance)); 00137 00138 if(hhcd->State == HAL_HCD_STATE_RESET) 00139 { 00140 /* Allocate lock resource and initialize it */ 00141 hhcd->Lock = HAL_UNLOCKED; 00142 00143 /* Init the low level hardware : GPIO, CLOCK, NVIC... */ 00144 HAL_HCD_MspInit(hhcd); 00145 } 00146 00147 hhcd->State = HAL_HCD_STATE_BUSY; 00148 00149 /* Disable the Interrupts */ 00150 __HAL_HCD_DISABLE(hhcd); 00151 00152 /*Init the Core (common init.) */ 00153 USB_CoreInit(hhcd->Instance, hhcd->Init); 00154 00155 /* Force Host Mode*/ 00156 USB_SetCurrentMode(hhcd->Instance , USB_HOST_MODE); 00157 00158 /* Init Host */ 00159 USB_HostInit(hhcd->Instance, hhcd->Init); 00160 00161 hhcd->State= HAL_HCD_STATE_READY; 00162 00163 return HAL_OK; 00164 } 00165 00166 /** 00167 * @brief Initialize a Host channel. 00168 * @param hhcd: HCD handle 00169 * @param ch_num: Channel number. 00170 * This parameter can be a value from 1 to 15 00171 * @param epnum: Endpoint number. 00172 * This parameter can be a value from 1 to 15 00173 * @param dev_address : Current device address 00174 * This parameter can be a value from 0 to 255 00175 * @param speed: Current device speed. 00176 * This parameter can be one of these values: 00177 * HCD_SPEED_HIGH: High speed mode, 00178 * HCD_SPEED_FULL: Full speed mode, 00179 * HCD_SPEED_LOW: Low speed mode 00180 * @param ep_type: Endpoint Type. 00181 * This parameter can be one of these values: 00182 * EP_TYPE_CTRL: Control type, 00183 * EP_TYPE_ISOC: Isochronous type, 00184 * EP_TYPE_BULK: Bulk type, 00185 * EP_TYPE_INTR: Interrupt type 00186 * @param mps: Max Packet Size. 00187 * This parameter can be a value from 0 to32K 00188 * @retval HAL status 00189 */ 00190 HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd, 00191 uint8_t ch_num, 00192 uint8_t epnum, 00193 uint8_t dev_address, 00194 uint8_t speed, 00195 uint8_t ep_type, 00196 uint16_t mps) 00197 { 00198 HAL_StatusTypeDef status = HAL_OK; 00199 00200 __HAL_LOCK(hhcd); 00201 00202 hhcd->hc[ch_num].dev_addr = dev_address; 00203 hhcd->hc[ch_num].max_packet = mps; 00204 hhcd->hc[ch_num].ch_num = ch_num; 00205 hhcd->hc[ch_num].ep_type = ep_type; 00206 hhcd->hc[ch_num].ep_num = epnum & 0x7F; 00207 hhcd->hc[ch_num].ep_is_in = ((epnum & 0x80) == 0x80); 00208 hhcd->hc[ch_num].speed = speed; 00209 /* reset to 0 */ 00210 hhcd->hc[ch_num].toggle_out = 0; 00211 hhcd->hc[ch_num].toggle_in = 0; 00212 00213 status = USB_HC_Init(hhcd->Instance, 00214 ch_num, 00215 epnum, 00216 dev_address, 00217 speed, 00218 ep_type, 00219 mps); 00220 __HAL_UNLOCK(hhcd); 00221 00222 return status; 00223 } 00224 00225 /** 00226 * @brief Halt a Host channel. 00227 * @param hhcd: HCD handle 00228 * @param ch_num: Channel number. 00229 * This parameter can be a value from 1 to 15 00230 * @retval HAL status 00231 */ 00232 HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd, uint8_t ch_num) 00233 { 00234 HAL_StatusTypeDef status = HAL_OK; 00235 00236 __HAL_LOCK(hhcd); 00237 USB_HC_Halt(hhcd->Instance, ch_num); 00238 __HAL_UNLOCK(hhcd); 00239 00240 return status; 00241 } 00242 00243 /** 00244 * @brief DeInitialize the Host driver. 00245 * @param hhcd: HCD handle 00246 * @retval HAL status 00247 */ 00248 HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd) 00249 { 00250 /* Check the HCD handle allocation */ 00251 if(hhcd == NULL) 00252 { 00253 return HAL_ERROR; 00254 } 00255 00256 hhcd->State = HAL_HCD_STATE_BUSY; 00257 00258 /* DeInit the low level hardware */ 00259 HAL_HCD_MspDeInit(hhcd); 00260 00261 __HAL_HCD_DISABLE(hhcd); 00262 00263 hhcd->State = HAL_HCD_STATE_RESET; 00264 00265 return HAL_OK; 00266 } 00267 00268 /** 00269 * @brief Initialize the HCD MSP. 00270 * @param hhcd: HCD handle 00271 * @retval None 00272 */ 00273 __weak void HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd) 00274 { 00275 /* Prevent unused argument(s) compilation warning */ 00276 UNUSED(hhcd); 00277 00278 /* NOTE : This function should not be modified, when the callback is needed, 00279 the HAL_PCD_MspInit could be implemented in the user file 00280 */ 00281 } 00282 00283 /** 00284 * @brief DeInitialize the HCD MSP. 00285 * @param hhcd: HCD handle 00286 * @retval None 00287 */ 00288 __weak void HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd) 00289 { 00290 /* Prevent unused argument(s) compilation warning */ 00291 UNUSED(hhcd); 00292 00293 /* NOTE : This function should not be modified, when the callback is needed, 00294 the HAL_PCD_MspDeInit could be implemented in the user file 00295 */ 00296 } 00297 00298 /** 00299 * @} 00300 */ 00301 00302 /** @defgroup HCD_Exported_Functions_Group2 Input and Output operation functions 00303 * @brief HCD IO operation functions 00304 * 00305 @verbatim 00306 =============================================================================== 00307 ##### IO operation functions ##### 00308 =============================================================================== 00309 [..] This subsection provides a set of functions allowing to manage the USB Host Data 00310 Transfer 00311 00312 @endverbatim 00313 * @{ 00314 */ 00315 00316 /** 00317 * @brief Submit a new URB for processing. 00318 * @param hhcd: HCD handle 00319 * @param ch_num: Channel number. 00320 * This parameter can be a value from 1 to 15 00321 * @param direction: Channel number. 00322 * This parameter can be one of these values: 00323 * 0 : Output / 1 : Input 00324 * @param ep_type: Endpoint Type. 00325 * This parameter can be one of these values: 00326 * EP_TYPE_CTRL: Control type/ 00327 * EP_TYPE_ISOC: Isochronous type/ 00328 * EP_TYPE_BULK: Bulk type/ 00329 * EP_TYPE_INTR: Interrupt type/ 00330 * @param token: Endpoint Type. 00331 * This parameter can be one of these values: 00332 * 0: HC_PID_SETUP / 1: HC_PID_DATA1 00333 * @param pbuff: pointer to URB data 00334 * @param length: Length of URB data 00335 * @param do_ping: activate do ping protocol (for high speed only). 00336 * This parameter can be one of these values: 00337 * 0 : do ping inactive / 1 : do ping active 00338 * @retval HAL status 00339 */ 00340 HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd, 00341 uint8_t ch_num, 00342 uint8_t direction , 00343 uint8_t ep_type, 00344 uint8_t token, 00345 uint8_t* pbuff, 00346 uint16_t length, 00347 uint8_t do_ping) 00348 { 00349 if ((hhcd->hc[ch_num].ep_is_in != direction)) { 00350 if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL)){ 00351 /* reconfigure the endpoint !!! from tx -> rx, and rx ->tx */ 00352 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 00353 if (direction) 00354 { 00355 USBx_HC(ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM; 00356 USBx_HC(ch_num)->HCCHAR |= 1 << 15; 00357 } 00358 else 00359 { 00360 USBx_HC(ch_num)->HCINTMSK &= ~USB_OTG_HCINTMSK_BBERRM; 00361 USBx_HC(ch_num)->HCCHAR &= ~(1 << 15); 00362 } 00363 hhcd->hc[ch_num].ep_is_in = direction; 00364 /* if reception put toggle_in to 1 */ 00365 if (direction == 1) hhcd->hc[ch_num].toggle_in=1; 00366 } 00367 } 00368 hhcd->hc[ch_num].ep_type = ep_type; 00369 00370 if(token == 0) 00371 { 00372 hhcd->hc[ch_num].data_pid = HC_PID_SETUP; 00373 } 00374 else 00375 { 00376 hhcd->hc[ch_num].data_pid = HC_PID_DATA1; 00377 } 00378 00379 /* Manage Data Toggle */ 00380 switch(ep_type) 00381 { 00382 case EP_TYPE_CTRL: 00383 if((token == 1) && (direction == 0)) /*send data */ 00384 { 00385 if ( length == 0 ) 00386 { /* For Status OUT stage, Length==0, Status Out PID = 1 */ 00387 hhcd->hc[ch_num].toggle_out = 1; 00388 } 00389 00390 /* Set the Data Toggle bit as per the Flag */ 00391 if ( hhcd->hc[ch_num].toggle_out == 0) 00392 { /* Put the PID 0 */ 00393 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00394 } 00395 else 00396 { /* Put the PID 1 */ 00397 hhcd->hc[ch_num].data_pid = HC_PID_DATA1 ; 00398 } 00399 if(hhcd->hc[ch_num].urb_state != URB_NOTREADY) 00400 { 00401 hhcd->hc[ch_num].do_ping = do_ping; 00402 } 00403 } 00404 else if ((token == 1) && (direction == 1)) 00405 { 00406 if( hhcd->hc[ch_num].toggle_in == 0) 00407 { 00408 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00409 } 00410 else 00411 { 00412 hhcd->hc[ch_num].data_pid = HC_PID_DATA1; 00413 } 00414 } 00415 break; 00416 00417 case EP_TYPE_BULK: 00418 if(direction == 0) 00419 { 00420 /* Set the Data Toggle bit as per the Flag */ 00421 if ( hhcd->hc[ch_num].toggle_out == 0) 00422 { /* Put the PID 0 */ 00423 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00424 } 00425 else 00426 { /* Put the PID 1 */ 00427 hhcd->hc[ch_num].data_pid = HC_PID_DATA1 ; 00428 } 00429 if(hhcd->hc[ch_num].urb_state != URB_NOTREADY) 00430 { 00431 hhcd->hc[ch_num].do_ping = do_ping; 00432 } 00433 } 00434 else 00435 { 00436 if( hhcd->hc[ch_num].toggle_in == 0) 00437 { 00438 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00439 } 00440 else 00441 { 00442 hhcd->hc[ch_num].data_pid = HC_PID_DATA1; 00443 } 00444 } 00445 00446 break; 00447 case EP_TYPE_INTR: 00448 if(direction == 0) 00449 { 00450 /* Set the Data Toggle bit as per the Flag */ 00451 if ( hhcd->hc[ch_num].toggle_out == 0) 00452 { /* Put the PID 0 */ 00453 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00454 } 00455 else 00456 { /* Put the PID 1 */ 00457 hhcd->hc[ch_num].data_pid = HC_PID_DATA1 ; 00458 } 00459 } 00460 else 00461 { 00462 if( hhcd->hc[ch_num].toggle_in == 0) 00463 { 00464 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00465 } 00466 else 00467 { 00468 hhcd->hc[ch_num].data_pid = HC_PID_DATA1; 00469 } 00470 } 00471 break; 00472 00473 case EP_TYPE_ISOC: 00474 hhcd->hc[ch_num].data_pid = HC_PID_DATA0; 00475 break; 00476 } 00477 00478 hhcd->hc[ch_num].xfer_buff = pbuff; 00479 hhcd->hc[ch_num].xfer_len = length; 00480 hhcd->hc[ch_num].urb_state = URB_IDLE; 00481 hhcd->hc[ch_num].xfer_count = 0 ; 00482 hhcd->hc[ch_num].ch_num = ch_num; 00483 hhcd->hc[ch_num].state = HC_IDLE; 00484 00485 return USB_HC_StartXfer(hhcd->Instance, &(hhcd->hc[ch_num]), hhcd->Init.dma_enable); 00486 } 00487 00488 /** 00489 * @brief Handle HCD interrupt request. 00490 * @param hhcd: HCD handle 00491 * @retval None 00492 */ 00493 void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd) 00494 { 00495 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 00496 uint32_t i = 0 , interrupt = 0; 00497 00498 /* ensure that we are in device mode */ 00499 if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST) 00500 { 00501 /* avoid spurious interrupt */ 00502 if(__HAL_HCD_IS_INVALID_INTERRUPT(hhcd)) 00503 { 00504 return; 00505 } 00506 00507 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT)) 00508 { 00509 /* incorrect mode, acknowledge the interrupt */ 00510 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT); 00511 } 00512 00513 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR)) 00514 { 00515 /* incorrect mode, acknowledge the interrupt */ 00516 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR); 00517 } 00518 00519 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE)) 00520 { 00521 /* incorrect mode, acknowledge the interrupt */ 00522 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE); 00523 } 00524 00525 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS)) 00526 { 00527 /* incorrect mode, acknowledge the interrupt */ 00528 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS); 00529 } 00530 00531 /* Handle Host Disconnect Interrupts */ 00532 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT)) 00533 { 00534 00535 /* Cleanup HPRT */ 00536 USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\ 00537 USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG ); 00538 00539 /* Handle Host Port Interrupts */ 00540 HAL_HCD_Disconnect_Callback(hhcd); 00541 USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ ); 00542 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT); 00543 } 00544 00545 /* Handle Host Port Interrupts */ 00546 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT)) 00547 { 00548 HCD_Port_IRQHandler (hhcd); 00549 } 00550 00551 /* Handle Host SOF Interrupts */ 00552 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF)) 00553 { 00554 HAL_HCD_SOF_Callback(hhcd); 00555 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF); 00556 } 00557 00558 /* Handle Host channel Interrupts */ 00559 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT)) 00560 { 00561 interrupt = USB_HC_ReadInterrupt(hhcd->Instance); 00562 for (i = 0; i < hhcd->Init.Host_channels ; i++) 00563 { 00564 if (interrupt & (1 << i)) 00565 { 00566 if ((USBx_HC(i)->HCCHAR) & USB_OTG_HCCHAR_EPDIR) 00567 { 00568 HCD_HC_IN_IRQHandler (hhcd, i); 00569 } 00570 else 00571 { 00572 HCD_HC_OUT_IRQHandler (hhcd, i); 00573 } 00574 } 00575 } 00576 __HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT); 00577 } 00578 00579 /* Handle Rx Queue Level Interrupts */ 00580 if(__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL)) 00581 { 00582 USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL); 00583 00584 HCD_RXQLVL_IRQHandler (hhcd); 00585 00586 USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL); 00587 } 00588 } 00589 } 00590 00591 /** 00592 * @brief SOF callback. 00593 * @param hhcd: HCD handle 00594 * @retval None 00595 */ 00596 __weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd) 00597 { 00598 /* Prevent unused argument(s) compilation warning */ 00599 UNUSED(hhcd); 00600 00601 /* NOTE : This function should not be modified, when the callback is needed, 00602 the HAL_HCD_SOF_Callback could be implemented in the user file 00603 */ 00604 } 00605 00606 /** 00607 * @brief Connection Event callback. 00608 * @param hhcd: HCD handle 00609 * @retval None 00610 */ 00611 __weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd) 00612 { 00613 /* Prevent unused argument(s) compilation warning */ 00614 UNUSED(hhcd); 00615 00616 /* NOTE : This function should not be modified, when the callback is needed, 00617 the HAL_HCD_Connect_Callback could be implemented in the user file 00618 */ 00619 } 00620 00621 /** 00622 * @brief Disconnection Event callback. 00623 * @param hhcd: HCD handle 00624 * @retval None 00625 */ 00626 __weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd) 00627 { 00628 /* Prevent unused argument(s) compilation warning */ 00629 UNUSED(hhcd); 00630 00631 /* NOTE : This function should not be modified, when the callback is needed, 00632 the HAL_HCD_Disconnect_Callback could be implemented in the user file 00633 */ 00634 } 00635 00636 /** 00637 * @brief Notify URB state change callback. 00638 * @param hhcd: HCD handle 00639 * @param chnum: Channel number. 00640 * This parameter can be a value from 1 to 15 00641 * @param urb_state: 00642 * This parameter can be one of these values: 00643 * URB_IDLE/ 00644 * URB_DONE/ 00645 * URB_NOTREADY/ 00646 * URB_NYET/ 00647 * URB_ERROR/ 00648 * URB_STALL/ 00649 * @retval None 00650 */ 00651 __weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state) 00652 { 00653 /* Prevent unused argument(s) compilation warning */ 00654 UNUSED(hhcd); 00655 UNUSED(chnum); 00656 UNUSED(urb_state); 00657 00658 /* NOTE : This function should not be modified, when the callback is needed, 00659 the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file 00660 */ 00661 } 00662 00663 /** 00664 * @} 00665 */ 00666 00667 /** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions 00668 * @brief Management functions 00669 * 00670 @verbatim 00671 =============================================================================== 00672 ##### Peripheral Control functions ##### 00673 =============================================================================== 00674 [..] 00675 This subsection provides a set of functions allowing to control the HCD data 00676 transfers. 00677 00678 @endverbatim 00679 * @{ 00680 */ 00681 00682 /** 00683 * @brief Start the Host driver. 00684 * @param hhcd: HCD handle 00685 * @retval HAL status 00686 */ 00687 HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd) 00688 { 00689 __HAL_LOCK(hhcd); 00690 __HAL_HCD_ENABLE(hhcd); 00691 USB_DriveVbus(hhcd->Instance, 1); 00692 __HAL_UNLOCK(hhcd); 00693 return HAL_OK; 00694 } 00695 00696 /** 00697 * @brief Stop the Host driver. 00698 * @param hhcd: HCD handle 00699 * @retval HAL status 00700 */ 00701 00702 HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd) 00703 { 00704 __HAL_LOCK(hhcd); 00705 USB_StopHost(hhcd->Instance); 00706 __HAL_UNLOCK(hhcd); 00707 return HAL_OK; 00708 } 00709 00710 /** 00711 * @brief Reset the Host port. 00712 * @param hhcd: HCD handle 00713 * @retval HAL status 00714 */ 00715 HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd) 00716 { 00717 return (USB_ResetPort(hhcd->Instance)); 00718 } 00719 00720 /** 00721 * @} 00722 */ 00723 00724 /** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions 00725 * @brief Peripheral State functions 00726 * 00727 @verbatim 00728 =============================================================================== 00729 ##### Peripheral State functions ##### 00730 =============================================================================== 00731 [..] 00732 This subsection permits to get in run-time the status of the peripheral 00733 and the data flow. 00734 00735 @endverbatim 00736 * @{ 00737 */ 00738 00739 /** 00740 * @brief Return the HCD handle state. 00741 * @param hhcd: HCD handle 00742 * @retval HAL state 00743 */ 00744 HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef *hhcd) 00745 { 00746 return hhcd->State; 00747 } 00748 00749 /** 00750 * @brief Return URB state for a channel. 00751 * @param hhcd: HCD handle 00752 * @param chnum: Channel number. 00753 * This parameter can be a value from 1 to 15 00754 * @retval URB state. 00755 * This parameter can be one of these values: 00756 * URB_IDLE/ 00757 * URB_DONE/ 00758 * URB_NOTREADY/ 00759 * URB_NYET/ 00760 * URB_ERROR/ 00761 * URB_STALL 00762 */ 00763 HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef *hhcd, uint8_t chnum) 00764 { 00765 return hhcd->hc[chnum].urb_state; 00766 } 00767 00768 00769 /** 00770 * @brief Return the last Host transfer size. 00771 * @param hhcd: HCD handle 00772 * @param chnum: Channel number. 00773 * This parameter can be a value from 1 to 15 00774 * @retval last transfer size in byte 00775 */ 00776 uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef *hhcd, uint8_t chnum) 00777 { 00778 return hhcd->hc[chnum].xfer_count; 00779 } 00780 00781 /** 00782 * @brief Return the Host Channel state. 00783 * @param hhcd: HCD handle 00784 * @param chnum: Channel number. 00785 * This parameter can be a value from 1 to 15 00786 * @retval Host channel state 00787 * This parameter can be one of these values: 00788 * HC_IDLE/ 00789 * HC_XFRC/ 00790 * HC_HALTED/ 00791 * HC_NYET/ 00792 * HC_NAK/ 00793 * HC_STALL/ 00794 * HC_XACTERR/ 00795 * HC_BBLERR/ 00796 * HC_DATATGLERR 00797 */ 00798 HCD_HCStateTypeDef HAL_HCD_HC_GetState(HCD_HandleTypeDef *hhcd, uint8_t chnum) 00799 { 00800 return hhcd->hc[chnum].state; 00801 } 00802 00803 /** 00804 * @brief Return the current Host frame number. 00805 * @param hhcd: HCD handle 00806 * @retval Current Host frame number 00807 */ 00808 uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd) 00809 { 00810 return (USB_GetCurrentFrame(hhcd->Instance)); 00811 } 00812 00813 /** 00814 * @brief Return the Host enumeration speed. 00815 * @param hhcd: HCD handle 00816 * @retval Enumeration speed 00817 */ 00818 uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd) 00819 { 00820 return (USB_GetHostSpeed(hhcd->Instance)); 00821 } 00822 00823 /** 00824 * @} 00825 */ 00826 00827 /** 00828 * @} 00829 */ 00830 00831 /** @addtogroup HCD_Private_Functions 00832 * @{ 00833 */ 00834 /** 00835 * @brief Handle Host Channel IN interrupt requests. 00836 * @param hhcd: HCD handle 00837 * @param chnum: Channel number. 00838 * This parameter can be a value from 1 to 15 00839 * @retval none 00840 */ 00841 static void HCD_HC_IN_IRQHandler (HCD_HandleTypeDef *hhcd, uint8_t chnum) 00842 { 00843 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 00844 uint32_t tmpreg = 0; 00845 00846 if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_AHBERR) 00847 { 00848 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR); 00849 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00850 } 00851 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_ACK) 00852 { 00853 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK); 00854 } 00855 00856 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_STALL) 00857 { 00858 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00859 hhcd->hc[chnum].state = HC_STALL; 00860 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 00861 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL); 00862 USB_HC_Halt(hhcd->Instance, chnum); 00863 } 00864 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_DTERR) 00865 { 00866 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00867 USB_HC_Halt(hhcd->Instance, chnum); 00868 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 00869 hhcd->hc[chnum].state = HC_DATATGLERR; 00870 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR); 00871 } 00872 00873 if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_FRMOR) 00874 { 00875 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00876 USB_HC_Halt(hhcd->Instance, chnum); 00877 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR); 00878 } 00879 00880 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_XFRC) 00881 { 00882 00883 if (hhcd->Init.dma_enable) 00884 { 00885 hhcd->hc[chnum].xfer_count = hhcd->hc[chnum].xfer_len - \ 00886 (USBx_HC(chnum)->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ); 00887 } 00888 00889 hhcd->hc[chnum].state = HC_XFRC; 00890 hhcd->hc[chnum].ErrCnt = 0; 00891 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC); 00892 00893 00894 if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)|| 00895 (hhcd->hc[chnum].ep_type == EP_TYPE_BULK)) 00896 { 00897 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00898 USB_HC_Halt(hhcd->Instance, chnum); 00899 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 00900 00901 } 00902 else if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR) 00903 { 00904 USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM; 00905 hhcd->hc[chnum].urb_state = URB_DONE; 00906 HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state); 00907 } 00908 hhcd->hc[chnum].toggle_in ^= 1; 00909 00910 } 00911 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_CHH) 00912 { 00913 int reactivate = 0; 00914 __HAL_HCD_MASK_HALT_HC_INT(chnum); 00915 00916 if(hhcd->hc[chnum].state == HC_XFRC) 00917 { 00918 hhcd->hc[chnum].urb_state = URB_DONE; 00919 } 00920 00921 else if (hhcd->hc[chnum].state == HC_STALL) 00922 { 00923 hhcd->hc[chnum].urb_state = URB_STALL; 00924 } 00925 00926 else if((hhcd->hc[chnum].state == HC_XACTERR) || 00927 (hhcd->hc[chnum].state == HC_DATATGLERR)) 00928 { 00929 if(hhcd->hc[chnum].ErrCnt++ > 3) 00930 { 00931 hhcd->hc[chnum].ErrCnt = 0; 00932 hhcd->hc[chnum].urb_state = URB_ERROR; 00933 } 00934 else 00935 { 00936 hhcd->hc[chnum].urb_state = URB_NOTREADY; 00937 } 00938 00939 /* re-activate the channel */ 00940 tmpreg = USBx_HC(chnum)->HCCHAR; 00941 tmpreg &= ~USB_OTG_HCCHAR_CHDIS; 00942 tmpreg |= USB_OTG_HCCHAR_CHENA; 00943 USBx_HC(chnum)->HCCHAR = tmpreg; 00944 reactivate = 1; 00945 } 00946 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH); 00947 if (reactivate == 0) HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state); 00948 } 00949 00950 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_TXERR) 00951 { 00952 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00953 hhcd->hc[chnum].ErrCnt++; 00954 hhcd->hc[chnum].state = HC_XACTERR; 00955 USB_HC_Halt(hhcd->Instance, chnum); 00956 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR); 00957 } 00958 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_NAK) 00959 { 00960 if(hhcd->hc[chnum].ep_type == EP_TYPE_INTR) 00961 { 00962 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00963 USB_HC_Halt(hhcd->Instance, chnum); 00964 } 00965 00966 /* Clear the NAK flag before re-enabling the channel for new IN request */ 00967 hhcd->hc[chnum].state = HC_NAK; 00968 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 00969 00970 if ((hhcd->hc[chnum].ep_type == EP_TYPE_CTRL)|| 00971 (hhcd->hc[chnum].ep_type == EP_TYPE_BULK)) 00972 { 00973 /* re-activate the channel */ 00974 USBx_HC(chnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHDIS; 00975 USBx_HC(chnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA; 00976 00977 } 00978 } 00979 } 00980 00981 /** 00982 * @brief Handle Host Channel OUT interrupt requests. 00983 * @param hhcd: HCD handle 00984 * @param chnum: Channel number. 00985 * This parameter can be a value from 1 to 15 00986 * @retval none 00987 */ 00988 static void HCD_HC_OUT_IRQHandler (HCD_HandleTypeDef *hhcd, uint8_t chnum) 00989 { 00990 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 00991 uint32_t tmpreg = 0; 00992 00993 if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_AHBERR) 00994 { 00995 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_AHBERR); 00996 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 00997 } 00998 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_ACK) 00999 { 01000 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_ACK); 01001 01002 if( hhcd->hc[chnum].do_ping == 1) 01003 { 01004 hhcd->hc[chnum].state = HC_NYET; 01005 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01006 USB_HC_Halt(hhcd->Instance, chnum); 01007 hhcd->hc[chnum].urb_state = URB_NOTREADY; 01008 } 01009 } 01010 01011 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_NYET) 01012 { 01013 hhcd->hc[chnum].state = HC_NYET; 01014 hhcd->hc[chnum].ErrCnt= 0; 01015 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01016 USB_HC_Halt(hhcd->Instance, chnum); 01017 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NYET); 01018 01019 } 01020 01021 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_FRMOR) 01022 { 01023 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01024 USB_HC_Halt(hhcd->Instance, chnum); 01025 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_FRMOR); 01026 } 01027 01028 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_XFRC) 01029 { 01030 hhcd->hc[chnum].ErrCnt = 0; 01031 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01032 USB_HC_Halt(hhcd->Instance, chnum); 01033 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_XFRC); 01034 hhcd->hc[chnum].state = HC_XFRC; 01035 01036 } 01037 01038 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_STALL) 01039 { 01040 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_STALL); 01041 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01042 USB_HC_Halt(hhcd->Instance, chnum); 01043 hhcd->hc[chnum].state = HC_STALL; 01044 } 01045 01046 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_NAK) 01047 { 01048 hhcd->hc[chnum].ErrCnt = 0; 01049 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01050 USB_HC_Halt(hhcd->Instance, chnum); 01051 hhcd->hc[chnum].state = HC_NAK; 01052 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 01053 } 01054 01055 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_TXERR) 01056 { 01057 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01058 USB_HC_Halt(hhcd->Instance, chnum); 01059 hhcd->hc[chnum].state = HC_XACTERR; 01060 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_TXERR); 01061 } 01062 01063 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_DTERR) 01064 { 01065 __HAL_HCD_UNMASK_HALT_HC_INT(chnum); 01066 USB_HC_Halt(hhcd->Instance, chnum); 01067 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_NAK); 01068 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_DTERR); 01069 hhcd->hc[chnum].state = HC_DATATGLERR; 01070 } 01071 01072 01073 else if ((USBx_HC(chnum)->HCINT) & USB_OTG_HCINT_CHH) 01074 { 01075 __HAL_HCD_MASK_HALT_HC_INT(chnum); 01076 01077 if(hhcd->hc[chnum].state == HC_XFRC) 01078 { 01079 hhcd->hc[chnum].urb_state = URB_DONE; 01080 if (hhcd->hc[chnum].ep_type == EP_TYPE_BULK) 01081 { 01082 hhcd->hc[chnum].toggle_out ^= 1; 01083 } 01084 } 01085 else if (hhcd->hc[chnum].state == HC_NAK) 01086 { 01087 hhcd->hc[chnum].urb_state = URB_NOTREADY; 01088 } 01089 01090 else if (hhcd->hc[chnum].state == HC_NYET) 01091 { 01092 hhcd->hc[chnum].urb_state = URB_NOTREADY; 01093 hhcd->hc[chnum].do_ping = 0; 01094 } 01095 01096 else if (hhcd->hc[chnum].state == HC_STALL) 01097 { 01098 hhcd->hc[chnum].urb_state = URB_STALL; 01099 } 01100 01101 else if((hhcd->hc[chnum].state == HC_XACTERR) || 01102 (hhcd->hc[chnum].state == HC_DATATGLERR)) 01103 { 01104 if(hhcd->hc[chnum].ErrCnt++ > 3) 01105 { 01106 hhcd->hc[chnum].ErrCnt = 0; 01107 hhcd->hc[chnum].urb_state = URB_ERROR; 01108 } 01109 else 01110 { 01111 hhcd->hc[chnum].urb_state = URB_NOTREADY; 01112 } 01113 01114 /* re-activate the channel */ 01115 tmpreg = USBx_HC(chnum)->HCCHAR; 01116 tmpreg &= ~USB_OTG_HCCHAR_CHDIS; 01117 tmpreg |= USB_OTG_HCCHAR_CHENA; 01118 USBx_HC(chnum)->HCCHAR = tmpreg; 01119 } 01120 01121 __HAL_HCD_CLEAR_HC_INT(chnum, USB_OTG_HCINT_CHH); 01122 HAL_HCD_HC_NotifyURBChange_Callback(hhcd, chnum, hhcd->hc[chnum].urb_state); 01123 } 01124 } 01125 01126 /** 01127 * @brief Handle Rx Queue Level interrupt requests. 01128 * @param hhcd: HCD handle 01129 * @retval none 01130 */ 01131 static void HCD_RXQLVL_IRQHandler (HCD_HandleTypeDef *hhcd) 01132 { 01133 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 01134 uint8_t channelnum =0; 01135 uint32_t pktsts; 01136 uint32_t pktcnt; 01137 uint32_t temp = 0; 01138 uint32_t tmpreg = 0; 01139 01140 temp = hhcd->Instance->GRXSTSP ; 01141 channelnum = temp & USB_OTG_GRXSTSP_EPNUM; 01142 pktsts = (temp & USB_OTG_GRXSTSP_PKTSTS) >> 17; 01143 pktcnt = (temp & USB_OTG_GRXSTSP_BCNT) >> 4; 01144 01145 switch (pktsts) 01146 { 01147 case GRXSTS_PKTSTS_IN: 01148 /* Read the data into the Host buffer. */ 01149 if ((pktcnt > 0) && (hhcd->hc[channelnum].xfer_buff != (void *)0)) 01150 { 01151 01152 USB_ReadPacket(hhcd->Instance, hhcd->hc[channelnum].xfer_buff, pktcnt); 01153 01154 /*manage multiple Xfer */ 01155 hhcd->hc[channelnum].xfer_buff += pktcnt; 01156 hhcd->hc[channelnum].xfer_count += pktcnt; 01157 01158 if((USBx_HC(channelnum)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) > 0) 01159 { 01160 /* re-activate the channel when more packets are expected */ 01161 tmpreg = USBx_HC(channelnum)->HCCHAR; 01162 tmpreg &= ~USB_OTG_HCCHAR_CHDIS; 01163 tmpreg |= USB_OTG_HCCHAR_CHENA; 01164 USBx_HC(channelnum)->HCCHAR = tmpreg; 01165 hhcd->hc[channelnum].toggle_in ^= 1; 01166 } 01167 } 01168 break; 01169 01170 case GRXSTS_PKTSTS_DATA_TOGGLE_ERR: 01171 break; 01172 case GRXSTS_PKTSTS_IN_XFER_COMP: 01173 case GRXSTS_PKTSTS_CH_HALTED: 01174 default: 01175 break; 01176 } 01177 } 01178 01179 /** 01180 * @brief Handle Host Port interrupt requests. 01181 * @param hhcd: HCD handle 01182 * @retval None 01183 */ 01184 static void HCD_Port_IRQHandler (HCD_HandleTypeDef *hhcd) 01185 { 01186 USB_OTG_GlobalTypeDef *USBx = hhcd->Instance; 01187 __IO uint32_t hprt0, hprt0_dup; 01188 01189 /* Handle Host Port Interrupts */ 01190 hprt0 = USBx_HPRT0; 01191 hprt0_dup = USBx_HPRT0; 01192 01193 hprt0_dup &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\ 01194 USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG ); 01195 01196 /* Check whether Port Connect Detected */ 01197 if((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET) 01198 { 01199 if((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS) 01200 { 01201 USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT); 01202 HAL_HCD_Connect_Callback(hhcd); 01203 } 01204 hprt0_dup |= USB_OTG_HPRT_PCDET; 01205 01206 } 01207 01208 /* Check whether Port Enable Changed */ 01209 if((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG) 01210 { 01211 hprt0_dup |= USB_OTG_HPRT_PENCHNG; 01212 01213 if((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA) 01214 { 01215 if(hhcd->Init.phy_itface == USB_OTG_EMBEDDED_PHY) 01216 { 01217 if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17)) 01218 { 01219 USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_6_MHZ ); 01220 } 01221 else 01222 { 01223 USB_InitFSLSPClkSel(hhcd->Instance ,HCFG_48_MHZ ); 01224 } 01225 } 01226 else 01227 { 01228 if(hhcd->Init.speed == HCD_SPEED_FULL) 01229 { 01230 USBx_HOST->HFIR = (uint32_t)60000; 01231 } 01232 } 01233 HAL_HCD_Connect_Callback(hhcd); 01234 01235 if(hhcd->Init.speed == HCD_SPEED_HIGH) 01236 { 01237 USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT); 01238 } 01239 } 01240 else 01241 { 01242 /* Cleanup HPRT */ 01243 USBx_HPRT0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |\ 01244 USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG ); 01245 01246 USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_DISCINT); 01247 } 01248 } 01249 01250 /* Check For an overcurrent */ 01251 if((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG) 01252 { 01253 hprt0_dup |= USB_OTG_HPRT_POCCHNG; 01254 } 01255 01256 /* Clear Port Interrupts */ 01257 USBx_HPRT0 = hprt0_dup; 01258 } 01259 01260 /** 01261 * @} 01262 */ 01263 01264 /** 01265 * @} 01266 */ 01267 01268 #endif /* HAL_HCD_MODULE_ENABLED */ 01269 /** 01270 * @} 01271 */ 01272 01273 /** 01274 * @} 01275 */ 01276 01277 #endif /* STM32L475xx || STM32L476xx || STM32L485xx || STM32L486xx */ 01278 01279 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated on Tue Jul 12 2022 10:59:58 by
1.7.2