mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F1/device/stm32f1xx_hal_pcd.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
187:0387e8f68319 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f1xx_hal_pcd.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @brief PCD HAL module driver.
<> 144:ef7eb2e8f9f7 6 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 7 * functionalities of the USB Peripheral Controller:
<> 144:ef7eb2e8f9f7 8 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 9 * + IO operation functions
<> 144:ef7eb2e8f9f7 10 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 11 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 12 *
<> 144:ef7eb2e8f9f7 13 @verbatim
<> 144:ef7eb2e8f9f7 14 ==============================================================================
<> 144:ef7eb2e8f9f7 15 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 16 ==============================================================================
<> 144:ef7eb2e8f9f7 17 [..]
<> 144:ef7eb2e8f9f7 18 The PCD HAL driver can be used as follows:
<> 144:ef7eb2e8f9f7 19
<> 144:ef7eb2e8f9f7 20 (#) Declare a PCD_HandleTypeDef handle structure, for example:
<> 144:ef7eb2e8f9f7 21 PCD_HandleTypeDef hpcd;
<> 144:ef7eb2e8f9f7 22
<> 144:ef7eb2e8f9f7 23 (#) Fill parameters of Init structure in HCD handle
<> 144:ef7eb2e8f9f7 24
<> 144:ef7eb2e8f9f7 25 (#) Call HAL_PCD_Init() API to initialize the HCD peripheral (Core, Device core, ...)
<> 144:ef7eb2e8f9f7 26
<> 144:ef7eb2e8f9f7 27 (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
<> 144:ef7eb2e8f9f7 28 (##) Enable the PCD/USB Low Level interface clock using the following macro
<> 144:ef7eb2e8f9f7 29 (+++) __HAL_RCC_USB_CLK_ENABLE(); For USB Device FS peripheral available
<> 144:ef7eb2e8f9f7 30 on STM32F102xx and STM32F103xx devices
<> 144:ef7eb2e8f9f7 31 (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE(); For USB OTG FS peripheral available
<> 144:ef7eb2e8f9f7 32 on STM32F105xx and STM32F107xx devices
<> 144:ef7eb2e8f9f7 33
<> 144:ef7eb2e8f9f7 34 (##) Initialize the related GPIO clocks
<> 144:ef7eb2e8f9f7 35 (##) Configure PCD pin-out
<> 144:ef7eb2e8f9f7 36 (##) Configure PCD NVIC interrupt
<> 144:ef7eb2e8f9f7 37
<> 144:ef7eb2e8f9f7 38 (#)Associate the Upper USB device stack to the HAL PCD Driver:
<> 144:ef7eb2e8f9f7 39 (##) hpcd.pData = pdev;
<> 144:ef7eb2e8f9f7 40
<> 144:ef7eb2e8f9f7 41 (#)Enable HCD transmission and reception:
<> 144:ef7eb2e8f9f7 42 (##) HAL_PCD_Start();
<> 144:ef7eb2e8f9f7 43
<> 144:ef7eb2e8f9f7 44 @endverbatim
<> 144:ef7eb2e8f9f7 45 ******************************************************************************
<> 144:ef7eb2e8f9f7 46 * @attention
<> 144:ef7eb2e8f9f7 47 *
<> 144:ef7eb2e8f9f7 48 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 49 *
<> 144:ef7eb2e8f9f7 50 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 51 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 52 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 53 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 54 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 55 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 56 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 57 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 58 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 59 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 60 *
<> 144:ef7eb2e8f9f7 61 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 62 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 64 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 67 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 68 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 69 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 70 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 71 *
<> 144:ef7eb2e8f9f7 72 ******************************************************************************
<> 144:ef7eb2e8f9f7 73 */
<> 144:ef7eb2e8f9f7 74
<> 144:ef7eb2e8f9f7 75 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 76 #include "stm32f1xx_hal.h"
<> 144:ef7eb2e8f9f7 77
<> 144:ef7eb2e8f9f7 78 /** @addtogroup STM32F1xx_HAL_Driver
<> 144:ef7eb2e8f9f7 79 * @{
<> 144:ef7eb2e8f9f7 80 */
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82
<> 144:ef7eb2e8f9f7 83
<> 144:ef7eb2e8f9f7 84 #ifdef HAL_PCD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 85
<> 144:ef7eb2e8f9f7 86 #if defined(STM32F102x6) || defined(STM32F102xB) || \
<> 144:ef7eb2e8f9f7 87 defined(STM32F103x6) || defined(STM32F103xB) || \
<> 144:ef7eb2e8f9f7 88 defined(STM32F103xE) || defined(STM32F103xG) || \
<> 144:ef7eb2e8f9f7 89 defined(STM32F105xC) || defined(STM32F107xC)
<> 144:ef7eb2e8f9f7 90
<> 144:ef7eb2e8f9f7 91 /** @defgroup PCD PCD
<> 144:ef7eb2e8f9f7 92 * @brief PCD HAL module driver
<> 144:ef7eb2e8f9f7 93 * @{
<> 144:ef7eb2e8f9f7 94 */
<> 144:ef7eb2e8f9f7 95
<> 144:ef7eb2e8f9f7 96 /* Private types -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 97 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 98 /* Private constants ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 99 /* Private macros ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 100 /** @defgroup PCD_Private_Macros PCD Private Macros
<> 144:ef7eb2e8f9f7 101 * @{
<> 144:ef7eb2e8f9f7 102 */
<> 144:ef7eb2e8f9f7 103 #define PCD_MIN(a, b) (((a) < (b)) ? (a) : (b))
<> 144:ef7eb2e8f9f7 104 #define PCD_MAX(a, b) (((a) > (b)) ? (a) : (b))
<> 144:ef7eb2e8f9f7 105 /**
<> 144:ef7eb2e8f9f7 106 * @}
<> 144:ef7eb2e8f9f7 107 */
<> 144:ef7eb2e8f9f7 108
<> 144:ef7eb2e8f9f7 109 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 110 /** @defgroup PCD_Private_Functions PCD Private Functions
<> 144:ef7eb2e8f9f7 111 * @{
<> 144:ef7eb2e8f9f7 112 */
<> 144:ef7eb2e8f9f7 113 #if defined (USB_OTG_FS)
<> 144:ef7eb2e8f9f7 114 static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum);
<> 144:ef7eb2e8f9f7 115 #endif /* USB_OTG_FS */
<> 144:ef7eb2e8f9f7 116
<> 144:ef7eb2e8f9f7 117 #if defined (USB)
<> 144:ef7eb2e8f9f7 118 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
<> 144:ef7eb2e8f9f7 119 #endif /* USB */
<> 144:ef7eb2e8f9f7 120 /**
<> 144:ef7eb2e8f9f7 121 * @}
<> 144:ef7eb2e8f9f7 122 */
<> 144:ef7eb2e8f9f7 123
<> 144:ef7eb2e8f9f7 124 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 125 /** @defgroup PCD_Exported_Functions PCD Exported Functions
<> 144:ef7eb2e8f9f7 126 * @{
<> 144:ef7eb2e8f9f7 127 */
<> 144:ef7eb2e8f9f7 128
<> 144:ef7eb2e8f9f7 129 /** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 130 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 131 *
<> 144:ef7eb2e8f9f7 132 @verbatim
<> 144:ef7eb2e8f9f7 133 ===============================================================================
<> 144:ef7eb2e8f9f7 134 ##### Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 135 ===============================================================================
<> 144:ef7eb2e8f9f7 136 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 137
<> 144:ef7eb2e8f9f7 138 @endverbatim
<> 144:ef7eb2e8f9f7 139 * @{
<> 144:ef7eb2e8f9f7 140 */
<> 144:ef7eb2e8f9f7 141
<> 144:ef7eb2e8f9f7 142 /**
<> 144:ef7eb2e8f9f7 143 * @brief Initializes the PCD according to the specified
<> 144:ef7eb2e8f9f7 144 * parameters in the PCD_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 145 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 146 * @retval HAL status
<> 144:ef7eb2e8f9f7 147 */
<> 144:ef7eb2e8f9f7 148 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 149 {
AnnaBridge 165:e614a9f1c9e2 150 uint32_t index = 0U;
<> 144:ef7eb2e8f9f7 151
<> 144:ef7eb2e8f9f7 152 /* Check the PCD handle allocation */
<> 144:ef7eb2e8f9f7 153 if(hpcd == NULL)
<> 144:ef7eb2e8f9f7 154 {
<> 144:ef7eb2e8f9f7 155 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 156 }
<> 144:ef7eb2e8f9f7 157
<> 144:ef7eb2e8f9f7 158 /* Check the parameters */
<> 144:ef7eb2e8f9f7 159 assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
<> 144:ef7eb2e8f9f7 160
<> 144:ef7eb2e8f9f7 161 if(hpcd->State == HAL_PCD_STATE_RESET)
<> 144:ef7eb2e8f9f7 162 {
<> 144:ef7eb2e8f9f7 163 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 164 hpcd->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 165
<> 144:ef7eb2e8f9f7 166 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
<> 144:ef7eb2e8f9f7 167 HAL_PCD_MspInit(hpcd);
<> 144:ef7eb2e8f9f7 168 }
<> 144:ef7eb2e8f9f7 169
<> 144:ef7eb2e8f9f7 170 hpcd->State = HAL_PCD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* Disable the Interrupts */
<> 144:ef7eb2e8f9f7 173 __HAL_PCD_DISABLE(hpcd);
AnnaBridge 165:e614a9f1c9e2 174
<> 144:ef7eb2e8f9f7 175 /*Init the Core (common init.) */
<> 144:ef7eb2e8f9f7 176 USB_CoreInit(hpcd->Instance, hpcd->Init);
<> 144:ef7eb2e8f9f7 177
<> 144:ef7eb2e8f9f7 178 /* Force Device Mode*/
<> 144:ef7eb2e8f9f7 179 USB_SetCurrentMode(hpcd->Instance , USB_DEVICE_MODE);
<> 144:ef7eb2e8f9f7 180
<> 144:ef7eb2e8f9f7 181 /* Init endpoints structures */
AnnaBridge 165:e614a9f1c9e2 182 for (index = 0U; index < 15U ; index++)
<> 144:ef7eb2e8f9f7 183 {
<> 144:ef7eb2e8f9f7 184 /* Init ep structure */
AnnaBridge 165:e614a9f1c9e2 185 hpcd->IN_ep[index].is_in = 1U;
<> 144:ef7eb2e8f9f7 186 hpcd->IN_ep[index].num = index;
<> 144:ef7eb2e8f9f7 187 hpcd->IN_ep[index].tx_fifo_num = index;
<> 144:ef7eb2e8f9f7 188 /* Control until ep is actvated */
<> 144:ef7eb2e8f9f7 189 hpcd->IN_ep[index].type = EP_TYPE_CTRL;
AnnaBridge 165:e614a9f1c9e2 190 hpcd->IN_ep[index].maxpacket = 0U;
AnnaBridge 165:e614a9f1c9e2 191 hpcd->IN_ep[index].xfer_buff = 0U;
AnnaBridge 165:e614a9f1c9e2 192 hpcd->IN_ep[index].xfer_len = 0U;
<> 144:ef7eb2e8f9f7 193 }
AnnaBridge 165:e614a9f1c9e2 194
AnnaBridge 165:e614a9f1c9e2 195 for (index = 0U; index < 15U ; index++)
<> 144:ef7eb2e8f9f7 196 {
AnnaBridge 165:e614a9f1c9e2 197 hpcd->OUT_ep[index].is_in = 0U;
<> 144:ef7eb2e8f9f7 198 hpcd->OUT_ep[index].num = index;
<> 144:ef7eb2e8f9f7 199 hpcd->IN_ep[index].tx_fifo_num = index;
<> 144:ef7eb2e8f9f7 200 /* Control until ep is activated */
<> 144:ef7eb2e8f9f7 201 hpcd->OUT_ep[index].type = EP_TYPE_CTRL;
AnnaBridge 165:e614a9f1c9e2 202 hpcd->OUT_ep[index].maxpacket = 0U;
AnnaBridge 165:e614a9f1c9e2 203 hpcd->OUT_ep[index].xfer_buff = 0U;
AnnaBridge 165:e614a9f1c9e2 204 hpcd->OUT_ep[index].xfer_len = 0U;
<> 144:ef7eb2e8f9f7 205 }
<> 144:ef7eb2e8f9f7 206
<> 144:ef7eb2e8f9f7 207 /* Init Device */
<> 144:ef7eb2e8f9f7 208 USB_DevInit(hpcd->Instance, hpcd->Init);
<> 144:ef7eb2e8f9f7 209
AnnaBridge 165:e614a9f1c9e2 210 hpcd->USB_Address = 0U;
<> 144:ef7eb2e8f9f7 211 hpcd->State= HAL_PCD_STATE_READY;
<> 144:ef7eb2e8f9f7 212
<> 144:ef7eb2e8f9f7 213 USB_DevDisconnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 214 return HAL_OK;
<> 144:ef7eb2e8f9f7 215 }
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 /**
<> 144:ef7eb2e8f9f7 218 * @brief DeInitializes the PCD peripheral
<> 144:ef7eb2e8f9f7 219 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 220 * @retval HAL status
<> 144:ef7eb2e8f9f7 221 */
<> 144:ef7eb2e8f9f7 222 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 223 {
<> 144:ef7eb2e8f9f7 224 /* Check the PCD handle allocation */
<> 144:ef7eb2e8f9f7 225 if(hpcd == NULL)
<> 144:ef7eb2e8f9f7 226 {
<> 144:ef7eb2e8f9f7 227 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 228 }
AnnaBridge 165:e614a9f1c9e2 229
<> 144:ef7eb2e8f9f7 230 hpcd->State = HAL_PCD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 231
<> 144:ef7eb2e8f9f7 232 /* Stop Device */
<> 144:ef7eb2e8f9f7 233 HAL_PCD_Stop(hpcd);
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 236 HAL_PCD_MspDeInit(hpcd);
<> 144:ef7eb2e8f9f7 237
<> 144:ef7eb2e8f9f7 238 hpcd->State = HAL_PCD_STATE_RESET;
<> 144:ef7eb2e8f9f7 239
<> 144:ef7eb2e8f9f7 240 return HAL_OK;
<> 144:ef7eb2e8f9f7 241 }
<> 144:ef7eb2e8f9f7 242
<> 144:ef7eb2e8f9f7 243 /**
<> 144:ef7eb2e8f9f7 244 * @brief Initializes the PCD MSP.
<> 144:ef7eb2e8f9f7 245 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 246 * @retval None
<> 144:ef7eb2e8f9f7 247 */
<> 144:ef7eb2e8f9f7 248 __weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 249 {
<> 144:ef7eb2e8f9f7 250 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 251 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 252 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 253 the HAL_PCD_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 254 */
<> 144:ef7eb2e8f9f7 255 }
<> 144:ef7eb2e8f9f7 256
<> 144:ef7eb2e8f9f7 257 /**
<> 144:ef7eb2e8f9f7 258 * @brief DeInitializes PCD MSP.
<> 144:ef7eb2e8f9f7 259 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 260 * @retval None
<> 144:ef7eb2e8f9f7 261 */
<> 144:ef7eb2e8f9f7 262 __weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 263 {
<> 144:ef7eb2e8f9f7 264 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 265 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 266 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 267 the HAL_PCD_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 268 */
<> 144:ef7eb2e8f9f7 269 }
<> 144:ef7eb2e8f9f7 270
<> 144:ef7eb2e8f9f7 271 /**
<> 144:ef7eb2e8f9f7 272 * @}
<> 144:ef7eb2e8f9f7 273 */
<> 144:ef7eb2e8f9f7 274
<> 144:ef7eb2e8f9f7 275 /** @defgroup PCD_Exported_Functions_Group2 IO operation functions
<> 144:ef7eb2e8f9f7 276 * @brief Data transfers functions
<> 144:ef7eb2e8f9f7 277 *
<> 144:ef7eb2e8f9f7 278 @verbatim
<> 144:ef7eb2e8f9f7 279 ===============================================================================
<> 144:ef7eb2e8f9f7 280 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 281 ===============================================================================
<> 144:ef7eb2e8f9f7 282 [..]
<> 144:ef7eb2e8f9f7 283 This subsection provides a set of functions allowing to manage the PCD data
<> 144:ef7eb2e8f9f7 284 transfers.
<> 144:ef7eb2e8f9f7 285
<> 144:ef7eb2e8f9f7 286 @endverbatim
<> 144:ef7eb2e8f9f7 287 * @{
<> 144:ef7eb2e8f9f7 288 */
<> 144:ef7eb2e8f9f7 289
<> 144:ef7eb2e8f9f7 290 /**
<> 144:ef7eb2e8f9f7 291 * @brief Start The USB Device.
<> 144:ef7eb2e8f9f7 292 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 293 * @retval HAL status
<> 144:ef7eb2e8f9f7 294 */
<> 144:ef7eb2e8f9f7 295 HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 296 {
<> 144:ef7eb2e8f9f7 297 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 298 HAL_PCDEx_SetConnectionState (hpcd, 1);
<> 144:ef7eb2e8f9f7 299 USB_DevConnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 300 __HAL_PCD_ENABLE(hpcd);
<> 144:ef7eb2e8f9f7 301 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 302 return HAL_OK;
<> 144:ef7eb2e8f9f7 303 }
<> 144:ef7eb2e8f9f7 304
<> 144:ef7eb2e8f9f7 305 /**
<> 144:ef7eb2e8f9f7 306 * @brief Stop The USB Device.
<> 144:ef7eb2e8f9f7 307 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 308 * @retval HAL status
<> 144:ef7eb2e8f9f7 309 */
<> 144:ef7eb2e8f9f7 310 HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
AnnaBridge 165:e614a9f1c9e2 311 {
<> 144:ef7eb2e8f9f7 312 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 313 __HAL_PCD_DISABLE(hpcd);
<> 144:ef7eb2e8f9f7 314 USB_StopDevice(hpcd->Instance);
<> 144:ef7eb2e8f9f7 315 USB_DevDisconnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 316 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 317 return HAL_OK;
<> 144:ef7eb2e8f9f7 318 }
<> 144:ef7eb2e8f9f7 319
<> 144:ef7eb2e8f9f7 320 #if defined (USB_OTG_FS)
<> 144:ef7eb2e8f9f7 321 /**
<> 144:ef7eb2e8f9f7 322 * @brief This function handles PCD interrupt request.
<> 144:ef7eb2e8f9f7 323 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 324 * @retval HAL status
<> 144:ef7eb2e8f9f7 325 */
<> 144:ef7eb2e8f9f7 326 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 327 {
<> 144:ef7eb2e8f9f7 328 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
AnnaBridge 165:e614a9f1c9e2 329 uint32_t index = 0U, ep_intr = 0U, epint = 0U, epnum = 0U;
AnnaBridge 165:e614a9f1c9e2 330 uint32_t fifoemptymsk = 0U, temp = 0U;
<> 144:ef7eb2e8f9f7 331 USB_OTG_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 332
<> 144:ef7eb2e8f9f7 333 /* ensure that we are in device mode */
<> 144:ef7eb2e8f9f7 334 if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)
<> 144:ef7eb2e8f9f7 335 {
<> 144:ef7eb2e8f9f7 336 /* avoid spurious interrupt */
<> 144:ef7eb2e8f9f7 337 if(__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))
<> 144:ef7eb2e8f9f7 338 {
<> 144:ef7eb2e8f9f7 339 return;
<> 144:ef7eb2e8f9f7 340 }
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))
<> 144:ef7eb2e8f9f7 343 {
<> 144:ef7eb2e8f9f7 344 /* incorrect mode, acknowledge the interrupt */
<> 144:ef7eb2e8f9f7 345 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);
<> 144:ef7eb2e8f9f7 346 }
<> 144:ef7eb2e8f9f7 347
<> 144:ef7eb2e8f9f7 348 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))
<> 144:ef7eb2e8f9f7 349 {
AnnaBridge 165:e614a9f1c9e2 350 epnum = 0U;
<> 144:ef7eb2e8f9f7 351
<> 144:ef7eb2e8f9f7 352 /* Read in the device interrupt bits */
<> 144:ef7eb2e8f9f7 353 ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 while ( ep_intr )
<> 144:ef7eb2e8f9f7 356 {
AnnaBridge 165:e614a9f1c9e2 357 if (ep_intr & 0x1U)
<> 144:ef7eb2e8f9f7 358 {
<> 144:ef7eb2e8f9f7 359 epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, epnum);
<> 144:ef7eb2e8f9f7 360
<> 144:ef7eb2e8f9f7 361 if(( epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
<> 144:ef7eb2e8f9f7 362 {
<> 144:ef7eb2e8f9f7 363 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
<> 144:ef7eb2e8f9f7 364
<> 144:ef7eb2e8f9f7 365 HAL_PCD_DataOutStageCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 366 }
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 if(( epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)
<> 144:ef7eb2e8f9f7 369 {
<> 144:ef7eb2e8f9f7 370 /* Inform the upper layer that a setup packet is available */
<> 144:ef7eb2e8f9f7 371 HAL_PCD_SetupStageCallback(hpcd);
<> 144:ef7eb2e8f9f7 372 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);
<> 144:ef7eb2e8f9f7 373 }
<> 144:ef7eb2e8f9f7 374
<> 144:ef7eb2e8f9f7 375 if(( epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)
<> 144:ef7eb2e8f9f7 376 {
<> 144:ef7eb2e8f9f7 377 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);
<> 144:ef7eb2e8f9f7 378 }
<> 144:ef7eb2e8f9f7 379 }
<> 144:ef7eb2e8f9f7 380 epnum++;
AnnaBridge 165:e614a9f1c9e2 381 ep_intr >>= 1U;
<> 144:ef7eb2e8f9f7 382 }
<> 144:ef7eb2e8f9f7 383 }
<> 144:ef7eb2e8f9f7 384
<> 144:ef7eb2e8f9f7 385 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))
<> 144:ef7eb2e8f9f7 386 {
<> 144:ef7eb2e8f9f7 387 /* Read in the device interrupt bits */
<> 144:ef7eb2e8f9f7 388 ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);
<> 144:ef7eb2e8f9f7 389
AnnaBridge 165:e614a9f1c9e2 390 epnum = 0U;
<> 144:ef7eb2e8f9f7 391
<> 144:ef7eb2e8f9f7 392 while ( ep_intr )
<> 144:ef7eb2e8f9f7 393 {
AnnaBridge 165:e614a9f1c9e2 394 if (ep_intr & 0x1U) /* In ITR */
<> 144:ef7eb2e8f9f7 395 {
<> 144:ef7eb2e8f9f7 396 epint = USB_ReadDevInEPInterrupt(hpcd->Instance, epnum);
AnnaBridge 165:e614a9f1c9e2 397
<> 144:ef7eb2e8f9f7 398 if(( epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)
<> 144:ef7eb2e8f9f7 399 {
AnnaBridge 165:e614a9f1c9e2 400 fifoemptymsk = 0x1U << epnum;
<> 144:ef7eb2e8f9f7 401 USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;
<> 144:ef7eb2e8f9f7 402
<> 144:ef7eb2e8f9f7 403 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);
<> 144:ef7eb2e8f9f7 404
<> 144:ef7eb2e8f9f7 405 HAL_PCD_DataInStageCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 406 }
<> 144:ef7eb2e8f9f7 407 if(( epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)
<> 144:ef7eb2e8f9f7 408 {
<> 144:ef7eb2e8f9f7 409 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);
<> 144:ef7eb2e8f9f7 410 }
<> 144:ef7eb2e8f9f7 411 if(( epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)
<> 144:ef7eb2e8f9f7 412 {
<> 144:ef7eb2e8f9f7 413 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);
<> 144:ef7eb2e8f9f7 414 }
<> 144:ef7eb2e8f9f7 415 if(( epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)
<> 144:ef7eb2e8f9f7 416 {
<> 144:ef7eb2e8f9f7 417 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);
<> 144:ef7eb2e8f9f7 418 }
<> 144:ef7eb2e8f9f7 419 if(( epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
<> 144:ef7eb2e8f9f7 420 {
<> 144:ef7eb2e8f9f7 421 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);
<> 144:ef7eb2e8f9f7 422 }
<> 144:ef7eb2e8f9f7 423 if(( epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)
<> 144:ef7eb2e8f9f7 424 {
<> 144:ef7eb2e8f9f7 425 PCD_WriteEmptyTxFifo(hpcd , epnum);
<> 144:ef7eb2e8f9f7 426 }
<> 144:ef7eb2e8f9f7 427 }
<> 144:ef7eb2e8f9f7 428 epnum++;
AnnaBridge 165:e614a9f1c9e2 429 ep_intr >>= 1U;
<> 144:ef7eb2e8f9f7 430 }
<> 144:ef7eb2e8f9f7 431 }
<> 144:ef7eb2e8f9f7 432
<> 144:ef7eb2e8f9f7 433 /* Handle Resume Interrupt */
<> 144:ef7eb2e8f9f7 434 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))
<> 144:ef7eb2e8f9f7 435 {
<> 144:ef7eb2e8f9f7 436 /* Clear the Remote Wake-up signalling */
<> 144:ef7eb2e8f9f7 437 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
<> 144:ef7eb2e8f9f7 438
<> 144:ef7eb2e8f9f7 439 HAL_PCD_ResumeCallback(hpcd);
<> 144:ef7eb2e8f9f7 440
<> 144:ef7eb2e8f9f7 441 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);
<> 144:ef7eb2e8f9f7 442 }
<> 144:ef7eb2e8f9f7 443
<> 144:ef7eb2e8f9f7 444 /* Handle Suspend Interrupt */
<> 144:ef7eb2e8f9f7 445 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))
<> 144:ef7eb2e8f9f7 446 {
<> 144:ef7eb2e8f9f7 447 if((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
<> 144:ef7eb2e8f9f7 448 {
<> 144:ef7eb2e8f9f7 449
<> 144:ef7eb2e8f9f7 450 HAL_PCD_SuspendCallback(hpcd);
<> 144:ef7eb2e8f9f7 451 }
<> 144:ef7eb2e8f9f7 452 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);
<> 144:ef7eb2e8f9f7 453 }
AnnaBridge 165:e614a9f1c9e2 454
<> 144:ef7eb2e8f9f7 455 /* Handle Reset Interrupt */
<> 144:ef7eb2e8f9f7 456 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))
<> 144:ef7eb2e8f9f7 457 {
<> 144:ef7eb2e8f9f7 458 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
AnnaBridge 165:e614a9f1c9e2 459 USB_FlushTxFifo(hpcd->Instance , 0x10U);
<> 144:ef7eb2e8f9f7 460
AnnaBridge 165:e614a9f1c9e2 461 for (index = 0U; index < hpcd->Init.dev_endpoints ; index++)
<> 144:ef7eb2e8f9f7 462 {
AnnaBridge 165:e614a9f1c9e2 463 USBx_INEP(index)->DIEPINT = 0xFFU;
AnnaBridge 165:e614a9f1c9e2 464 USBx_OUTEP(index)->DOEPINT = 0xFFU;
<> 144:ef7eb2e8f9f7 465 }
AnnaBridge 165:e614a9f1c9e2 466 USBx_DEVICE->DAINT = 0xFFFFFFFFU;
AnnaBridge 165:e614a9f1c9e2 467 USBx_DEVICE->DAINTMSK |= 0x10001U;
<> 144:ef7eb2e8f9f7 468
<> 144:ef7eb2e8f9f7 469 USBx_DEVICE->DOEPMSK |= (USB_OTG_DOEPMSK_STUPM | USB_OTG_DOEPMSK_XFRCM | USB_OTG_DOEPMSK_EPDM);
<> 144:ef7eb2e8f9f7 470 USBx_DEVICE->DIEPMSK |= (USB_OTG_DIEPMSK_TOM | USB_OTG_DIEPMSK_XFRCM | USB_OTG_DIEPMSK_EPDM);
<> 144:ef7eb2e8f9f7 471
<> 144:ef7eb2e8f9f7 472 /* Set Default Address to 0 */
<> 144:ef7eb2e8f9f7 473 USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;
<> 144:ef7eb2e8f9f7 474
<> 144:ef7eb2e8f9f7 475 /* setup EP0 to receive SETUP packets */
<> 144:ef7eb2e8f9f7 476 USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 477
<> 144:ef7eb2e8f9f7 478 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);
<> 144:ef7eb2e8f9f7 479 }
<> 144:ef7eb2e8f9f7 480
<> 144:ef7eb2e8f9f7 481 /* Handle Enumeration done Interrupt */
<> 144:ef7eb2e8f9f7 482 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))
<> 144:ef7eb2e8f9f7 483 {
<> 144:ef7eb2e8f9f7 484 USB_ActivateSetup(hpcd->Instance);
<> 144:ef7eb2e8f9f7 485 hpcd->Instance->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;
<> 144:ef7eb2e8f9f7 486
<> 144:ef7eb2e8f9f7 487 hpcd->Init.speed = USB_OTG_SPEED_FULL;
<> 144:ef7eb2e8f9f7 488 hpcd->Init.ep0_mps = USB_OTG_FS_MAX_PACKET_SIZE ;
AnnaBridge 165:e614a9f1c9e2 489 hpcd->Instance->GUSBCFG |= (uint32_t)((USBD_FS_TRDT_VALUE << 10U) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 490
<> 144:ef7eb2e8f9f7 491 HAL_PCD_ResetCallback(hpcd);
<> 144:ef7eb2e8f9f7 492
<> 144:ef7eb2e8f9f7 493 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);
<> 144:ef7eb2e8f9f7 494 }
AnnaBridge 165:e614a9f1c9e2 495
<> 144:ef7eb2e8f9f7 496 /* Handle RxQLevel Interrupt */
<> 144:ef7eb2e8f9f7 497 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))
<> 144:ef7eb2e8f9f7 498 {
<> 144:ef7eb2e8f9f7 499 USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<> 144:ef7eb2e8f9f7 500 temp = USBx->GRXSTSP;
<> 144:ef7eb2e8f9f7 501 ep = &hpcd->OUT_ep[temp & USB_OTG_GRXSTSP_EPNUM];
<> 144:ef7eb2e8f9f7 502
AnnaBridge 165:e614a9f1c9e2 503 if(((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17U) == STS_DATA_UPDT)
<> 144:ef7eb2e8f9f7 504 {
AnnaBridge 165:e614a9f1c9e2 505 if((temp & USB_OTG_GRXSTSP_BCNT) != 0U)
<> 144:ef7eb2e8f9f7 506 {
AnnaBridge 165:e614a9f1c9e2 507 USB_ReadPacket(USBx, ep->xfer_buff, (temp & USB_OTG_GRXSTSP_BCNT) >> 4U);
AnnaBridge 165:e614a9f1c9e2 508 ep->xfer_buff += (temp & USB_OTG_GRXSTSP_BCNT) >> 4U;
AnnaBridge 165:e614a9f1c9e2 509 ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4U;
<> 144:ef7eb2e8f9f7 510 }
<> 144:ef7eb2e8f9f7 511 }
AnnaBridge 165:e614a9f1c9e2 512 else if (((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17U) == STS_SETUP_UPDT)
<> 144:ef7eb2e8f9f7 513 {
AnnaBridge 165:e614a9f1c9e2 514 USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8U);
AnnaBridge 165:e614a9f1c9e2 515 ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4U;
<> 144:ef7eb2e8f9f7 516 }
<> 144:ef7eb2e8f9f7 517 USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<> 144:ef7eb2e8f9f7 518 }
<> 144:ef7eb2e8f9f7 519
<> 144:ef7eb2e8f9f7 520 /* Handle SOF Interrupt */
<> 144:ef7eb2e8f9f7 521 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 HAL_PCD_SOFCallback(hpcd);
<> 144:ef7eb2e8f9f7 524 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);
<> 144:ef7eb2e8f9f7 525 }
<> 144:ef7eb2e8f9f7 526
<> 144:ef7eb2e8f9f7 527 /* Handle Incomplete ISO IN Interrupt */
<> 144:ef7eb2e8f9f7 528 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))
<> 144:ef7eb2e8f9f7 529 {
<> 144:ef7eb2e8f9f7 530 HAL_PCD_ISOINIncompleteCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 531 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);
<> 144:ef7eb2e8f9f7 532 }
<> 144:ef7eb2e8f9f7 533
<> 144:ef7eb2e8f9f7 534 /* Handle Incomplete ISO OUT Interrupt */
<> 144:ef7eb2e8f9f7 535 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
<> 144:ef7eb2e8f9f7 536 {
<> 144:ef7eb2e8f9f7 537 HAL_PCD_ISOOUTIncompleteCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 538 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
<> 144:ef7eb2e8f9f7 539 }
<> 144:ef7eb2e8f9f7 540
<> 144:ef7eb2e8f9f7 541 /* Handle Connection event Interrupt */
<> 144:ef7eb2e8f9f7 542 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
<> 144:ef7eb2e8f9f7 543 {
<> 144:ef7eb2e8f9f7 544 HAL_PCD_ConnectCallback(hpcd);
<> 144:ef7eb2e8f9f7 545 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
<> 144:ef7eb2e8f9f7 546 }
<> 144:ef7eb2e8f9f7 547
<> 144:ef7eb2e8f9f7 548 /* Handle Disconnection event Interrupt */
<> 144:ef7eb2e8f9f7 549 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))
<> 144:ef7eb2e8f9f7 550 {
<> 144:ef7eb2e8f9f7 551 temp = hpcd->Instance->GOTGINT;
<> 144:ef7eb2e8f9f7 552
<> 144:ef7eb2e8f9f7 553 if((temp & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)
<> 144:ef7eb2e8f9f7 554 {
<> 144:ef7eb2e8f9f7 555 HAL_PCD_DisconnectCallback(hpcd);
<> 144:ef7eb2e8f9f7 556 }
<> 144:ef7eb2e8f9f7 557 hpcd->Instance->GOTGINT |= temp;
<> 144:ef7eb2e8f9f7 558 }
<> 144:ef7eb2e8f9f7 559 }
<> 144:ef7eb2e8f9f7 560 }
<> 144:ef7eb2e8f9f7 561 #endif /* USB_OTG_FS */
<> 144:ef7eb2e8f9f7 562
<> 144:ef7eb2e8f9f7 563 #if defined (USB)
<> 144:ef7eb2e8f9f7 564 /**
<> 144:ef7eb2e8f9f7 565 * @brief This function handles PCD interrupt request.
<> 144:ef7eb2e8f9f7 566 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 567 * @retval HAL status
<> 144:ef7eb2e8f9f7 568 */
<> 144:ef7eb2e8f9f7 569 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
AnnaBridge 165:e614a9f1c9e2 570 {
<> 144:ef7eb2e8f9f7 571 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_CTR))
<> 144:ef7eb2e8f9f7 572 {
<> 144:ef7eb2e8f9f7 573 /* servicing of the endpoint correct transfer interrupt */
<> 144:ef7eb2e8f9f7 574 /* clear of the CTR flag into the sub */
<> 144:ef7eb2e8f9f7 575 PCD_EP_ISR_Handler(hpcd);
<> 144:ef7eb2e8f9f7 576 }
<> 144:ef7eb2e8f9f7 577
<> 144:ef7eb2e8f9f7 578 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_RESET))
<> 144:ef7eb2e8f9f7 579 {
<> 144:ef7eb2e8f9f7 580 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
<> 144:ef7eb2e8f9f7 581 HAL_PCD_ResetCallback(hpcd);
AnnaBridge 165:e614a9f1c9e2 582 HAL_PCD_SetAddress(hpcd, 0U);
<> 144:ef7eb2e8f9f7 583 }
<> 144:ef7eb2e8f9f7 584
<> 144:ef7eb2e8f9f7 585 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_PMAOVR))
<> 144:ef7eb2e8f9f7 586 {
<> 144:ef7eb2e8f9f7 587 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
<> 144:ef7eb2e8f9f7 588 }
<> 144:ef7eb2e8f9f7 589 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ERR))
<> 144:ef7eb2e8f9f7 590 {
<> 144:ef7eb2e8f9f7 591 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
<> 144:ef7eb2e8f9f7 592 }
<> 144:ef7eb2e8f9f7 593
<> 144:ef7eb2e8f9f7 594 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP))
AnnaBridge 165:e614a9f1c9e2 595 {
<> 144:ef7eb2e8f9f7 596 hpcd->Instance->CNTR &= ~(USB_CNTR_LP_MODE);
AnnaBridge 165:e614a9f1c9e2 597 hpcd->Instance->CNTR &= ~(USB_CNTR_FSUSP);
<> 144:ef7eb2e8f9f7 598
<> 144:ef7eb2e8f9f7 599 HAL_PCD_ResumeCallback(hpcd);
AnnaBridge 165:e614a9f1c9e2 600
<> 144:ef7eb2e8f9f7 601 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
<> 144:ef7eb2e8f9f7 602 }
<> 144:ef7eb2e8f9f7 603
<> 144:ef7eb2e8f9f7 604 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SUSP))
AnnaBridge 165:e614a9f1c9e2 605 {
AnnaBridge 165:e614a9f1c9e2 606 /* Force low-power mode in the macrocell */
AnnaBridge 165:e614a9f1c9e2 607 hpcd->Instance->CNTR |= USB_CNTR_FSUSP;
AnnaBridge 165:e614a9f1c9e2 608
<> 144:ef7eb2e8f9f7 609 /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
<> 144:ef7eb2e8f9f7 610 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);
AnnaBridge 165:e614a9f1c9e2 611
<> 144:ef7eb2e8f9f7 612 hpcd->Instance->CNTR |= USB_CNTR_LP_MODE;
AnnaBridge 165:e614a9f1c9e2 613 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP) == 0U)
<> 144:ef7eb2e8f9f7 614 {
<> 144:ef7eb2e8f9f7 615 HAL_PCD_SuspendCallback(hpcd);
<> 144:ef7eb2e8f9f7 616 }
<> 144:ef7eb2e8f9f7 617 }
<> 144:ef7eb2e8f9f7 618
<> 144:ef7eb2e8f9f7 619 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SOF))
<> 144:ef7eb2e8f9f7 620 {
<> 144:ef7eb2e8f9f7 621 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
<> 144:ef7eb2e8f9f7 622 HAL_PCD_SOFCallback(hpcd);
<> 144:ef7eb2e8f9f7 623 }
<> 144:ef7eb2e8f9f7 624
<> 144:ef7eb2e8f9f7 625 if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ESOF))
<> 144:ef7eb2e8f9f7 626 {
<> 144:ef7eb2e8f9f7 627 /* clear ESOF flag in ISTR */
<> 144:ef7eb2e8f9f7 628 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
<> 144:ef7eb2e8f9f7 629 }
<> 144:ef7eb2e8f9f7 630 }
<> 144:ef7eb2e8f9f7 631 #endif /* USB */
<> 144:ef7eb2e8f9f7 632
<> 144:ef7eb2e8f9f7 633 /**
<> 144:ef7eb2e8f9f7 634 * @brief Data out stage callbacks
<> 144:ef7eb2e8f9f7 635 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 636 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 637 * @retval None
<> 144:ef7eb2e8f9f7 638 */
<> 144:ef7eb2e8f9f7 639 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 640 {
<> 144:ef7eb2e8f9f7 641 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 642 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 643 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 644 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 645 the HAL_PCD_DataOutStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 646 */
<> 144:ef7eb2e8f9f7 647 }
<> 144:ef7eb2e8f9f7 648
<> 144:ef7eb2e8f9f7 649 /**
<> 144:ef7eb2e8f9f7 650 * @brief Data IN stage callbacks
<> 144:ef7eb2e8f9f7 651 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 652 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 653 * @retval None
<> 144:ef7eb2e8f9f7 654 */
<> 144:ef7eb2e8f9f7 655 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 656 {
<> 144:ef7eb2e8f9f7 657 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 658 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 659 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 660 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 661 the HAL_PCD_DataInStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 662 */
<> 144:ef7eb2e8f9f7 663 }
<> 144:ef7eb2e8f9f7 664 /**
<> 144:ef7eb2e8f9f7 665 * @brief Setup stage callback
<> 144:ef7eb2e8f9f7 666 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 667 * @retval None
<> 144:ef7eb2e8f9f7 668 */
<> 144:ef7eb2e8f9f7 669 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 670 {
<> 144:ef7eb2e8f9f7 671 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 672 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 673 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 674 the HAL_PCD_SetupStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 675 */
<> 144:ef7eb2e8f9f7 676 }
<> 144:ef7eb2e8f9f7 677
<> 144:ef7eb2e8f9f7 678 /**
<> 144:ef7eb2e8f9f7 679 * @brief USB Start Of Frame callbacks
<> 144:ef7eb2e8f9f7 680 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 681 * @retval None
<> 144:ef7eb2e8f9f7 682 */
<> 144:ef7eb2e8f9f7 683 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 684 {
<> 144:ef7eb2e8f9f7 685 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 686 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 687 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 688 the HAL_PCD_SOFCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 689 */
<> 144:ef7eb2e8f9f7 690 }
<> 144:ef7eb2e8f9f7 691
<> 144:ef7eb2e8f9f7 692 /**
<> 144:ef7eb2e8f9f7 693 * @brief USB Reset callbacks
<> 144:ef7eb2e8f9f7 694 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 695 * @retval None
<> 144:ef7eb2e8f9f7 696 */
<> 144:ef7eb2e8f9f7 697 __weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 698 {
<> 144:ef7eb2e8f9f7 699 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 700 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 701 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 702 the HAL_PCD_ResetCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 703 */
<> 144:ef7eb2e8f9f7 704 }
<> 144:ef7eb2e8f9f7 705
<> 144:ef7eb2e8f9f7 706 /**
<> 144:ef7eb2e8f9f7 707 * @brief Suspend event callbacks
<> 144:ef7eb2e8f9f7 708 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 709 * @retval None
<> 144:ef7eb2e8f9f7 710 */
<> 144:ef7eb2e8f9f7 711 __weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 712 {
<> 144:ef7eb2e8f9f7 713 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 714 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 715 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 716 the HAL_PCD_SuspendCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 717 */
<> 144:ef7eb2e8f9f7 718 }
<> 144:ef7eb2e8f9f7 719
<> 144:ef7eb2e8f9f7 720 /**
<> 144:ef7eb2e8f9f7 721 * @brief Resume event callbacks
<> 144:ef7eb2e8f9f7 722 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 723 * @retval None
<> 144:ef7eb2e8f9f7 724 */
<> 144:ef7eb2e8f9f7 725 __weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 726 {
<> 144:ef7eb2e8f9f7 727 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 728 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 729 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 730 the HAL_PCD_ResumeCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 731 */
<> 144:ef7eb2e8f9f7 732 }
<> 144:ef7eb2e8f9f7 733
<> 144:ef7eb2e8f9f7 734 /**
<> 144:ef7eb2e8f9f7 735 * @brief Incomplete ISO OUT callbacks
<> 144:ef7eb2e8f9f7 736 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 737 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 738 * @retval None
<> 144:ef7eb2e8f9f7 739 */
<> 144:ef7eb2e8f9f7 740 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 741 {
<> 144:ef7eb2e8f9f7 742 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 743 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 744 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 745 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 746 the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 747 */
<> 144:ef7eb2e8f9f7 748 }
<> 144:ef7eb2e8f9f7 749
<> 144:ef7eb2e8f9f7 750 /**
<> 144:ef7eb2e8f9f7 751 * @brief Incomplete ISO IN callbacks
<> 144:ef7eb2e8f9f7 752 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 753 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 754 * @retval None
<> 144:ef7eb2e8f9f7 755 */
<> 144:ef7eb2e8f9f7 756 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 757 {
<> 144:ef7eb2e8f9f7 758 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 759 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 760 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 761 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 762 the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 763 */
<> 144:ef7eb2e8f9f7 764 }
<> 144:ef7eb2e8f9f7 765
<> 144:ef7eb2e8f9f7 766 /**
<> 144:ef7eb2e8f9f7 767 * @brief Connection event callbacks
<> 144:ef7eb2e8f9f7 768 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 769 * @retval None
<> 144:ef7eb2e8f9f7 770 */
<> 144:ef7eb2e8f9f7 771 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 772 {
<> 144:ef7eb2e8f9f7 773 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 774 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 775 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 776 the HAL_PCD_ConnectCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 777 */
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779
<> 144:ef7eb2e8f9f7 780 /**
<> 144:ef7eb2e8f9f7 781 * @brief Disconnection event callbacks
<> 144:ef7eb2e8f9f7 782 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 783 * @retval None
<> 144:ef7eb2e8f9f7 784 */
<> 144:ef7eb2e8f9f7 785 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 786 {
<> 144:ef7eb2e8f9f7 787 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 788 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 789 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 790 the HAL_PCD_DisconnectCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 791 */
<> 144:ef7eb2e8f9f7 792 }
<> 144:ef7eb2e8f9f7 793
<> 144:ef7eb2e8f9f7 794 /**
<> 144:ef7eb2e8f9f7 795 * @}
<> 144:ef7eb2e8f9f7 796 */
<> 144:ef7eb2e8f9f7 797
<> 144:ef7eb2e8f9f7 798 /** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
<> 144:ef7eb2e8f9f7 799 * @brief management functions
<> 144:ef7eb2e8f9f7 800 *
<> 144:ef7eb2e8f9f7 801 @verbatim
<> 144:ef7eb2e8f9f7 802 ===============================================================================
<> 144:ef7eb2e8f9f7 803 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 804 ===============================================================================
<> 144:ef7eb2e8f9f7 805 [..]
<> 144:ef7eb2e8f9f7 806 This subsection provides a set of functions allowing to control the PCD data
<> 144:ef7eb2e8f9f7 807 transfers.
<> 144:ef7eb2e8f9f7 808
<> 144:ef7eb2e8f9f7 809 @endverbatim
<> 144:ef7eb2e8f9f7 810 * @{
<> 144:ef7eb2e8f9f7 811 */
<> 144:ef7eb2e8f9f7 812
<> 144:ef7eb2e8f9f7 813 /**
<> 144:ef7eb2e8f9f7 814 * @brief Connect the USB device
<> 144:ef7eb2e8f9f7 815 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 816 * @retval HAL status
<> 144:ef7eb2e8f9f7 817 */
<> 144:ef7eb2e8f9f7 818 HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 819 {
<> 144:ef7eb2e8f9f7 820 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 821 HAL_PCDEx_SetConnectionState (hpcd, 1);
<> 144:ef7eb2e8f9f7 822 USB_DevConnect(hpcd->Instance);
<> 144:ef7eb2e8f9f7 823 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 824 return HAL_OK;
<> 144:ef7eb2e8f9f7 825 }
<> 144:ef7eb2e8f9f7 826
<> 144:ef7eb2e8f9f7 827 /**
<> 144:ef7eb2e8f9f7 828 * @brief Disconnect the USB device
<> 144:ef7eb2e8f9f7 829 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 830 * @retval HAL status
<> 144:ef7eb2e8f9f7 831 */
<> 144:ef7eb2e8f9f7 832 HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 833 {
<> 144:ef7eb2e8f9f7 834 __HAL_LOCK(hpcd);
AnnaBridge 165:e614a9f1c9e2 835 HAL_PCDEx_SetConnectionState (hpcd, 0U);
<> 144:ef7eb2e8f9f7 836 USB_DevDisconnect(hpcd->Instance);
<> 144:ef7eb2e8f9f7 837 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 838 return HAL_OK;
<> 144:ef7eb2e8f9f7 839 }
<> 144:ef7eb2e8f9f7 840
<> 144:ef7eb2e8f9f7 841 /**
<> 144:ef7eb2e8f9f7 842 * @brief Set the USB Device address
<> 144:ef7eb2e8f9f7 843 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 844 * @param address: new device address
<> 144:ef7eb2e8f9f7 845 * @retval HAL status
<> 144:ef7eb2e8f9f7 846 */
<> 144:ef7eb2e8f9f7 847 HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
<> 144:ef7eb2e8f9f7 848 {
<> 144:ef7eb2e8f9f7 849 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 850 hpcd->USB_Address = address;
<> 144:ef7eb2e8f9f7 851 USB_SetDevAddress(hpcd->Instance, address);
<> 144:ef7eb2e8f9f7 852 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 853 return HAL_OK;
<> 144:ef7eb2e8f9f7 854 }
<> 144:ef7eb2e8f9f7 855 /**
<> 144:ef7eb2e8f9f7 856 * @brief Open and configure an endpoint
<> 144:ef7eb2e8f9f7 857 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 858 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 859 * @param ep_mps: endpoint max packet size
<> 144:ef7eb2e8f9f7 860 * @param ep_type: endpoint type
<> 144:ef7eb2e8f9f7 861 * @retval HAL status
<> 144:ef7eb2e8f9f7 862 */
<> 144:ef7eb2e8f9f7 863 HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint16_t ep_mps, uint8_t ep_type)
<> 144:ef7eb2e8f9f7 864 {
<> 144:ef7eb2e8f9f7 865 HAL_StatusTypeDef ret = HAL_OK;
<> 144:ef7eb2e8f9f7 866 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 867
AnnaBridge 165:e614a9f1c9e2 868 if ((ep_addr & 0x80U) == 0x80U)
<> 144:ef7eb2e8f9f7 869 {
AnnaBridge 165:e614a9f1c9e2 870 ep = &hpcd->IN_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 871 }
<> 144:ef7eb2e8f9f7 872 else
<> 144:ef7eb2e8f9f7 873 {
AnnaBridge 165:e614a9f1c9e2 874 ep = &hpcd->OUT_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 875 }
AnnaBridge 165:e614a9f1c9e2 876 ep->num = ep_addr & 0x7FU;
<> 144:ef7eb2e8f9f7 877
AnnaBridge 165:e614a9f1c9e2 878 ep->is_in = (0x80U & ep_addr) != 0U;
<> 144:ef7eb2e8f9f7 879 ep->maxpacket = ep_mps;
<> 144:ef7eb2e8f9f7 880 ep->type = ep_type;
<> 144:ef7eb2e8f9f7 881
<> 144:ef7eb2e8f9f7 882 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 883 USB_ActivateEndpoint(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 884 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 885 return ret;
<> 144:ef7eb2e8f9f7 886 }
<> 144:ef7eb2e8f9f7 887
<> 144:ef7eb2e8f9f7 888 /**
<> 144:ef7eb2e8f9f7 889 * @brief Deactivate an endpoint
<> 144:ef7eb2e8f9f7 890 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 891 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 892 * @retval HAL status
<> 144:ef7eb2e8f9f7 893 */
<> 144:ef7eb2e8f9f7 894 HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 895 {
<> 144:ef7eb2e8f9f7 896 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 897
AnnaBridge 165:e614a9f1c9e2 898 if ((ep_addr & 0x80U) == 0x80U)
<> 144:ef7eb2e8f9f7 899 {
AnnaBridge 165:e614a9f1c9e2 900 ep = &hpcd->IN_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 901 }
<> 144:ef7eb2e8f9f7 902 else
<> 144:ef7eb2e8f9f7 903 {
AnnaBridge 165:e614a9f1c9e2 904 ep = &hpcd->OUT_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 905 }
AnnaBridge 165:e614a9f1c9e2 906 ep->num = ep_addr & 0x7FU;
<> 144:ef7eb2e8f9f7 907
AnnaBridge 165:e614a9f1c9e2 908 ep->is_in = (0x80U & ep_addr) != 0U;
<> 144:ef7eb2e8f9f7 909
<> 144:ef7eb2e8f9f7 910 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 911 USB_DeactivateEndpoint(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 912 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 913 return HAL_OK;
<> 144:ef7eb2e8f9f7 914 }
<> 144:ef7eb2e8f9f7 915
<> 144:ef7eb2e8f9f7 916
<> 144:ef7eb2e8f9f7 917 /**
<> 144:ef7eb2e8f9f7 918 * @brief Receive an amount of data
<> 144:ef7eb2e8f9f7 919 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 920 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 921 * @param pBuf: pointer to the reception buffer
<> 144:ef7eb2e8f9f7 922 * @param len: amount of data to be received
<> 144:ef7eb2e8f9f7 923 * @retval HAL status
<> 144:ef7eb2e8f9f7 924 */
<> 144:ef7eb2e8f9f7 925 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
<> 144:ef7eb2e8f9f7 926 {
<> 144:ef7eb2e8f9f7 927 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 928
AnnaBridge 165:e614a9f1c9e2 929 ep = &hpcd->OUT_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 930
<> 144:ef7eb2e8f9f7 931 /*setup and start the Xfer */
<> 144:ef7eb2e8f9f7 932 ep->xfer_buff = pBuf;
<> 144:ef7eb2e8f9f7 933 ep->xfer_len = len;
AnnaBridge 165:e614a9f1c9e2 934 ep->xfer_count = 0U;
AnnaBridge 165:e614a9f1c9e2 935 ep->is_in = 0U;
AnnaBridge 165:e614a9f1c9e2 936 ep->num = ep_addr & 0x7FU;
AnnaBridge 165:e614a9f1c9e2 937
AnnaBridge 165:e614a9f1c9e2 938 if ((ep_addr & 0x7FU) == 0U)
<> 144:ef7eb2e8f9f7 939 {
<> 144:ef7eb2e8f9f7 940 USB_EP0StartXfer(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 941 }
<> 144:ef7eb2e8f9f7 942 else
<> 144:ef7eb2e8f9f7 943 {
<> 144:ef7eb2e8f9f7 944 USB_EPStartXfer(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 945 }
AnnaBridge 165:e614a9f1c9e2 946
<> 144:ef7eb2e8f9f7 947 return HAL_OK;
<> 144:ef7eb2e8f9f7 948 }
<> 144:ef7eb2e8f9f7 949
<> 144:ef7eb2e8f9f7 950 /**
<> 144:ef7eb2e8f9f7 951 * @brief Get Received Data Size
<> 144:ef7eb2e8f9f7 952 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 953 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 954 * @retval Data Size
<> 144:ef7eb2e8f9f7 955 */
<> 144:ef7eb2e8f9f7 956 uint16_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 957 {
AnnaBridge 165:e614a9f1c9e2 958 return hpcd->OUT_ep[ep_addr & 0xF].xfer_count;
<> 144:ef7eb2e8f9f7 959 }
<> 144:ef7eb2e8f9f7 960 /**
<> 144:ef7eb2e8f9f7 961 * @brief Send an amount of data
<> 144:ef7eb2e8f9f7 962 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 963 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 964 * @param pBuf: pointer to the transmission buffer
<> 144:ef7eb2e8f9f7 965 * @param len: amount of data to be sent
<> 144:ef7eb2e8f9f7 966 * @retval HAL status
<> 144:ef7eb2e8f9f7 967 */
<> 144:ef7eb2e8f9f7 968 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
<> 144:ef7eb2e8f9f7 969 {
<> 144:ef7eb2e8f9f7 970 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 971
AnnaBridge 165:e614a9f1c9e2 972 ep = &hpcd->IN_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 973
<> 144:ef7eb2e8f9f7 974 /*setup and start the Xfer */
<> 144:ef7eb2e8f9f7 975 ep->xfer_buff = pBuf;
<> 144:ef7eb2e8f9f7 976 ep->xfer_len = len;
AnnaBridge 165:e614a9f1c9e2 977 ep->xfer_count = 0U;
AnnaBridge 165:e614a9f1c9e2 978 ep->is_in = 1U;
AnnaBridge 165:e614a9f1c9e2 979 ep->num = ep_addr & 0x7FU;
AnnaBridge 165:e614a9f1c9e2 980
AnnaBridge 165:e614a9f1c9e2 981 if ((ep_addr & 0x7FU) == 0U)
<> 144:ef7eb2e8f9f7 982 {
<> 144:ef7eb2e8f9f7 983 USB_EP0StartXfer(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 984 }
<> 144:ef7eb2e8f9f7 985 else
<> 144:ef7eb2e8f9f7 986 {
<> 144:ef7eb2e8f9f7 987 USB_EPStartXfer(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 988 }
AnnaBridge 165:e614a9f1c9e2 989
<> 144:ef7eb2e8f9f7 990 return HAL_OK;
<> 144:ef7eb2e8f9f7 991 }
<> 144:ef7eb2e8f9f7 992
<> 144:ef7eb2e8f9f7 993 /**
<> 144:ef7eb2e8f9f7 994 * @brief Set a STALL condition over an endpoint
<> 144:ef7eb2e8f9f7 995 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 996 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 997 * @retval HAL status
<> 144:ef7eb2e8f9f7 998 */
<> 144:ef7eb2e8f9f7 999 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1000 {
<> 144:ef7eb2e8f9f7 1001 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 1002
AnnaBridge 165:e614a9f1c9e2 1003 if ((0x80U & ep_addr) == 0x80U)
<> 144:ef7eb2e8f9f7 1004 {
AnnaBridge 165:e614a9f1c9e2 1005 ep = &hpcd->IN_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 1006 }
<> 144:ef7eb2e8f9f7 1007 else
<> 144:ef7eb2e8f9f7 1008 {
<> 144:ef7eb2e8f9f7 1009 ep = &hpcd->OUT_ep[ep_addr];
<> 144:ef7eb2e8f9f7 1010 }
<> 144:ef7eb2e8f9f7 1011
AnnaBridge 165:e614a9f1c9e2 1012 ep->is_stall = 1U;
AnnaBridge 165:e614a9f1c9e2 1013 ep->num = ep_addr & 0x7FU;
AnnaBridge 165:e614a9f1c9e2 1014 ep->is_in = ((ep_addr & 0x80U) == 0x80U);
<> 144:ef7eb2e8f9f7 1015
<> 144:ef7eb2e8f9f7 1016 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 1017 USB_EPSetStall(hpcd->Instance , ep);
AnnaBridge 165:e614a9f1c9e2 1018 if((ep_addr & 0x7FU) == 0U)
<> 144:ef7eb2e8f9f7 1019 {
<> 144:ef7eb2e8f9f7 1020 USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 1021 }
<> 144:ef7eb2e8f9f7 1022 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 1023
<> 144:ef7eb2e8f9f7 1024 return HAL_OK;
<> 144:ef7eb2e8f9f7 1025 }
<> 144:ef7eb2e8f9f7 1026
<> 144:ef7eb2e8f9f7 1027 /**
<> 144:ef7eb2e8f9f7 1028 * @brief Clear a STALL condition over in an endpoint
<> 144:ef7eb2e8f9f7 1029 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1030 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1031 * @retval HAL status
<> 144:ef7eb2e8f9f7 1032 */
<> 144:ef7eb2e8f9f7 1033 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1034 {
<> 144:ef7eb2e8f9f7 1035 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 1036
AnnaBridge 165:e614a9f1c9e2 1037 if ((0x80U & ep_addr) == 0x80U)
<> 144:ef7eb2e8f9f7 1038 {
AnnaBridge 165:e614a9f1c9e2 1039 ep = &hpcd->IN_ep[ep_addr & 0x7FU];
<> 144:ef7eb2e8f9f7 1040 }
<> 144:ef7eb2e8f9f7 1041 else
<> 144:ef7eb2e8f9f7 1042 {
<> 144:ef7eb2e8f9f7 1043 ep = &hpcd->OUT_ep[ep_addr];
<> 144:ef7eb2e8f9f7 1044 }
<> 144:ef7eb2e8f9f7 1045
AnnaBridge 165:e614a9f1c9e2 1046 ep->is_stall = 0U;
AnnaBridge 165:e614a9f1c9e2 1047 ep->num = ep_addr & 0x7FU;
AnnaBridge 165:e614a9f1c9e2 1048 ep->is_in = ((ep_addr & 0x80U) == 0x80U);
<> 144:ef7eb2e8f9f7 1049
<> 144:ef7eb2e8f9f7 1050 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 1051 USB_EPClearStall(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 1052 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 1053
<> 144:ef7eb2e8f9f7 1054 return HAL_OK;
<> 144:ef7eb2e8f9f7 1055 }
<> 144:ef7eb2e8f9f7 1056
<> 144:ef7eb2e8f9f7 1057 /**
<> 144:ef7eb2e8f9f7 1058 * @brief Flush an endpoint
<> 144:ef7eb2e8f9f7 1059 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1060 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1061 * @retval HAL status
<> 144:ef7eb2e8f9f7 1062 */
<> 144:ef7eb2e8f9f7 1063 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1064 {
<> 144:ef7eb2e8f9f7 1065 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 1066
AnnaBridge 165:e614a9f1c9e2 1067 if ((ep_addr & 0x80U) == 0x80U)
<> 144:ef7eb2e8f9f7 1068 {
AnnaBridge 165:e614a9f1c9e2 1069 USB_FlushTxFifo(hpcd->Instance, ep_addr & 0x7FU);
<> 144:ef7eb2e8f9f7 1070 }
<> 144:ef7eb2e8f9f7 1071 else
<> 144:ef7eb2e8f9f7 1072 {
<> 144:ef7eb2e8f9f7 1073 USB_FlushRxFifo(hpcd->Instance);
<> 144:ef7eb2e8f9f7 1074 }
<> 144:ef7eb2e8f9f7 1075
<> 144:ef7eb2e8f9f7 1076 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 1077
<> 144:ef7eb2e8f9f7 1078 return HAL_OK;
<> 144:ef7eb2e8f9f7 1079 }
<> 144:ef7eb2e8f9f7 1080
<> 144:ef7eb2e8f9f7 1081 /**
<> 144:ef7eb2e8f9f7 1082 * @brief HAL_PCD_ActivateRemoteWakeup : active remote wakeup signalling
<> 144:ef7eb2e8f9f7 1083 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1084 * @retval HAL status
<> 144:ef7eb2e8f9f7 1085 */
<> 144:ef7eb2e8f9f7 1086 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1087 {
<> 144:ef7eb2e8f9f7 1088 return(USB_ActivateRemoteWakeup(hpcd->Instance));
<> 144:ef7eb2e8f9f7 1089 }
<> 144:ef7eb2e8f9f7 1090
<> 144:ef7eb2e8f9f7 1091 /**
<> 144:ef7eb2e8f9f7 1092 * @brief HAL_PCD_DeActivateRemoteWakeup : de-active remote wakeup signalling
<> 144:ef7eb2e8f9f7 1093 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1094 * @retval HAL status
<> 144:ef7eb2e8f9f7 1095 */
<> 144:ef7eb2e8f9f7 1096 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1097 {
<> 144:ef7eb2e8f9f7 1098 return(USB_DeActivateRemoteWakeup(hpcd->Instance));
<> 144:ef7eb2e8f9f7 1099 }
<> 144:ef7eb2e8f9f7 1100 /**
<> 144:ef7eb2e8f9f7 1101 * @}
<> 144:ef7eb2e8f9f7 1102 */
<> 144:ef7eb2e8f9f7 1103
<> 144:ef7eb2e8f9f7 1104 /** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
<> 144:ef7eb2e8f9f7 1105 * @brief Peripheral State functions
<> 144:ef7eb2e8f9f7 1106 *
<> 144:ef7eb2e8f9f7 1107 @verbatim
<> 144:ef7eb2e8f9f7 1108 ===============================================================================
<> 144:ef7eb2e8f9f7 1109 ##### Peripheral State functions #####
<> 144:ef7eb2e8f9f7 1110 ===============================================================================
<> 144:ef7eb2e8f9f7 1111 [..]
<> 144:ef7eb2e8f9f7 1112 This subsection permits to get in run-time the status of the peripheral
<> 144:ef7eb2e8f9f7 1113 and the data flow.
<> 144:ef7eb2e8f9f7 1114
<> 144:ef7eb2e8f9f7 1115 @endverbatim
<> 144:ef7eb2e8f9f7 1116 * @{
<> 144:ef7eb2e8f9f7 1117 */
<> 144:ef7eb2e8f9f7 1118
<> 144:ef7eb2e8f9f7 1119 /**
<> 144:ef7eb2e8f9f7 1120 * @brief Return the PCD state
<> 144:ef7eb2e8f9f7 1121 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1122 * @retval HAL state
<> 144:ef7eb2e8f9f7 1123 */
<> 144:ef7eb2e8f9f7 1124 PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1125 {
<> 144:ef7eb2e8f9f7 1126 return hpcd->State;
<> 144:ef7eb2e8f9f7 1127 }
<> 144:ef7eb2e8f9f7 1128
<> 144:ef7eb2e8f9f7 1129 /**
<> 144:ef7eb2e8f9f7 1130 * @}
<> 144:ef7eb2e8f9f7 1131 */
<> 144:ef7eb2e8f9f7 1132
<> 144:ef7eb2e8f9f7 1133 /**
<> 144:ef7eb2e8f9f7 1134 * @}
<> 144:ef7eb2e8f9f7 1135 */
<> 144:ef7eb2e8f9f7 1136
<> 144:ef7eb2e8f9f7 1137 /** @addtogroup PCD_Private_Functions
<> 144:ef7eb2e8f9f7 1138 * @{
<> 144:ef7eb2e8f9f7 1139 */
<> 144:ef7eb2e8f9f7 1140 #if defined (USB_OTG_FS)
<> 144:ef7eb2e8f9f7 1141 /**
<> 144:ef7eb2e8f9f7 1142 * @brief DCD_WriteEmptyTxFifo
<> 144:ef7eb2e8f9f7 1143 * check FIFO for the next packet to be loaded
<> 144:ef7eb2e8f9f7 1144 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1145 * @param epnum : endpoint number
<> 144:ef7eb2e8f9f7 1146 * This parameter can be a value from 0 to 15
<> 144:ef7eb2e8f9f7 1147 * @retval HAL status
<> 144:ef7eb2e8f9f7 1148 */
<> 144:ef7eb2e8f9f7 1149 static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum)
<> 144:ef7eb2e8f9f7 1150 {
<> 144:ef7eb2e8f9f7 1151 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<> 144:ef7eb2e8f9f7 1152 USB_OTG_EPTypeDef *ep = NULL;
AnnaBridge 187:0387e8f68319 1153 uint32_t len; // MBED patch
AnnaBridge 165:e614a9f1c9e2 1154 uint32_t len32b = 0U;
AnnaBridge 165:e614a9f1c9e2 1155 uint32_t fifoemptymsk = 0U;
<> 144:ef7eb2e8f9f7 1156
<> 144:ef7eb2e8f9f7 1157 ep = &hpcd->IN_ep[epnum];
<> 144:ef7eb2e8f9f7 1158 len = ep->xfer_len - ep->xfer_count;
<> 144:ef7eb2e8f9f7 1159
<> 144:ef7eb2e8f9f7 1160 if (len > ep->maxpacket)
<> 144:ef7eb2e8f9f7 1161 {
<> 144:ef7eb2e8f9f7 1162 len = ep->maxpacket;
<> 144:ef7eb2e8f9f7 1163 }
<> 144:ef7eb2e8f9f7 1164
AnnaBridge 165:e614a9f1c9e2 1165 len32b = (len + 3U) / 4U;
<> 144:ef7eb2e8f9f7 1166
<> 144:ef7eb2e8f9f7 1167 while ((USBx_INEP(epnum)->DTXFSTS & USB_OTG_DTXFSTS_INEPTFSAV) > len32b &&
<> 144:ef7eb2e8f9f7 1168 ep->xfer_count < ep->xfer_len &&
AnnaBridge 165:e614a9f1c9e2 1169 ep->xfer_len != 0U)
<> 144:ef7eb2e8f9f7 1170 {
<> 144:ef7eb2e8f9f7 1171 /* Write the FIFO */
<> 144:ef7eb2e8f9f7 1172 len = ep->xfer_len - ep->xfer_count;
<> 144:ef7eb2e8f9f7 1173
AnnaBridge 165:e614a9f1c9e2 1174 if ((uint32_t)len > ep->maxpacket)
<> 144:ef7eb2e8f9f7 1175 {
<> 144:ef7eb2e8f9f7 1176 len = ep->maxpacket;
<> 144:ef7eb2e8f9f7 1177 }
AnnaBridge 165:e614a9f1c9e2 1178 len32b = (len + 3U) / 4U;
<> 144:ef7eb2e8f9f7 1179
<> 144:ef7eb2e8f9f7 1180 USB_WritePacket(USBx, ep->xfer_buff, epnum, len);
<> 144:ef7eb2e8f9f7 1181
<> 144:ef7eb2e8f9f7 1182 ep->xfer_buff += len;
<> 144:ef7eb2e8f9f7 1183 ep->xfer_count += len;
<> 144:ef7eb2e8f9f7 1184 }
<> 144:ef7eb2e8f9f7 1185
AnnaBridge 187:0387e8f68319 1186 if (ep->xfer_count >= ep->xfer_len) // MBED patch
<> 144:ef7eb2e8f9f7 1187 {
AnnaBridge 165:e614a9f1c9e2 1188 fifoemptymsk = 0x01U << epnum;
<> 144:ef7eb2e8f9f7 1189 USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;
<> 144:ef7eb2e8f9f7 1190
<> 144:ef7eb2e8f9f7 1191 }
<> 144:ef7eb2e8f9f7 1192
<> 144:ef7eb2e8f9f7 1193 return HAL_OK;
<> 144:ef7eb2e8f9f7 1194 }
<> 144:ef7eb2e8f9f7 1195 #endif /* USB_OTG_FS */
<> 144:ef7eb2e8f9f7 1196
<> 144:ef7eb2e8f9f7 1197 #if defined (USB)
<> 144:ef7eb2e8f9f7 1198 /**
<> 144:ef7eb2e8f9f7 1199 * @brief This function handles PCD Endpoint interrupt request.
<> 144:ef7eb2e8f9f7 1200 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1201 * @retval HAL status
<> 144:ef7eb2e8f9f7 1202 */
<> 144:ef7eb2e8f9f7 1203 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1204 {
<> 144:ef7eb2e8f9f7 1205 PCD_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 1206 uint16_t count = 0;
<> 144:ef7eb2e8f9f7 1207 uint8_t epindex = 0;
<> 144:ef7eb2e8f9f7 1208 __IO uint16_t wIstr = 0;
<> 144:ef7eb2e8f9f7 1209 __IO uint16_t wEPVal = 0;
<> 144:ef7eb2e8f9f7 1210
<> 144:ef7eb2e8f9f7 1211 /* stay in loop while pending interrupts */
<> 144:ef7eb2e8f9f7 1212 while (((wIstr = hpcd->Instance->ISTR) & USB_ISTR_CTR) != 0)
<> 144:ef7eb2e8f9f7 1213 {
<> 144:ef7eb2e8f9f7 1214 /* extract highest priority endpoint number */
<> 144:ef7eb2e8f9f7 1215 epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
<> 144:ef7eb2e8f9f7 1216
<> 144:ef7eb2e8f9f7 1217 if (epindex == 0)
<> 144:ef7eb2e8f9f7 1218 {
<> 144:ef7eb2e8f9f7 1219 /* Decode and service control endpoint interrupt */
<> 144:ef7eb2e8f9f7 1220
<> 144:ef7eb2e8f9f7 1221 /* DIR bit = origin of the interrupt */
<> 144:ef7eb2e8f9f7 1222 if ((wIstr & USB_ISTR_DIR) == 0)
<> 144:ef7eb2e8f9f7 1223 {
<> 144:ef7eb2e8f9f7 1224 /* DIR = 0 */
<> 144:ef7eb2e8f9f7 1225
<> 144:ef7eb2e8f9f7 1226 /* DIR = 0 => IN int */
<> 144:ef7eb2e8f9f7 1227 /* DIR = 0 implies that (EP_CTR_TX = 1) always */
<> 144:ef7eb2e8f9f7 1228 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<> 144:ef7eb2e8f9f7 1229 ep = &hpcd->IN_ep[0];
<> 144:ef7eb2e8f9f7 1230
<> 144:ef7eb2e8f9f7 1231 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
<> 144:ef7eb2e8f9f7 1232 ep->xfer_buff += ep->xfer_count;
<> 144:ef7eb2e8f9f7 1233
<> 144:ef7eb2e8f9f7 1234 /* TX COMPLETE */
AnnaBridge 165:e614a9f1c9e2 1235 HAL_PCD_DataInStageCallback(hpcd, 0U);
<> 144:ef7eb2e8f9f7 1236
<> 144:ef7eb2e8f9f7 1237
AnnaBridge 165:e614a9f1c9e2 1238 if((hpcd->USB_Address > 0U)&& ( ep->xfer_len == 0U))
<> 144:ef7eb2e8f9f7 1239 {
<> 144:ef7eb2e8f9f7 1240 hpcd->Instance->DADDR = (hpcd->USB_Address | USB_DADDR_EF);
AnnaBridge 165:e614a9f1c9e2 1241 hpcd->USB_Address = 0U;
<> 144:ef7eb2e8f9f7 1242 }
<> 144:ef7eb2e8f9f7 1243
<> 144:ef7eb2e8f9f7 1244 }
<> 144:ef7eb2e8f9f7 1245 else
<> 144:ef7eb2e8f9f7 1246 {
<> 144:ef7eb2e8f9f7 1247 /* DIR = 1 */
<> 144:ef7eb2e8f9f7 1248
<> 144:ef7eb2e8f9f7 1249 /* DIR = 1 & CTR_RX => SETUP or OUT int */
<> 144:ef7eb2e8f9f7 1250 /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
AnnaBridge 165:e614a9f1c9e2 1251 ep = &hpcd->OUT_ep[0U];
<> 144:ef7eb2e8f9f7 1252 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
<> 144:ef7eb2e8f9f7 1253
AnnaBridge 165:e614a9f1c9e2 1254 if ((wEPVal & USB_EP_SETUP) != 0U)
<> 144:ef7eb2e8f9f7 1255 {
<> 144:ef7eb2e8f9f7 1256 /* Get SETUP Packet*/
<> 144:ef7eb2e8f9f7 1257 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
<> 144:ef7eb2e8f9f7 1258 USB_ReadPMA(hpcd->Instance, (uint8_t*)hpcd->Setup ,ep->pmaadress , ep->xfer_count);
<> 144:ef7eb2e8f9f7 1259 /* SETUP bit kept frozen while CTR_RX = 1*/
<> 144:ef7eb2e8f9f7 1260 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<> 144:ef7eb2e8f9f7 1261
<> 144:ef7eb2e8f9f7 1262 /* Process SETUP Packet*/
<> 144:ef7eb2e8f9f7 1263 HAL_PCD_SetupStageCallback(hpcd);
<> 144:ef7eb2e8f9f7 1264 }
<> 144:ef7eb2e8f9f7 1265
AnnaBridge 165:e614a9f1c9e2 1266 else if ((wEPVal & USB_EP_CTR_RX) != 0U)
<> 144:ef7eb2e8f9f7 1267 {
<> 144:ef7eb2e8f9f7 1268 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<> 144:ef7eb2e8f9f7 1269 /* Get Control Data OUT Packet*/
<> 144:ef7eb2e8f9f7 1270 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
<> 144:ef7eb2e8f9f7 1271
AnnaBridge 165:e614a9f1c9e2 1272 if (ep->xfer_count != 0U)
<> 144:ef7eb2e8f9f7 1273 {
<> 144:ef7eb2e8f9f7 1274 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, ep->xfer_count);
<> 144:ef7eb2e8f9f7 1275 ep->xfer_buff+=ep->xfer_count;
<> 144:ef7eb2e8f9f7 1276 }
<> 144:ef7eb2e8f9f7 1277
<> 144:ef7eb2e8f9f7 1278 /* Process Control Data OUT Packet*/
AnnaBridge 165:e614a9f1c9e2 1279 HAL_PCD_DataOutStageCallback(hpcd, 0U);
<> 144:ef7eb2e8f9f7 1280
<> 144:ef7eb2e8f9f7 1281 PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
<> 144:ef7eb2e8f9f7 1282 PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
<> 144:ef7eb2e8f9f7 1283 }
<> 144:ef7eb2e8f9f7 1284 }
<> 144:ef7eb2e8f9f7 1285 }
<> 144:ef7eb2e8f9f7 1286 else
<> 144:ef7eb2e8f9f7 1287 {
<> 144:ef7eb2e8f9f7 1288 /* Decode and service non control endpoints interrupt */
<> 144:ef7eb2e8f9f7 1289
<> 144:ef7eb2e8f9f7 1290 /* process related endpoint register */
<> 144:ef7eb2e8f9f7 1291 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, epindex);
AnnaBridge 165:e614a9f1c9e2 1292 if ((wEPVal & USB_EP_CTR_RX) != 0U)
<> 144:ef7eb2e8f9f7 1293 {
<> 144:ef7eb2e8f9f7 1294 /* clear int flag */
<> 144:ef7eb2e8f9f7 1295 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
<> 144:ef7eb2e8f9f7 1296 ep = &hpcd->OUT_ep[epindex];
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 /* OUT double Buffering*/
AnnaBridge 165:e614a9f1c9e2 1299 if (ep->doublebuffer == 0U)
<> 144:ef7eb2e8f9f7 1300 {
<> 144:ef7eb2e8f9f7 1301 count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1302 if (count != 0U)
<> 144:ef7eb2e8f9f7 1303 {
<> 144:ef7eb2e8f9f7 1304 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
<> 144:ef7eb2e8f9f7 1305 }
<> 144:ef7eb2e8f9f7 1306 }
<> 144:ef7eb2e8f9f7 1307 else
<> 144:ef7eb2e8f9f7 1308 {
<> 144:ef7eb2e8f9f7 1309 if (PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX)
<> 144:ef7eb2e8f9f7 1310 {
<> 144:ef7eb2e8f9f7 1311 /*read from endpoint BUF0Addr buffer*/
<> 144:ef7eb2e8f9f7 1312 count = PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1313 if (count != 0U)
<> 144:ef7eb2e8f9f7 1314 {
<> 144:ef7eb2e8f9f7 1315 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
<> 144:ef7eb2e8f9f7 1316 }
<> 144:ef7eb2e8f9f7 1317 }
<> 144:ef7eb2e8f9f7 1318 else
<> 144:ef7eb2e8f9f7 1319 {
<> 144:ef7eb2e8f9f7 1320 /*read from endpoint BUF1Addr buffer*/
<> 144:ef7eb2e8f9f7 1321 count = PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1322 if (count != 0U)
<> 144:ef7eb2e8f9f7 1323 {
<> 144:ef7eb2e8f9f7 1324 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
<> 144:ef7eb2e8f9f7 1325 }
<> 144:ef7eb2e8f9f7 1326 }
<> 144:ef7eb2e8f9f7 1327 PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_OUT);
<> 144:ef7eb2e8f9f7 1328 }
<> 144:ef7eb2e8f9f7 1329 /*multi-packet on the NON control OUT endpoint*/
<> 144:ef7eb2e8f9f7 1330 ep->xfer_count+=count;
<> 144:ef7eb2e8f9f7 1331 ep->xfer_buff+=count;
<> 144:ef7eb2e8f9f7 1332
AnnaBridge 165:e614a9f1c9e2 1333 if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
<> 144:ef7eb2e8f9f7 1334 {
<> 144:ef7eb2e8f9f7 1335 /* RX COMPLETE */
<> 144:ef7eb2e8f9f7 1336 HAL_PCD_DataOutStageCallback(hpcd, ep->num);
<> 144:ef7eb2e8f9f7 1337 }
<> 144:ef7eb2e8f9f7 1338 else
<> 144:ef7eb2e8f9f7 1339 {
<> 144:ef7eb2e8f9f7 1340 HAL_PCD_EP_Receive(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
<> 144:ef7eb2e8f9f7 1341 }
<> 144:ef7eb2e8f9f7 1342
<> 144:ef7eb2e8f9f7 1343 } /* if((wEPVal & EP_CTR_RX) */
<> 144:ef7eb2e8f9f7 1344
AnnaBridge 165:e614a9f1c9e2 1345 if ((wEPVal & USB_EP_CTR_TX) != 0U)
<> 144:ef7eb2e8f9f7 1346 {
<> 144:ef7eb2e8f9f7 1347 ep = &hpcd->IN_ep[epindex];
<> 144:ef7eb2e8f9f7 1348
<> 144:ef7eb2e8f9f7 1349 /* clear int flag */
<> 144:ef7eb2e8f9f7 1350 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
<> 144:ef7eb2e8f9f7 1351
<> 144:ef7eb2e8f9f7 1352 /* IN double Buffering*/
AnnaBridge 165:e614a9f1c9e2 1353 if (ep->doublebuffer == 0U)
<> 144:ef7eb2e8f9f7 1354 {
<> 144:ef7eb2e8f9f7 1355 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1356 if (ep->xfer_count != 0U)
<> 144:ef7eb2e8f9f7 1357 {
<> 144:ef7eb2e8f9f7 1358 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, ep->xfer_count);
<> 144:ef7eb2e8f9f7 1359 }
<> 144:ef7eb2e8f9f7 1360 }
<> 144:ef7eb2e8f9f7 1361 else
<> 144:ef7eb2e8f9f7 1362 {
<> 144:ef7eb2e8f9f7 1363 if (PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_TX)
<> 144:ef7eb2e8f9f7 1364 {
<> 144:ef7eb2e8f9f7 1365 /*read from endpoint BUF0Addr buffer*/
<> 144:ef7eb2e8f9f7 1366 ep->xfer_count = PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1367 if (ep->xfer_count != 0U)
<> 144:ef7eb2e8f9f7 1368 {
<> 144:ef7eb2e8f9f7 1369 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, ep->xfer_count);
<> 144:ef7eb2e8f9f7 1370 }
<> 144:ef7eb2e8f9f7 1371 }
<> 144:ef7eb2e8f9f7 1372 else
<> 144:ef7eb2e8f9f7 1373 {
<> 144:ef7eb2e8f9f7 1374 /*read from endpoint BUF1Addr buffer*/
<> 144:ef7eb2e8f9f7 1375 ep->xfer_count = PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
AnnaBridge 165:e614a9f1c9e2 1376 if (ep->xfer_count != 0U)
<> 144:ef7eb2e8f9f7 1377 {
<> 144:ef7eb2e8f9f7 1378 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, ep->xfer_count);
<> 144:ef7eb2e8f9f7 1379 }
<> 144:ef7eb2e8f9f7 1380 }
<> 144:ef7eb2e8f9f7 1381 PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_IN);
<> 144:ef7eb2e8f9f7 1382 }
<> 144:ef7eb2e8f9f7 1383 /*multi-packet on the NON control IN endpoint*/
<> 144:ef7eb2e8f9f7 1384 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
<> 144:ef7eb2e8f9f7 1385 ep->xfer_buff+=ep->xfer_count;
<> 144:ef7eb2e8f9f7 1386
<> 144:ef7eb2e8f9f7 1387 /* Zero Length Packet? */
AnnaBridge 165:e614a9f1c9e2 1388 if (ep->xfer_len == 0U)
<> 144:ef7eb2e8f9f7 1389 {
<> 144:ef7eb2e8f9f7 1390 /* TX COMPLETE */
<> 144:ef7eb2e8f9f7 1391 HAL_PCD_DataInStageCallback(hpcd, ep->num);
<> 144:ef7eb2e8f9f7 1392 }
<> 144:ef7eb2e8f9f7 1393 else
<> 144:ef7eb2e8f9f7 1394 {
<> 144:ef7eb2e8f9f7 1395 HAL_PCD_EP_Transmit(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
<> 144:ef7eb2e8f9f7 1396 }
<> 144:ef7eb2e8f9f7 1397 }
<> 144:ef7eb2e8f9f7 1398 }
<> 144:ef7eb2e8f9f7 1399 }
<> 144:ef7eb2e8f9f7 1400 return HAL_OK;
<> 144:ef7eb2e8f9f7 1401 }
<> 144:ef7eb2e8f9f7 1402 #endif /* USB */
<> 144:ef7eb2e8f9f7 1403
<> 144:ef7eb2e8f9f7 1404 /**
<> 144:ef7eb2e8f9f7 1405 * @}
<> 144:ef7eb2e8f9f7 1406 */
<> 144:ef7eb2e8f9f7 1407
<> 144:ef7eb2e8f9f7 1408 /**
<> 144:ef7eb2e8f9f7 1409 * @}
<> 144:ef7eb2e8f9f7 1410 */
<> 144:ef7eb2e8f9f7 1411
<> 144:ef7eb2e8f9f7 1412 #endif /* STM32F102x6 || STM32F102xB || */
<> 144:ef7eb2e8f9f7 1413 /* STM32F103x6 || STM32F103xB || */
<> 144:ef7eb2e8f9f7 1414 /* STM32F103xE || STM32F103xG || */
<> 144:ef7eb2e8f9f7 1415 /* STM32F105xC || STM32F107xC */
<> 144:ef7eb2e8f9f7 1416
<> 144:ef7eb2e8f9f7 1417 #endif /* HAL_PCD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1418
<> 144:ef7eb2e8f9f7 1419
<> 144:ef7eb2e8f9f7 1420 /**
<> 144:ef7eb2e8f9f7 1421 * @}
<> 144:ef7eb2e8f9f7 1422 */
<> 144:ef7eb2e8f9f7 1423
<> 144:ef7eb2e8f9f7 1424 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/