shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F407VG/stm32f4xx_hal_hcd.c@323:9e901b0a5aa1, 2014-09-13 (annotated)

Committer:
shaoziyang
Date:
Sat Sep 13 14:25:46 2014 +0000
Revision:
323:9e901b0a5aa1
Parent:
296:ec1b66a3d094 
test with CLOCK_SETUP = 0

Who changed what in which revision?

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