anyThing Connected Team / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   BREAK_SENSOR_LED

Fork of mbed-dev by mbed official

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_pcd.c@168:9672193075cf, 2017-07-06 (annotated)

Committer:
AnnaBridge
Date:
Thu Jul 06 15:42:05 2017 +0100
Revision:
168:9672193075cf
Parent:
161:2cc1468da177 
This updates the lib to the mbed lib v 146

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f7xx_hal_pcd.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
AnnaBridge 168:9672193075cf 5 * @version V1.2.2
AnnaBridge 168:9672193075cf 6 * @date 14-April-2017
<> 144:ef7eb2e8f9f7 7 * @brief PCD HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the USB Peripheral Controller:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + IO operation functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 @verbatim
<> 144:ef7eb2e8f9f7 16 ==============================================================================
<> 144:ef7eb2e8f9f7 17 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 18 ==============================================================================
<> 144:ef7eb2e8f9f7 19 [..]
<> 144:ef7eb2e8f9f7 20 The PCD HAL driver can be used as follows:
<> 144:ef7eb2e8f9f7 21
<> 144:ef7eb2e8f9f7 22 (#) Declare a PCD_HandleTypeDef handle structure, for example:
<> 144:ef7eb2e8f9f7 23 PCD_HandleTypeDef hpcd;
<> 144:ef7eb2e8f9f7 24
<> 144:ef7eb2e8f9f7 25 (#) Fill parameters of Init structure in HCD handle
<> 144:ef7eb2e8f9f7 26
<> 144:ef7eb2e8f9f7 27 (#) Call HAL_PCD_Init() API to initialize the PCD peripheral (Core, Device core, ...)
<> 144:ef7eb2e8f9f7 28
<> 144:ef7eb2e8f9f7 29 (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
<> 144:ef7eb2e8f9f7 30 (##) Enable the PCD/USB Low Level interface clock using
<> 144:ef7eb2e8f9f7 31 (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 32 (+++) __HAL_RCC_USB_OTG_HS_CLK_ENABLE(); (For High Speed Mode)
<> 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 PCD 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 *
AnnaBridge 168:9672193075cf 48 * <h2><center>&copy; COPYRIGHT(c) 2017 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 "stm32f7xx_hal.h"
<> 144:ef7eb2e8f9f7 77
<> 144:ef7eb2e8f9f7 78 /** @addtogroup STM32F7xx_HAL_Driver
<> 144:ef7eb2e8f9f7 79 * @{
<> 144:ef7eb2e8f9f7 80 */
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 /** @defgroup PCD PCD
<> 144:ef7eb2e8f9f7 83 * @brief PCD HAL module driver
<> 144:ef7eb2e8f9f7 84 * @{
<> 144:ef7eb2e8f9f7 85 */
<> 144:ef7eb2e8f9f7 86
<> 144:ef7eb2e8f9f7 87 #ifdef HAL_PCD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 88
<> 144:ef7eb2e8f9f7 89 /* Private types -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 90 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 91 /* Private constants ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 92 /* Private macros ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 93 /** @defgroup PCD_Private_Macros PCD Private Macros
<> 144:ef7eb2e8f9f7 94 * @{
<> 144:ef7eb2e8f9f7 95 */
<> 144:ef7eb2e8f9f7 96 #define PCD_MIN(a, b) (((a) < (b)) ? (a) : (b))
<> 144:ef7eb2e8f9f7 97 #define PCD_MAX(a, b) (((a) > (b)) ? (a) : (b))
<> 144:ef7eb2e8f9f7 98 /**
<> 144:ef7eb2e8f9f7 99 * @}
<> 144:ef7eb2e8f9f7 100 */
<> 144:ef7eb2e8f9f7 101
<> 144:ef7eb2e8f9f7 102 /* Private functions prototypes ----------------------------------------------*/
<> 144:ef7eb2e8f9f7 103 /** @defgroup PCD_Private_Functions PCD Private Functions
<> 144:ef7eb2e8f9f7 104 * @{
<> 144:ef7eb2e8f9f7 105 */
<> 144:ef7eb2e8f9f7 106 static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum);
<> 144:ef7eb2e8f9f7 107 /**
<> 144:ef7eb2e8f9f7 108 * @}
<> 144:ef7eb2e8f9f7 109 */
<> 144:ef7eb2e8f9f7 110
<> 144:ef7eb2e8f9f7 111 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 112 /** @defgroup PCD_Exported_Functions PCD Exported Functions
<> 144:ef7eb2e8f9f7 113 * @{
<> 144:ef7eb2e8f9f7 114 */
<> 144:ef7eb2e8f9f7 115
<> 144:ef7eb2e8f9f7 116 /** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 117 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 118 *
<> 144:ef7eb2e8f9f7 119 @verbatim
<> 144:ef7eb2e8f9f7 120 ===============================================================================
<> 144:ef7eb2e8f9f7 121 ##### Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 122 ===============================================================================
<> 144:ef7eb2e8f9f7 123 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 124
<> 144:ef7eb2e8f9f7 125 @endverbatim
<> 144:ef7eb2e8f9f7 126 * @{
<> 144:ef7eb2e8f9f7 127 */
<> 144:ef7eb2e8f9f7 128
<> 144:ef7eb2e8f9f7 129 /**
<> 144:ef7eb2e8f9f7 130 * @brief Initializes the PCD according to the specified
<> 144:ef7eb2e8f9f7 131 * parameters in the PCD_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 132 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 133 * @retval HAL status
<> 144:ef7eb2e8f9f7 134 */
<> 144:ef7eb2e8f9f7 135 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 136 {
<> 144:ef7eb2e8f9f7 137 uint32_t i = 0;
<> 144:ef7eb2e8f9f7 138
<> 144:ef7eb2e8f9f7 139 /* Check the PCD handle allocation */
<> 144:ef7eb2e8f9f7 140 if(hpcd == NULL)
<> 144:ef7eb2e8f9f7 141 {
<> 144:ef7eb2e8f9f7 142 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 143 }
<> 144:ef7eb2e8f9f7 144
<> 144:ef7eb2e8f9f7 145 /* Check the parameters */
<> 144:ef7eb2e8f9f7 146 assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
<> 144:ef7eb2e8f9f7 147
<> 153:fa9ff456f731 148 if(hpcd->State == HAL_PCD_STATE_RESET)
<> 153:fa9ff456f731 149 {
<> 153:fa9ff456f731 150 /* Allocate lock resource and initialize it */
<> 153:fa9ff456f731 151 hpcd->Lock = HAL_UNLOCKED;
<> 153:fa9ff456f731 152 for (i = 0; i < hpcd->Init.dev_endpoints ; i++)
<> 153:fa9ff456f731 153 hpcd->EPLock[i].Lock = HAL_UNLOCKED;
<> 153:fa9ff456f731 154 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
<> 153:fa9ff456f731 155 HAL_PCD_MspInit(hpcd);
<> 153:fa9ff456f731 156 }
<> 153:fa9ff456f731 157
<> 144:ef7eb2e8f9f7 158 hpcd->State = HAL_PCD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 159
<> 144:ef7eb2e8f9f7 160 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
<> 144:ef7eb2e8f9f7 161 HAL_PCD_MspInit(hpcd);
<> 144:ef7eb2e8f9f7 162
<> 144:ef7eb2e8f9f7 163 /* Disable the Interrupts */
<> 144:ef7eb2e8f9f7 164 __HAL_PCD_DISABLE(hpcd);
<> 144:ef7eb2e8f9f7 165
<> 144:ef7eb2e8f9f7 166 /*Init the Core (common init.) */
<> 144:ef7eb2e8f9f7 167 USB_CoreInit(hpcd->Instance, hpcd->Init);
<> 144:ef7eb2e8f9f7 168
<> 144:ef7eb2e8f9f7 169 /* Force Device Mode*/
<> 144:ef7eb2e8f9f7 170 USB_SetCurrentMode(hpcd->Instance , USB_OTG_DEVICE_MODE);
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* Init endpoints structures */
<> 144:ef7eb2e8f9f7 173 for (i = 0; i < 15 ; i++)
<> 144:ef7eb2e8f9f7 174 {
<> 144:ef7eb2e8f9f7 175 /* Init ep structure */
<> 144:ef7eb2e8f9f7 176 hpcd->IN_ep[i].is_in = 1;
<> 144:ef7eb2e8f9f7 177 hpcd->IN_ep[i].num = i;
<> 144:ef7eb2e8f9f7 178 hpcd->IN_ep[i].tx_fifo_num = i;
<> 144:ef7eb2e8f9f7 179 /* Control until ep is activated */
<> 144:ef7eb2e8f9f7 180 hpcd->IN_ep[i].type = EP_TYPE_CTRL;
<> 144:ef7eb2e8f9f7 181 hpcd->IN_ep[i].maxpacket = 0;
<> 144:ef7eb2e8f9f7 182 hpcd->IN_ep[i].xfer_buff = 0;
<> 144:ef7eb2e8f9f7 183 hpcd->IN_ep[i].xfer_len = 0;
<> 144:ef7eb2e8f9f7 184 }
<> 144:ef7eb2e8f9f7 185
<> 144:ef7eb2e8f9f7 186 for (i = 0; i < 15 ; i++)
<> 144:ef7eb2e8f9f7 187 {
<> 144:ef7eb2e8f9f7 188 hpcd->OUT_ep[i].is_in = 0;
<> 144:ef7eb2e8f9f7 189 hpcd->OUT_ep[i].num = i;
<> 144:ef7eb2e8f9f7 190 hpcd->IN_ep[i].tx_fifo_num = i;
<> 144:ef7eb2e8f9f7 191 /* Control until ep is activated */
<> 144:ef7eb2e8f9f7 192 hpcd->OUT_ep[i].type = EP_TYPE_CTRL;
<> 144:ef7eb2e8f9f7 193 hpcd->OUT_ep[i].maxpacket = 0;
<> 144:ef7eb2e8f9f7 194 hpcd->OUT_ep[i].xfer_buff = 0;
<> 144:ef7eb2e8f9f7 195 hpcd->OUT_ep[i].xfer_len = 0;
<> 144:ef7eb2e8f9f7 196
<> 144:ef7eb2e8f9f7 197 hpcd->Instance->DIEPTXF[i] = 0;
<> 144:ef7eb2e8f9f7 198 }
<> 144:ef7eb2e8f9f7 199 /* Init Device */
<> 144:ef7eb2e8f9f7 200 USB_DevInit(hpcd->Instance, hpcd->Init);
<> 144:ef7eb2e8f9f7 201
<> 144:ef7eb2e8f9f7 202 hpcd->State= HAL_PCD_STATE_READY;
<> 144:ef7eb2e8f9f7 203
<> 144:ef7eb2e8f9f7 204 /* Activate LPM */
<> 157:ff67d9f36b67 205 if (hpcd->Init.lpm_enable ==1)
<> 144:ef7eb2e8f9f7 206 {
<> 144:ef7eb2e8f9f7 207 HAL_PCDEx_ActivateLPM(hpcd);
<> 144:ef7eb2e8f9f7 208 }
<> 161:2cc1468da177 209 #if defined (USB_OTG_GCCFG_BCDEN)
<> 161:2cc1468da177 210 /* Activate Battery charging */
<> 161:2cc1468da177 211 if (hpcd->Init.battery_charging_enable ==1)
<> 161:2cc1468da177 212 {
<> 161:2cc1468da177 213 HAL_PCDEx_ActivateBCD(hpcd);
<> 161:2cc1468da177 214 }
<> 161:2cc1468da177 215 #endif /* USB_OTG_GCCFG_BCDEN */
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 USB_DevDisconnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 218 return HAL_OK;
<> 144:ef7eb2e8f9f7 219 }
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 /**
<> 144:ef7eb2e8f9f7 222 * @brief DeInitializes the PCD peripheral.
<> 144:ef7eb2e8f9f7 223 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 224 * @retval HAL status
<> 144:ef7eb2e8f9f7 225 */
<> 144:ef7eb2e8f9f7 226 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 227 {
<> 144:ef7eb2e8f9f7 228 /* Check the PCD handle allocation */
<> 144:ef7eb2e8f9f7 229 if(hpcd == NULL)
<> 144:ef7eb2e8f9f7 230 {
<> 144:ef7eb2e8f9f7 231 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 232 }
<> 144:ef7eb2e8f9f7 233
<> 144:ef7eb2e8f9f7 234 hpcd->State = HAL_PCD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 235
<> 144:ef7eb2e8f9f7 236 /* Stop Device */
<> 144:ef7eb2e8f9f7 237 HAL_PCD_Stop(hpcd);
<> 144:ef7eb2e8f9f7 238
<> 144:ef7eb2e8f9f7 239 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 240 HAL_PCD_MspDeInit(hpcd);
<> 144:ef7eb2e8f9f7 241
<> 144:ef7eb2e8f9f7 242 hpcd->State = HAL_PCD_STATE_RESET;
<> 144:ef7eb2e8f9f7 243
<> 144:ef7eb2e8f9f7 244 return HAL_OK;
<> 144:ef7eb2e8f9f7 245 }
<> 144:ef7eb2e8f9f7 246
<> 144:ef7eb2e8f9f7 247 /**
<> 144:ef7eb2e8f9f7 248 * @brief Initializes the PCD MSP.
<> 144:ef7eb2e8f9f7 249 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 250 * @retval None
<> 144:ef7eb2e8f9f7 251 */
<> 144:ef7eb2e8f9f7 252 __weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 253 {
<> 144:ef7eb2e8f9f7 254 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 255 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 256
<> 144:ef7eb2e8f9f7 257 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 258 the HAL_PCD_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 259 */
<> 144:ef7eb2e8f9f7 260 }
<> 144:ef7eb2e8f9f7 261
<> 144:ef7eb2e8f9f7 262 /**
<> 144:ef7eb2e8f9f7 263 * @brief DeInitializes PCD MSP.
<> 144:ef7eb2e8f9f7 264 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 265 * @retval None
<> 144:ef7eb2e8f9f7 266 */
<> 144:ef7eb2e8f9f7 267 __weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 268 {
<> 144:ef7eb2e8f9f7 269 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 270 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 271
<> 144:ef7eb2e8f9f7 272 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 273 the HAL_PCD_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 274 */
<> 144:ef7eb2e8f9f7 275 }
<> 144:ef7eb2e8f9f7 276
<> 144:ef7eb2e8f9f7 277 /**
<> 144:ef7eb2e8f9f7 278 * @}
<> 144:ef7eb2e8f9f7 279 */
<> 144:ef7eb2e8f9f7 280
<> 144:ef7eb2e8f9f7 281 /** @defgroup PCD_Exported_Functions_Group2 Input and Output operation functions
<> 144:ef7eb2e8f9f7 282 * @brief Data transfers functions
<> 144:ef7eb2e8f9f7 283 *
<> 144:ef7eb2e8f9f7 284 @verbatim
<> 144:ef7eb2e8f9f7 285 ===============================================================================
<> 144:ef7eb2e8f9f7 286 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 287 ===============================================================================
<> 144:ef7eb2e8f9f7 288 [..]
<> 144:ef7eb2e8f9f7 289 This subsection provides a set of functions allowing to manage the PCD data
<> 144:ef7eb2e8f9f7 290 transfers.
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 @endverbatim
<> 144:ef7eb2e8f9f7 293 * @{
<> 144:ef7eb2e8f9f7 294 */
<> 144:ef7eb2e8f9f7 295
<> 144:ef7eb2e8f9f7 296 /**
<> 144:ef7eb2e8f9f7 297 * @brief Start The USB OTG Device.
<> 144:ef7eb2e8f9f7 298 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 299 * @retval HAL status
<> 144:ef7eb2e8f9f7 300 */
<> 144:ef7eb2e8f9f7 301 HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 302 {
<> 144:ef7eb2e8f9f7 303 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 304 USB_DevConnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 305 __HAL_PCD_ENABLE(hpcd);
<> 144:ef7eb2e8f9f7 306 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 307 return HAL_OK;
<> 144:ef7eb2e8f9f7 308 }
<> 144:ef7eb2e8f9f7 309
<> 144:ef7eb2e8f9f7 310 /**
<> 144:ef7eb2e8f9f7 311 * @brief Stop The USB OTG Device.
<> 144:ef7eb2e8f9f7 312 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 313 * @retval HAL status
<> 144:ef7eb2e8f9f7 314 */
<> 144:ef7eb2e8f9f7 315 HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 316 {
<> 144:ef7eb2e8f9f7 317 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 318 __HAL_PCD_DISABLE(hpcd);
<> 144:ef7eb2e8f9f7 319 USB_StopDevice(hpcd->Instance);
<> 144:ef7eb2e8f9f7 320 USB_DevDisconnect (hpcd->Instance);
<> 144:ef7eb2e8f9f7 321 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 322 return HAL_OK;
<> 144:ef7eb2e8f9f7 323 }
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 /**
<> 144:ef7eb2e8f9f7 326 * @brief Handle PCD interrupt request.
<> 144:ef7eb2e8f9f7 327 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 328 * @retval HAL status
<> 144:ef7eb2e8f9f7 329 */
<> 144:ef7eb2e8f9f7 330 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 331 {
<> 144:ef7eb2e8f9f7 332 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<> 144:ef7eb2e8f9f7 333 uint32_t i = 0, ep_intr = 0, epint = 0, epnum = 0;
<> 144:ef7eb2e8f9f7 334 uint32_t fifoemptymsk = 0, temp = 0;
<> 144:ef7eb2e8f9f7 335 USB_OTG_EPTypeDef *ep = NULL;
<> 144:ef7eb2e8f9f7 336 uint32_t hclk = 200000000;
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 /* ensure that we are in device mode */
<> 144:ef7eb2e8f9f7 339 if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)
<> 144:ef7eb2e8f9f7 340 {
<> 144:ef7eb2e8f9f7 341 /* avoid spurious interrupt */
<> 144:ef7eb2e8f9f7 342 if(__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))
<> 144:ef7eb2e8f9f7 343 {
<> 144:ef7eb2e8f9f7 344 return;
<> 144:ef7eb2e8f9f7 345 }
<> 144:ef7eb2e8f9f7 346
<> 144:ef7eb2e8f9f7 347 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))
<> 144:ef7eb2e8f9f7 348 {
<> 144:ef7eb2e8f9f7 349 /* incorrect mode, acknowledge the interrupt */
<> 144:ef7eb2e8f9f7 350 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);
<> 144:ef7eb2e8f9f7 351 }
<> 144:ef7eb2e8f9f7 352
<> 144:ef7eb2e8f9f7 353 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))
<> 144:ef7eb2e8f9f7 354 {
<> 144:ef7eb2e8f9f7 355 epnum = 0;
<> 144:ef7eb2e8f9f7 356
<> 144:ef7eb2e8f9f7 357 /* Read in the device interrupt bits */
<> 144:ef7eb2e8f9f7 358 ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 while ( ep_intr )
<> 144:ef7eb2e8f9f7 361 {
<> 144:ef7eb2e8f9f7 362 if (ep_intr & 0x1)
<> 144:ef7eb2e8f9f7 363 {
<> 144:ef7eb2e8f9f7 364 epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, epnum);
<> 144:ef7eb2e8f9f7 365
<> 144:ef7eb2e8f9f7 366 if(( epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
<> 144:ef7eb2e8f9f7 367 {
<> 144:ef7eb2e8f9f7 368 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
<> 144:ef7eb2e8f9f7 369
<> 144:ef7eb2e8f9f7 370 if(hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 371 {
<> 144:ef7eb2e8f9f7 372 hpcd->OUT_ep[epnum].xfer_count = hpcd->OUT_ep[epnum].maxpacket- (USBx_OUTEP(epnum)->DOEPTSIZ & USB_OTG_DOEPTSIZ_XFRSIZ);
<> 144:ef7eb2e8f9f7 373 hpcd->OUT_ep[epnum].xfer_buff += hpcd->OUT_ep[epnum].maxpacket;
<> 144:ef7eb2e8f9f7 374 }
<> 144:ef7eb2e8f9f7 375
<> 144:ef7eb2e8f9f7 376 HAL_PCD_DataOutStageCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 377 if(hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 378 {
<> 144:ef7eb2e8f9f7 379 if((epnum == 0) && (hpcd->OUT_ep[epnum].xfer_len == 0))
<> 144:ef7eb2e8f9f7 380 {
<> 144:ef7eb2e8f9f7 381 /* this is ZLP, so prepare EP0 for next setup */
<> 144:ef7eb2e8f9f7 382 USB_EP0_OutStart(hpcd->Instance, 1, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 383 }
<> 144:ef7eb2e8f9f7 384 }
<> 144:ef7eb2e8f9f7 385 }
<> 144:ef7eb2e8f9f7 386
<> 144:ef7eb2e8f9f7 387 if(( epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)
<> 144:ef7eb2e8f9f7 388 {
<> 144:ef7eb2e8f9f7 389 /* Inform the upper layer that a setup packet is available */
<> 144:ef7eb2e8f9f7 390 HAL_PCD_SetupStageCallback(hpcd);
<> 144:ef7eb2e8f9f7 391 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);
<> 144:ef7eb2e8f9f7 392 }
<> 144:ef7eb2e8f9f7 393
<> 144:ef7eb2e8f9f7 394 if(( epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)
<> 144:ef7eb2e8f9f7 395 {
<> 144:ef7eb2e8f9f7 396 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);
<> 144:ef7eb2e8f9f7 397 }
<> 144:ef7eb2e8f9f7 398 /* Clear Status Phase Received interrupt */
<> 144:ef7eb2e8f9f7 399 if(( epint & USB_OTG_DOEPINT_OTEPSPR) == USB_OTG_DOEPINT_OTEPSPR)
<> 144:ef7eb2e8f9f7 400 {
<> 144:ef7eb2e8f9f7 401 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPSPR);
<> 144:ef7eb2e8f9f7 402 }
<> 144:ef7eb2e8f9f7 403 }
<> 144:ef7eb2e8f9f7 404 epnum++;
<> 144:ef7eb2e8f9f7 405 ep_intr >>= 1;
<> 144:ef7eb2e8f9f7 406 }
<> 144:ef7eb2e8f9f7 407 }
<> 144:ef7eb2e8f9f7 408
<> 144:ef7eb2e8f9f7 409 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))
<> 144:ef7eb2e8f9f7 410 {
<> 144:ef7eb2e8f9f7 411 /* Read in the device interrupt bits */
<> 144:ef7eb2e8f9f7 412 ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 epnum = 0;
<> 144:ef7eb2e8f9f7 415
<> 144:ef7eb2e8f9f7 416 while ( ep_intr )
<> 144:ef7eb2e8f9f7 417 {
<> 144:ef7eb2e8f9f7 418 if (ep_intr & 0x1) /* In ITR */
<> 144:ef7eb2e8f9f7 419 {
<> 144:ef7eb2e8f9f7 420 epint = USB_ReadDevInEPInterrupt(hpcd->Instance, epnum);
<> 144:ef7eb2e8f9f7 421
<> 144:ef7eb2e8f9f7 422 if(( epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)
<> 144:ef7eb2e8f9f7 423 {
<> 144:ef7eb2e8f9f7 424 fifoemptymsk = 0x1 << epnum;
<> 153:fa9ff456f731 425 atomic_clr_u32(&USBx_DEVICE->DIEPEMPMSK, fifoemptymsk);
<> 144:ef7eb2e8f9f7 426
<> 144:ef7eb2e8f9f7 427 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);
<> 144:ef7eb2e8f9f7 428
<> 144:ef7eb2e8f9f7 429 if (hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 430 {
<> 144:ef7eb2e8f9f7 431 hpcd->IN_ep[epnum].xfer_buff += hpcd->IN_ep[epnum].maxpacket;
<> 144:ef7eb2e8f9f7 432 }
<> 144:ef7eb2e8f9f7 433
<> 144:ef7eb2e8f9f7 434 HAL_PCD_DataInStageCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 435
<> 144:ef7eb2e8f9f7 436 if (hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 437 {
<> 144:ef7eb2e8f9f7 438 /* this is ZLP, so prepare EP0 for next setup */
<> 144:ef7eb2e8f9f7 439 if((epnum == 0) && (hpcd->IN_ep[epnum].xfer_len == 0))
<> 144:ef7eb2e8f9f7 440 {
<> 144:ef7eb2e8f9f7 441 /* prepare to rx more setup packets */
<> 144:ef7eb2e8f9f7 442 USB_EP0_OutStart(hpcd->Instance, 1, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 443 }
<> 144:ef7eb2e8f9f7 444 }
<> 144:ef7eb2e8f9f7 445 }
<> 144:ef7eb2e8f9f7 446 if(( epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)
<> 144:ef7eb2e8f9f7 447 {
<> 144:ef7eb2e8f9f7 448 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);
<> 144:ef7eb2e8f9f7 449 }
<> 144:ef7eb2e8f9f7 450 if(( epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)
<> 144:ef7eb2e8f9f7 451 {
<> 144:ef7eb2e8f9f7 452 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);
<> 144:ef7eb2e8f9f7 453 }
<> 144:ef7eb2e8f9f7 454 if(( epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)
<> 144:ef7eb2e8f9f7 455 {
<> 144:ef7eb2e8f9f7 456 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);
<> 144:ef7eb2e8f9f7 457 }
<> 144:ef7eb2e8f9f7 458 if(( epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
<> 144:ef7eb2e8f9f7 459 {
<> 144:ef7eb2e8f9f7 460 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);
<> 144:ef7eb2e8f9f7 461 }
<> 144:ef7eb2e8f9f7 462 if(( epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)
<> 144:ef7eb2e8f9f7 463 {
<> 144:ef7eb2e8f9f7 464 PCD_WriteEmptyTxFifo(hpcd , epnum);
<> 144:ef7eb2e8f9f7 465 }
<> 144:ef7eb2e8f9f7 466 }
<> 144:ef7eb2e8f9f7 467 epnum++;
<> 144:ef7eb2e8f9f7 468 ep_intr >>= 1;
<> 144:ef7eb2e8f9f7 469 }
<> 144:ef7eb2e8f9f7 470 }
<> 144:ef7eb2e8f9f7 471
<> 144:ef7eb2e8f9f7 472 /* Handle Resume Interrupt */
<> 144:ef7eb2e8f9f7 473 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))
<> 144:ef7eb2e8f9f7 474 {
<> 144:ef7eb2e8f9f7 475 /* Clear the Remote Wake-up Signaling */
<> 144:ef7eb2e8f9f7 476 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
<> 144:ef7eb2e8f9f7 477
<> 144:ef7eb2e8f9f7 478 if(hpcd->LPM_State == LPM_L1)
<> 144:ef7eb2e8f9f7 479 {
<> 144:ef7eb2e8f9f7 480 hpcd->LPM_State = LPM_L0;
<> 144:ef7eb2e8f9f7 481 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
<> 144:ef7eb2e8f9f7 482 }
<> 144:ef7eb2e8f9f7 483 else
<> 144:ef7eb2e8f9f7 484 {
<> 144:ef7eb2e8f9f7 485 HAL_PCD_ResumeCallback(hpcd);
<> 144:ef7eb2e8f9f7 486 }
<> 144:ef7eb2e8f9f7 487 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);
<> 144:ef7eb2e8f9f7 488 }
<> 144:ef7eb2e8f9f7 489
<> 144:ef7eb2e8f9f7 490 /* Handle Suspend Interrupt */
<> 144:ef7eb2e8f9f7 491 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))
<> 144:ef7eb2e8f9f7 492 {
<> 144:ef7eb2e8f9f7 493 if((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
<> 144:ef7eb2e8f9f7 494 {
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 HAL_PCD_SuspendCallback(hpcd);
<> 144:ef7eb2e8f9f7 497 }
<> 144:ef7eb2e8f9f7 498 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);
<> 144:ef7eb2e8f9f7 499 }
<> 144:ef7eb2e8f9f7 500
<> 144:ef7eb2e8f9f7 501 /* Handle LPM Interrupt */
<> 144:ef7eb2e8f9f7 502 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT))
<> 144:ef7eb2e8f9f7 503 {
<> 144:ef7eb2e8f9f7 504 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT);
<> 144:ef7eb2e8f9f7 505 if( hpcd->LPM_State == LPM_L0)
<> 144:ef7eb2e8f9f7 506 {
<> 144:ef7eb2e8f9f7 507 hpcd->LPM_State = LPM_L1;
<> 144:ef7eb2e8f9f7 508 hpcd->BESL = (hpcd->Instance->GLPMCFG & USB_OTG_GLPMCFG_BESL) >>2 ;
<> 144:ef7eb2e8f9f7 509 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
<> 144:ef7eb2e8f9f7 510 }
<> 144:ef7eb2e8f9f7 511 else
<> 144:ef7eb2e8f9f7 512 {
<> 144:ef7eb2e8f9f7 513 HAL_PCD_SuspendCallback(hpcd);
<> 144:ef7eb2e8f9f7 514 }
<> 144:ef7eb2e8f9f7 515 }
<> 144:ef7eb2e8f9f7 516
<> 144:ef7eb2e8f9f7 517 /* Handle Reset Interrupt */
<> 144:ef7eb2e8f9f7 518 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))
<> 144:ef7eb2e8f9f7 519 {
<> 144:ef7eb2e8f9f7 520 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
<> 161:2cc1468da177 521 USB_FlushTxFifo(hpcd->Instance, 0x10);
<> 144:ef7eb2e8f9f7 522
<> 144:ef7eb2e8f9f7 523 for (i = 0; i < hpcd->Init.dev_endpoints ; i++)
<> 144:ef7eb2e8f9f7 524 {
<> 144:ef7eb2e8f9f7 525 USBx_INEP(i)->DIEPINT = 0xFF;
<> 144:ef7eb2e8f9f7 526 USBx_OUTEP(i)->DOEPINT = 0xFF;
<> 144:ef7eb2e8f9f7 527 }
<> 144:ef7eb2e8f9f7 528 USBx_DEVICE->DAINT = 0xFFFFFFFF;
<> 144:ef7eb2e8f9f7 529 USBx_DEVICE->DAINTMSK |= 0x10001;
<> 144:ef7eb2e8f9f7 530
<> 144:ef7eb2e8f9f7 531 if(hpcd->Init.use_dedicated_ep1)
<> 144:ef7eb2e8f9f7 532 {
<> 144:ef7eb2e8f9f7 533 USBx_DEVICE->DOUTEP1MSK |= (USB_OTG_DOEPMSK_STUPM | USB_OTG_DOEPMSK_XFRCM | USB_OTG_DOEPMSK_EPDM);
<> 144:ef7eb2e8f9f7 534 USBx_DEVICE->DINEP1MSK |= (USB_OTG_DIEPMSK_TOM | USB_OTG_DIEPMSK_XFRCM | USB_OTG_DIEPMSK_EPDM);
<> 144:ef7eb2e8f9f7 535 }
<> 144:ef7eb2e8f9f7 536 else
<> 144:ef7eb2e8f9f7 537 {
<> 144:ef7eb2e8f9f7 538 USBx_DEVICE->DOEPMSK |= (USB_OTG_DOEPMSK_STUPM | USB_OTG_DOEPMSK_XFRCM | USB_OTG_DOEPMSK_EPDM | USB_OTG_DOEPMSK_OTEPSPRM);
<> 144:ef7eb2e8f9f7 539 USBx_DEVICE->DIEPMSK |= (USB_OTG_DIEPMSK_TOM | USB_OTG_DIEPMSK_XFRCM | USB_OTG_DIEPMSK_EPDM);
<> 144:ef7eb2e8f9f7 540 }
<> 144:ef7eb2e8f9f7 541
<> 144:ef7eb2e8f9f7 542 /* Set Default Address to 0 */
<> 144:ef7eb2e8f9f7 543 USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;
<> 144:ef7eb2e8f9f7 544
<> 144:ef7eb2e8f9f7 545 /* setup EP0 to receive SETUP packets */
<> 144:ef7eb2e8f9f7 546 USB_EP0_OutStart(hpcd->Instance, hpcd->Init.dma_enable, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 547
<> 144:ef7eb2e8f9f7 548 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);
<> 144:ef7eb2e8f9f7 549 }
<> 144:ef7eb2e8f9f7 550
<> 144:ef7eb2e8f9f7 551 /* Handle Enumeration done Interrupt */
<> 144:ef7eb2e8f9f7 552 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))
<> 144:ef7eb2e8f9f7 553 {
<> 144:ef7eb2e8f9f7 554 USB_ActivateSetup(hpcd->Instance);
<> 144:ef7eb2e8f9f7 555 hpcd->Instance->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;
<> 144:ef7eb2e8f9f7 556
<> 144:ef7eb2e8f9f7 557 if ( USB_GetDevSpeed(hpcd->Instance) == USB_OTG_SPEED_HIGH)
<> 144:ef7eb2e8f9f7 558 {
<> 144:ef7eb2e8f9f7 559 hpcd->Init.speed = USB_OTG_SPEED_HIGH;
<> 144:ef7eb2e8f9f7 560 hpcd->Init.ep0_mps = USB_OTG_HS_MAX_PACKET_SIZE ;
<> 144:ef7eb2e8f9f7 561 hpcd->Instance->GUSBCFG |= (uint32_t)((USBD_HS_TRDT_VALUE << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 562 }
<> 144:ef7eb2e8f9f7 563 else
<> 144:ef7eb2e8f9f7 564 {
<> 144:ef7eb2e8f9f7 565 hpcd->Init.speed = USB_OTG_SPEED_FULL;
<> 144:ef7eb2e8f9f7 566 hpcd->Init.ep0_mps = USB_OTG_FS_MAX_PACKET_SIZE ;
<> 144:ef7eb2e8f9f7 567
<> 144:ef7eb2e8f9f7 568 /* The USBTRD is configured according to the tables below, depending on AHB frequency
<> 144:ef7eb2e8f9f7 569 used by application. In the low AHB frequency range it is used to stretch enough the USB response
<> 144:ef7eb2e8f9f7 570 time to IN tokens, the USB turnaround time, so to compensate for the longer AHB read access
<> 144:ef7eb2e8f9f7 571 latency to the Data FIFO */
<> 144:ef7eb2e8f9f7 572
<> 144:ef7eb2e8f9f7 573 /* Get hclk frequency value */
<> 144:ef7eb2e8f9f7 574 hclk = HAL_RCC_GetHCLKFreq();
<> 144:ef7eb2e8f9f7 575
<> 144:ef7eb2e8f9f7 576 if((hclk >= 14200000)&&(hclk < 15000000))
<> 144:ef7eb2e8f9f7 577 {
<> 144:ef7eb2e8f9f7 578 /* hclk Clock Range between 14.2-15 MHz */
<> 144:ef7eb2e8f9f7 579 hpcd->Instance->GUSBCFG |= (uint32_t)((0xF << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 580 }
<> 144:ef7eb2e8f9f7 581
<> 144:ef7eb2e8f9f7 582 else if((hclk >= 15000000)&&(hclk < 16000000))
<> 144:ef7eb2e8f9f7 583 {
<> 144:ef7eb2e8f9f7 584 /* hclk Clock Range between 15-16 MHz */
<> 144:ef7eb2e8f9f7 585 hpcd->Instance->GUSBCFG |= (uint32_t)((0xE << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 586 }
<> 144:ef7eb2e8f9f7 587
<> 144:ef7eb2e8f9f7 588 else if((hclk >= 16000000)&&(hclk < 17200000))
<> 144:ef7eb2e8f9f7 589 {
<> 144:ef7eb2e8f9f7 590 /* hclk Clock Range between 16-17.2 MHz */
<> 144:ef7eb2e8f9f7 591 hpcd->Instance->GUSBCFG |= (uint32_t)((0xD << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 592 }
<> 144:ef7eb2e8f9f7 593
<> 144:ef7eb2e8f9f7 594 else if((hclk >= 17200000)&&(hclk < 18500000))
<> 144:ef7eb2e8f9f7 595 {
<> 144:ef7eb2e8f9f7 596 /* hclk Clock Range between 17.2-18.5 MHz */
<> 144:ef7eb2e8f9f7 597 hpcd->Instance->GUSBCFG |= (uint32_t)((0xC << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 598 }
<> 144:ef7eb2e8f9f7 599
<> 144:ef7eb2e8f9f7 600 else if((hclk >= 18500000)&&(hclk < 20000000))
<> 144:ef7eb2e8f9f7 601 {
<> 144:ef7eb2e8f9f7 602 /* hclk Clock Range between 18.5-20 MHz */
<> 144:ef7eb2e8f9f7 603 hpcd->Instance->GUSBCFG |= (uint32_t)((0xB << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 604 }
<> 144:ef7eb2e8f9f7 605
<> 144:ef7eb2e8f9f7 606 else if((hclk >= 20000000)&&(hclk < 21800000))
<> 144:ef7eb2e8f9f7 607 {
<> 144:ef7eb2e8f9f7 608 /* hclk Clock Range between 20-21.8 MHz */
<> 144:ef7eb2e8f9f7 609 hpcd->Instance->GUSBCFG |= (uint32_t)((0xA << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 610 }
<> 144:ef7eb2e8f9f7 611
<> 144:ef7eb2e8f9f7 612 else if((hclk >= 21800000)&&(hclk < 24000000))
<> 144:ef7eb2e8f9f7 613 {
<> 144:ef7eb2e8f9f7 614 /* hclk Clock Range between 21.8-24 MHz */
<> 144:ef7eb2e8f9f7 615 hpcd->Instance->GUSBCFG |= (uint32_t)((0x9 << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 616 }
<> 144:ef7eb2e8f9f7 617
<> 144:ef7eb2e8f9f7 618 else if((hclk >= 24000000)&&(hclk < 27700000))
<> 144:ef7eb2e8f9f7 619 {
<> 144:ef7eb2e8f9f7 620 /* hclk Clock Range between 24-27.7 MHz */
<> 144:ef7eb2e8f9f7 621 hpcd->Instance->GUSBCFG |= (uint32_t)((0x8 << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 622 }
<> 144:ef7eb2e8f9f7 623
<> 144:ef7eb2e8f9f7 624 else if((hclk >= 27700000)&&(hclk < 32000000))
<> 144:ef7eb2e8f9f7 625 {
<> 144:ef7eb2e8f9f7 626 /* hclk Clock Range between 27.7-32 MHz */
<> 144:ef7eb2e8f9f7 627 hpcd->Instance->GUSBCFG |= (uint32_t)((0x7 << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 628 }
<> 144:ef7eb2e8f9f7 629
<> 144:ef7eb2e8f9f7 630 else /* if(hclk >= 32000000) */
<> 144:ef7eb2e8f9f7 631 {
<> 144:ef7eb2e8f9f7 632 /* hclk Clock Range between 32-200 MHz */
<> 144:ef7eb2e8f9f7 633 hpcd->Instance->GUSBCFG |= (uint32_t)((0x6 << 10) & USB_OTG_GUSBCFG_TRDT);
<> 144:ef7eb2e8f9f7 634 }
<> 144:ef7eb2e8f9f7 635 }
<> 144:ef7eb2e8f9f7 636
<> 144:ef7eb2e8f9f7 637 HAL_PCD_ResetCallback(hpcd);
<> 144:ef7eb2e8f9f7 638
<> 144:ef7eb2e8f9f7 639 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);
<> 144:ef7eb2e8f9f7 640 }
<> 144:ef7eb2e8f9f7 641
<> 144:ef7eb2e8f9f7 642 /* Handle RxQLevel Interrupt */
<> 144:ef7eb2e8f9f7 643 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))
<> 144:ef7eb2e8f9f7 644 {
<> 144:ef7eb2e8f9f7 645 USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<> 144:ef7eb2e8f9f7 646 temp = USBx->GRXSTSP;
<> 144:ef7eb2e8f9f7 647 ep = &hpcd->OUT_ep[temp & USB_OTG_GRXSTSP_EPNUM];
<> 144:ef7eb2e8f9f7 648
<> 144:ef7eb2e8f9f7 649 if(((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_DATA_UPDT)
<> 144:ef7eb2e8f9f7 650 {
<> 144:ef7eb2e8f9f7 651 if((temp & USB_OTG_GRXSTSP_BCNT) != 0)
<> 144:ef7eb2e8f9f7 652 {
<> 144:ef7eb2e8f9f7 653 USB_ReadPacket(USBx, ep->xfer_buff, (temp & USB_OTG_GRXSTSP_BCNT) >> 4);
<> 144:ef7eb2e8f9f7 654 ep->xfer_buff += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<> 144:ef7eb2e8f9f7 655 ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<> 144:ef7eb2e8f9f7 656 }
<> 144:ef7eb2e8f9f7 657 }
<> 144:ef7eb2e8f9f7 658 else if (((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_SETUP_UPDT)
<> 144:ef7eb2e8f9f7 659 {
<> 144:ef7eb2e8f9f7 660 USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8);
<> 144:ef7eb2e8f9f7 661 ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<> 144:ef7eb2e8f9f7 662 }
<> 144:ef7eb2e8f9f7 663 USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<> 144:ef7eb2e8f9f7 664 }
<> 144:ef7eb2e8f9f7 665
<> 144:ef7eb2e8f9f7 666 /* Handle SOF Interrupt */
<> 144:ef7eb2e8f9f7 667 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))
<> 144:ef7eb2e8f9f7 668 {
<> 144:ef7eb2e8f9f7 669 HAL_PCD_SOFCallback(hpcd);
<> 144:ef7eb2e8f9f7 670 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);
<> 144:ef7eb2e8f9f7 671 }
<> 144:ef7eb2e8f9f7 672
<> 144:ef7eb2e8f9f7 673 /* Handle Incomplete ISO IN Interrupt */
<> 144:ef7eb2e8f9f7 674 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))
<> 144:ef7eb2e8f9f7 675 {
<> 144:ef7eb2e8f9f7 676 HAL_PCD_ISOINIncompleteCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 677 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);
<> 144:ef7eb2e8f9f7 678 }
<> 144:ef7eb2e8f9f7 679
<> 144:ef7eb2e8f9f7 680 /* Handle Incomplete ISO OUT Interrupt */
<> 144:ef7eb2e8f9f7 681 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
<> 144:ef7eb2e8f9f7 682 {
<> 144:ef7eb2e8f9f7 683 HAL_PCD_ISOOUTIncompleteCallback(hpcd, epnum);
<> 144:ef7eb2e8f9f7 684 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
<> 144:ef7eb2e8f9f7 685 }
<> 144:ef7eb2e8f9f7 686
<> 144:ef7eb2e8f9f7 687 /* Handle Connection event Interrupt */
<> 144:ef7eb2e8f9f7 688 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
<> 144:ef7eb2e8f9f7 689 {
<> 144:ef7eb2e8f9f7 690 HAL_PCD_ConnectCallback(hpcd);
<> 144:ef7eb2e8f9f7 691 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
<> 144:ef7eb2e8f9f7 692 }
<> 144:ef7eb2e8f9f7 693
<> 144:ef7eb2e8f9f7 694 /* Handle Disconnection event Interrupt */
<> 144:ef7eb2e8f9f7 695 if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))
<> 144:ef7eb2e8f9f7 696 {
<> 144:ef7eb2e8f9f7 697 temp = hpcd->Instance->GOTGINT;
<> 144:ef7eb2e8f9f7 698
<> 144:ef7eb2e8f9f7 699 if((temp & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)
<> 144:ef7eb2e8f9f7 700 {
<> 144:ef7eb2e8f9f7 701 HAL_PCD_DisconnectCallback(hpcd);
<> 144:ef7eb2e8f9f7 702 }
<> 144:ef7eb2e8f9f7 703 hpcd->Instance->GOTGINT |= temp;
<> 144:ef7eb2e8f9f7 704 }
<> 144:ef7eb2e8f9f7 705 }
<> 144:ef7eb2e8f9f7 706 }
<> 144:ef7eb2e8f9f7 707
<> 144:ef7eb2e8f9f7 708 /**
<> 144:ef7eb2e8f9f7 709 * @brief Data OUT stage callback.
<> 144:ef7eb2e8f9f7 710 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 711 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 712 * @retval None
<> 144:ef7eb2e8f9f7 713 */
<> 144:ef7eb2e8f9f7 714 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 715 {
<> 144:ef7eb2e8f9f7 716 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 717 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 718 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 719 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 720 the HAL_PCD_DataOutStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 721 */
<> 144:ef7eb2e8f9f7 722 }
<> 144:ef7eb2e8f9f7 723
<> 144:ef7eb2e8f9f7 724 /**
<> 144:ef7eb2e8f9f7 725 * @brief Data IN stage callback.
<> 144:ef7eb2e8f9f7 726 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 727 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 728 * @retval None
<> 144:ef7eb2e8f9f7 729 */
<> 144:ef7eb2e8f9f7 730 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 731 {
<> 144:ef7eb2e8f9f7 732 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 733 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 734 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 735 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 736 the HAL_PCD_DataInStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 737 */
<> 144:ef7eb2e8f9f7 738 }
<> 144:ef7eb2e8f9f7 739 /**
<> 144:ef7eb2e8f9f7 740 * @brief Setup stage callback.
<> 144:ef7eb2e8f9f7 741 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 742 * @retval None
<> 144:ef7eb2e8f9f7 743 */
<> 144:ef7eb2e8f9f7 744 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 745 {
<> 144:ef7eb2e8f9f7 746 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 747 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 748
<> 144:ef7eb2e8f9f7 749 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 750 the HAL_PCD_SetupStageCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 751 */
<> 144:ef7eb2e8f9f7 752 }
<> 144:ef7eb2e8f9f7 753
<> 144:ef7eb2e8f9f7 754 /**
<> 144:ef7eb2e8f9f7 755 * @brief USB Start Of Frame callback.
<> 144:ef7eb2e8f9f7 756 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 757 * @retval None
<> 144:ef7eb2e8f9f7 758 */
<> 144:ef7eb2e8f9f7 759 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 760 {
<> 144:ef7eb2e8f9f7 761 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 762 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 763
<> 144:ef7eb2e8f9f7 764 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 765 the HAL_PCD_SOFCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 766 */
<> 144:ef7eb2e8f9f7 767 }
<> 144:ef7eb2e8f9f7 768
<> 144:ef7eb2e8f9f7 769 /**
<> 144:ef7eb2e8f9f7 770 * @brief USB Reset callback.
<> 144:ef7eb2e8f9f7 771 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 772 * @retval None
<> 144:ef7eb2e8f9f7 773 */
<> 144:ef7eb2e8f9f7 774 __weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 775 {
<> 144:ef7eb2e8f9f7 776 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 777 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 778
<> 144:ef7eb2e8f9f7 779 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 780 the HAL_PCD_ResetCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 781 */
<> 144:ef7eb2e8f9f7 782 }
<> 144:ef7eb2e8f9f7 783
<> 144:ef7eb2e8f9f7 784 /**
<> 144:ef7eb2e8f9f7 785 * @brief Suspend event callback.
<> 144:ef7eb2e8f9f7 786 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 787 * @retval None
<> 144:ef7eb2e8f9f7 788 */
<> 144:ef7eb2e8f9f7 789 __weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 790 {
<> 144:ef7eb2e8f9f7 791 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 792 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 793
<> 144:ef7eb2e8f9f7 794 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 795 the HAL_PCD_SuspendCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 796 */
<> 144:ef7eb2e8f9f7 797 }
<> 144:ef7eb2e8f9f7 798
<> 144:ef7eb2e8f9f7 799 /**
<> 144:ef7eb2e8f9f7 800 * @brief Resume event callback.
<> 144:ef7eb2e8f9f7 801 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 802 * @retval None
<> 144:ef7eb2e8f9f7 803 */
<> 144:ef7eb2e8f9f7 804 __weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 805 {
<> 144:ef7eb2e8f9f7 806 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 807 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 808
<> 144:ef7eb2e8f9f7 809 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 810 the HAL_PCD_ResumeCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 811 */
<> 144:ef7eb2e8f9f7 812 }
<> 144:ef7eb2e8f9f7 813
<> 144:ef7eb2e8f9f7 814 /**
<> 144:ef7eb2e8f9f7 815 * @brief Incomplete ISO OUT callback.
<> 144:ef7eb2e8f9f7 816 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 817 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 818 * @retval None
<> 144:ef7eb2e8f9f7 819 */
<> 144:ef7eb2e8f9f7 820 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 821 {
<> 144:ef7eb2e8f9f7 822 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 823 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 824 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 825 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 826 the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 827 */
<> 144:ef7eb2e8f9f7 828 }
<> 144:ef7eb2e8f9f7 829
<> 144:ef7eb2e8f9f7 830 /**
<> 144:ef7eb2e8f9f7 831 * @brief Incomplete ISO IN callback.
<> 144:ef7eb2e8f9f7 832 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 833 * @param epnum: endpoint number
<> 144:ef7eb2e8f9f7 834 * @retval None
<> 144:ef7eb2e8f9f7 835 */
<> 144:ef7eb2e8f9f7 836 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<> 144:ef7eb2e8f9f7 837 {
<> 144:ef7eb2e8f9f7 838 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 839 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 840 UNUSED(epnum);
<> 144:ef7eb2e8f9f7 841 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 842 the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 843 */
<> 144:ef7eb2e8f9f7 844 }
<> 144:ef7eb2e8f9f7 845
<> 144:ef7eb2e8f9f7 846 /**
<> 144:ef7eb2e8f9f7 847 * @brief Connection event callback.
<> 144:ef7eb2e8f9f7 848 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 849 * @retval None
<> 144:ef7eb2e8f9f7 850 */
<> 144:ef7eb2e8f9f7 851 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 852 {
<> 144:ef7eb2e8f9f7 853 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 854 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 855
<> 144:ef7eb2e8f9f7 856 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 857 the HAL_PCD_ConnectCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 858 */
<> 144:ef7eb2e8f9f7 859 }
<> 144:ef7eb2e8f9f7 860
<> 144:ef7eb2e8f9f7 861 /**
<> 144:ef7eb2e8f9f7 862 * @brief Disconnection event callback.
<> 144:ef7eb2e8f9f7 863 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 864 * @retval None
<> 144:ef7eb2e8f9f7 865 */
<> 144:ef7eb2e8f9f7 866 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 867 {
<> 144:ef7eb2e8f9f7 868 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 869 UNUSED(hpcd);
<> 144:ef7eb2e8f9f7 870
<> 144:ef7eb2e8f9f7 871 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 872 the HAL_PCD_DisconnectCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 873 */
<> 144:ef7eb2e8f9f7 874 }
<> 144:ef7eb2e8f9f7 875
<> 144:ef7eb2e8f9f7 876 /**
<> 144:ef7eb2e8f9f7 877 * @}
<> 144:ef7eb2e8f9f7 878 */
<> 144:ef7eb2e8f9f7 879
<> 144:ef7eb2e8f9f7 880 /** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
<> 144:ef7eb2e8f9f7 881 * @brief management functions
<> 144:ef7eb2e8f9f7 882 *
<> 144:ef7eb2e8f9f7 883 @verbatim
<> 144:ef7eb2e8f9f7 884 ===============================================================================
<> 144:ef7eb2e8f9f7 885 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 886 ===============================================================================
<> 144:ef7eb2e8f9f7 887 [..]
<> 144:ef7eb2e8f9f7 888 This subsection provides a set of functions allowing to control the PCD data
<> 144:ef7eb2e8f9f7 889 transfers.
<> 144:ef7eb2e8f9f7 890
<> 144:ef7eb2e8f9f7 891 @endverbatim
<> 144:ef7eb2e8f9f7 892 * @{
<> 144:ef7eb2e8f9f7 893 */
<> 144:ef7eb2e8f9f7 894
<> 144:ef7eb2e8f9f7 895 /**
<> 144:ef7eb2e8f9f7 896 * @brief Connect the USB device.
<> 144:ef7eb2e8f9f7 897 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 898 * @retval HAL status
<> 144:ef7eb2e8f9f7 899 */
<> 144:ef7eb2e8f9f7 900 HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 901 {
<> 144:ef7eb2e8f9f7 902 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 903 USB_DevConnect(hpcd->Instance);
<> 144:ef7eb2e8f9f7 904 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 905 return HAL_OK;
<> 144:ef7eb2e8f9f7 906 }
<> 144:ef7eb2e8f9f7 907
<> 144:ef7eb2e8f9f7 908 /**
<> 144:ef7eb2e8f9f7 909 * @brief Disconnect the USB device.
<> 144:ef7eb2e8f9f7 910 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 911 * @retval HAL status
<> 144:ef7eb2e8f9f7 912 */
<> 144:ef7eb2e8f9f7 913 HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 914 {
<> 144:ef7eb2e8f9f7 915 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 916 USB_DevDisconnect(hpcd->Instance);
<> 144:ef7eb2e8f9f7 917 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 918 return HAL_OK;
<> 144:ef7eb2e8f9f7 919 }
<> 144:ef7eb2e8f9f7 920
<> 144:ef7eb2e8f9f7 921 /**
<> 144:ef7eb2e8f9f7 922 * @brief Set the USB Device address.
<> 144:ef7eb2e8f9f7 923 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 924 * @param address: new device address
<> 144:ef7eb2e8f9f7 925 * @retval HAL status
<> 144:ef7eb2e8f9f7 926 */
<> 144:ef7eb2e8f9f7 927 HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
<> 144:ef7eb2e8f9f7 928 {
<> 144:ef7eb2e8f9f7 929 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 930 USB_SetDevAddress(hpcd->Instance, address);
<> 144:ef7eb2e8f9f7 931 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 932 return HAL_OK;
<> 144:ef7eb2e8f9f7 933 }
<> 144:ef7eb2e8f9f7 934 /**
<> 144:ef7eb2e8f9f7 935 * @brief Open and configure an endpoint.
<> 144:ef7eb2e8f9f7 936 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 937 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 938 * @param ep_mps: endpoint max packet size
<> 144:ef7eb2e8f9f7 939 * @param ep_type: endpoint type
<> 144:ef7eb2e8f9f7 940 * @retval HAL status
<> 144:ef7eb2e8f9f7 941 */
<> 144:ef7eb2e8f9f7 942 HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint16_t ep_mps, uint8_t ep_type)
<> 144:ef7eb2e8f9f7 943 {
<> 144:ef7eb2e8f9f7 944 HAL_StatusTypeDef ret = HAL_OK;
<> 144:ef7eb2e8f9f7 945 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 946
<> 144:ef7eb2e8f9f7 947 if ((ep_addr & 0x80) == 0x80)
<> 144:ef7eb2e8f9f7 948 {
<> 144:ef7eb2e8f9f7 949 ep = &hpcd->IN_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 950 }
<> 144:ef7eb2e8f9f7 951 else
<> 144:ef7eb2e8f9f7 952 {
<> 144:ef7eb2e8f9f7 953 ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 954 }
<> 144:ef7eb2e8f9f7 955 ep->num = ep_addr & 0x7F;
<> 144:ef7eb2e8f9f7 956
<> 144:ef7eb2e8f9f7 957 ep->is_in = (0x80 & ep_addr) != 0;
<> 144:ef7eb2e8f9f7 958 ep->maxpacket = ep_mps;
<> 144:ef7eb2e8f9f7 959 ep->type = ep_type;
<> 144:ef7eb2e8f9f7 960 if (ep->is_in)
<> 144:ef7eb2e8f9f7 961 {
<> 144:ef7eb2e8f9f7 962 /* Assign a Tx FIFO */
<> 144:ef7eb2e8f9f7 963 ep->tx_fifo_num = ep->num;
<> 144:ef7eb2e8f9f7 964 }
<> 144:ef7eb2e8f9f7 965 /* Set initial data PID. */
<> 144:ef7eb2e8f9f7 966 if (ep_type == EP_TYPE_BULK )
<> 144:ef7eb2e8f9f7 967 {
<> 144:ef7eb2e8f9f7 968 ep->data_pid_start = 0;
<> 144:ef7eb2e8f9f7 969 }
<> 144:ef7eb2e8f9f7 970
<> 144:ef7eb2e8f9f7 971 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 972 USB_ActivateEndpoint(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 973 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 974 return ret;
<> 144:ef7eb2e8f9f7 975 }
<> 144:ef7eb2e8f9f7 976
<> 144:ef7eb2e8f9f7 977
<> 144:ef7eb2e8f9f7 978 /**
<> 144:ef7eb2e8f9f7 979 * @brief Deactivate an endpoint.
<> 144:ef7eb2e8f9f7 980 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 981 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 982 * @retval HAL status
<> 144:ef7eb2e8f9f7 983 */
<> 144:ef7eb2e8f9f7 984 HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 985 {
<> 144:ef7eb2e8f9f7 986 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 987
<> 144:ef7eb2e8f9f7 988 if ((ep_addr & 0x80) == 0x80)
<> 144:ef7eb2e8f9f7 989 {
<> 144:ef7eb2e8f9f7 990 ep = &hpcd->IN_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 991 }
<> 144:ef7eb2e8f9f7 992 else
<> 144:ef7eb2e8f9f7 993 {
<> 144:ef7eb2e8f9f7 994 ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 995 }
<> 144:ef7eb2e8f9f7 996 ep->num = ep_addr & 0x7F;
<> 144:ef7eb2e8f9f7 997
<> 144:ef7eb2e8f9f7 998 ep->is_in = (0x80 & ep_addr) != 0;
<> 144:ef7eb2e8f9f7 999
<> 144:ef7eb2e8f9f7 1000 __HAL_LOCK(hpcd);
<> 144:ef7eb2e8f9f7 1001 USB_DeactivateEndpoint(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 1002 __HAL_UNLOCK(hpcd);
<> 144:ef7eb2e8f9f7 1003 return HAL_OK;
<> 144:ef7eb2e8f9f7 1004 }
<> 144:ef7eb2e8f9f7 1005
<> 144:ef7eb2e8f9f7 1006
<> 144:ef7eb2e8f9f7 1007 /**
<> 144:ef7eb2e8f9f7 1008 * @brief Receive an amount of data.
<> 144:ef7eb2e8f9f7 1009 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1010 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1011 * @param pBuf: pointer to the reception buffer
<> 144:ef7eb2e8f9f7 1012 * @param len: amount of data to be received
<> 144:ef7eb2e8f9f7 1013 * @retval HAL status
<> 144:ef7eb2e8f9f7 1014 */
<> 144:ef7eb2e8f9f7 1015 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
<> 144:ef7eb2e8f9f7 1016 {
<> 144:ef7eb2e8f9f7 1017 USB_OTG_EPTypeDef *ep;
<> 161:2cc1468da177 1018
<> 144:ef7eb2e8f9f7 1019 ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<> 161:2cc1468da177 1020
<> 144:ef7eb2e8f9f7 1021 /*setup and start the Xfer */
<> 144:ef7eb2e8f9f7 1022 ep->xfer_buff = pBuf;
<> 144:ef7eb2e8f9f7 1023 ep->xfer_len = len;
<> 144:ef7eb2e8f9f7 1024 ep->xfer_count = 0;
<> 144:ef7eb2e8f9f7 1025 ep->is_in = 0;
<> 144:ef7eb2e8f9f7 1026 ep->num = ep_addr & 0x7F;
<> 161:2cc1468da177 1027
<> 144:ef7eb2e8f9f7 1028 if (hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 1029 {
<> 144:ef7eb2e8f9f7 1030 ep->dma_addr = (uint32_t)pBuf;
<> 144:ef7eb2e8f9f7 1031 }
<> 144:ef7eb2e8f9f7 1032
<> 153:fa9ff456f731 1033 __HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1034
<> 144:ef7eb2e8f9f7 1035 if ((ep_addr & 0x7F) == 0 )
<> 144:ef7eb2e8f9f7 1036 {
<> 144:ef7eb2e8f9f7 1037 USB_EP0StartXfer(hpcd->Instance , ep, hpcd->Init.dma_enable);
<> 144:ef7eb2e8f9f7 1038 }
<> 144:ef7eb2e8f9f7 1039 else
<> 144:ef7eb2e8f9f7 1040 {
<> 144:ef7eb2e8f9f7 1041 USB_EPStartXfer(hpcd->Instance , ep, hpcd->Init.dma_enable);
<> 144:ef7eb2e8f9f7 1042 }
<> 153:fa9ff456f731 1043 __HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1044
<> 144:ef7eb2e8f9f7 1045 return HAL_OK;
<> 144:ef7eb2e8f9f7 1046 }
<> 144:ef7eb2e8f9f7 1047
<> 144:ef7eb2e8f9f7 1048 /**
<> 144:ef7eb2e8f9f7 1049 * @brief Get Received Data Size.
<> 144:ef7eb2e8f9f7 1050 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1051 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1052 * @retval Data Size
<> 144:ef7eb2e8f9f7 1053 */
<> 144:ef7eb2e8f9f7 1054 uint16_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1055 {
<> 161:2cc1468da177 1056 return hpcd->OUT_ep[ep_addr & 0xF].xfer_count;
<> 144:ef7eb2e8f9f7 1057 }
<> 144:ef7eb2e8f9f7 1058 /**
<> 144:ef7eb2e8f9f7 1059 * @brief Send an amount of data.
<> 144:ef7eb2e8f9f7 1060 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1061 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1062 * @param pBuf: pointer to the transmission buffer
<> 144:ef7eb2e8f9f7 1063 * @param len: amount of data to be sent
<> 144:ef7eb2e8f9f7 1064 * @retval HAL status
<> 144:ef7eb2e8f9f7 1065 */
<> 144:ef7eb2e8f9f7 1066 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
<> 144:ef7eb2e8f9f7 1067 {
<> 144:ef7eb2e8f9f7 1068 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 1069
<> 144:ef7eb2e8f9f7 1070 ep = &hpcd->IN_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 1071
<> 144:ef7eb2e8f9f7 1072 /*setup and start the Xfer */
<> 144:ef7eb2e8f9f7 1073 ep->xfer_buff = pBuf;
<> 144:ef7eb2e8f9f7 1074 ep->xfer_len = len;
<> 144:ef7eb2e8f9f7 1075 ep->xfer_count = 0;
<> 144:ef7eb2e8f9f7 1076 ep->is_in = 1;
<> 144:ef7eb2e8f9f7 1077 ep->num = ep_addr & 0x7F;
<> 144:ef7eb2e8f9f7 1078
<> 144:ef7eb2e8f9f7 1079 if (hpcd->Init.dma_enable == 1)
<> 144:ef7eb2e8f9f7 1080 {
<> 144:ef7eb2e8f9f7 1081 ep->dma_addr = (uint32_t)pBuf;
<> 144:ef7eb2e8f9f7 1082 }
<> 144:ef7eb2e8f9f7 1083
<> 153:fa9ff456f731 1084 __HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1085
<> 144:ef7eb2e8f9f7 1086 if ((ep_addr & 0x7F) == 0 )
<> 144:ef7eb2e8f9f7 1087 {
<> 144:ef7eb2e8f9f7 1088 USB_EP0StartXfer(hpcd->Instance , ep, hpcd->Init.dma_enable);
<> 144:ef7eb2e8f9f7 1089 }
<> 144:ef7eb2e8f9f7 1090 else
<> 144:ef7eb2e8f9f7 1091 {
<> 144:ef7eb2e8f9f7 1092 USB_EPStartXfer(hpcd->Instance , ep, hpcd->Init.dma_enable);
<> 144:ef7eb2e8f9f7 1093 }
<> 144:ef7eb2e8f9f7 1094
<> 153:fa9ff456f731 1095 __HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 153:fa9ff456f731 1096
<> 144:ef7eb2e8f9f7 1097 return HAL_OK;
<> 144:ef7eb2e8f9f7 1098 }
<> 144:ef7eb2e8f9f7 1099
<> 144:ef7eb2e8f9f7 1100 /**
<> 144:ef7eb2e8f9f7 1101 * @brief Set a STALL condition over an endpoint.
<> 144:ef7eb2e8f9f7 1102 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1103 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1104 * @retval HAL status
<> 144:ef7eb2e8f9f7 1105 */
<> 144:ef7eb2e8f9f7 1106 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1107 {
<> 144:ef7eb2e8f9f7 1108 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 1109
<> 144:ef7eb2e8f9f7 1110 if ((0x80 & ep_addr) == 0x80)
<> 144:ef7eb2e8f9f7 1111 {
<> 144:ef7eb2e8f9f7 1112 ep = &hpcd->IN_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 1113 }
<> 144:ef7eb2e8f9f7 1114 else
<> 144:ef7eb2e8f9f7 1115 {
<> 144:ef7eb2e8f9f7 1116 ep = &hpcd->OUT_ep[ep_addr];
<> 144:ef7eb2e8f9f7 1117 }
<> 144:ef7eb2e8f9f7 1118
<> 144:ef7eb2e8f9f7 1119 ep->is_stall = 1;
<> 144:ef7eb2e8f9f7 1120 ep->num = ep_addr & 0x7F;
<> 144:ef7eb2e8f9f7 1121 ep->is_in = ((ep_addr & 0x80) == 0x80);
<> 144:ef7eb2e8f9f7 1122
<> 144:ef7eb2e8f9f7 1123
<> 153:fa9ff456f731 1124 __HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1125 USB_EPSetStall(hpcd->Instance , ep);
<> 144:ef7eb2e8f9f7 1126 if((ep_addr & 0x7F) == 0)
<> 144:ef7eb2e8f9f7 1127 {
<> 144:ef7eb2e8f9f7 1128 USB_EP0_OutStart(hpcd->Instance, hpcd->Init.dma_enable, (uint8_t *)hpcd->Setup);
<> 144:ef7eb2e8f9f7 1129 }
<> 153:fa9ff456f731 1130 __HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1131
<> 144:ef7eb2e8f9f7 1132 return HAL_OK;
<> 144:ef7eb2e8f9f7 1133 }
<> 144:ef7eb2e8f9f7 1134
<> 144:ef7eb2e8f9f7 1135 /**
<> 144:ef7eb2e8f9f7 1136 * @brief Clear a STALL condition over in an endpoint.
<> 144:ef7eb2e8f9f7 1137 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1138 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1139 * @retval HAL status
<> 144:ef7eb2e8f9f7 1140 */
<> 144:ef7eb2e8f9f7 1141 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1142 {
<> 144:ef7eb2e8f9f7 1143 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 1144
<> 144:ef7eb2e8f9f7 1145 if ((0x80 & ep_addr) == 0x80)
<> 144:ef7eb2e8f9f7 1146 {
<> 144:ef7eb2e8f9f7 1147 ep = &hpcd->IN_ep[ep_addr & 0x7F];
<> 144:ef7eb2e8f9f7 1148 }
<> 144:ef7eb2e8f9f7 1149 else
<> 144:ef7eb2e8f9f7 1150 {
<> 144:ef7eb2e8f9f7 1151 ep = &hpcd->OUT_ep[ep_addr];
<> 144:ef7eb2e8f9f7 1152 }
<> 144:ef7eb2e8f9f7 1153
<> 144:ef7eb2e8f9f7 1154 ep->is_stall = 0;
<> 144:ef7eb2e8f9f7 1155 ep->num = ep_addr & 0x7F;
<> 144:ef7eb2e8f9f7 1156 ep->is_in = ((ep_addr & 0x80) == 0x80);
<> 144:ef7eb2e8f9f7 1157
<> 153:fa9ff456f731 1158 __HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1159 USB_EPClearStall(hpcd->Instance , ep);
<> 153:fa9ff456f731 1160 __HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1161
<> 144:ef7eb2e8f9f7 1162 return HAL_OK;
<> 144:ef7eb2e8f9f7 1163 }
<> 144:ef7eb2e8f9f7 1164
<> 144:ef7eb2e8f9f7 1165 /**
<> 144:ef7eb2e8f9f7 1166 * @brief Flush an endpoint.
<> 144:ef7eb2e8f9f7 1167 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1168 * @param ep_addr: endpoint address
<> 144:ef7eb2e8f9f7 1169 * @retval HAL status
<> 144:ef7eb2e8f9f7 1170 */
<> 144:ef7eb2e8f9f7 1171 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<> 144:ef7eb2e8f9f7 1172 {
<> 153:fa9ff456f731 1173 __HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1174
<> 144:ef7eb2e8f9f7 1175 if ((ep_addr & 0x80) == 0x80)
<> 144:ef7eb2e8f9f7 1176 {
<> 144:ef7eb2e8f9f7 1177 USB_FlushTxFifo(hpcd->Instance, ep_addr & 0x7F);
<> 144:ef7eb2e8f9f7 1178 }
<> 144:ef7eb2e8f9f7 1179 else
<> 144:ef7eb2e8f9f7 1180 {
<> 144:ef7eb2e8f9f7 1181 USB_FlushRxFifo(hpcd->Instance);
<> 144:ef7eb2e8f9f7 1182 }
<> 144:ef7eb2e8f9f7 1183
<> 153:fa9ff456f731 1184 __HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<> 144:ef7eb2e8f9f7 1185
<> 144:ef7eb2e8f9f7 1186 return HAL_OK;
<> 144:ef7eb2e8f9f7 1187 }
<> 144:ef7eb2e8f9f7 1188
<> 144:ef7eb2e8f9f7 1189 /**
<> 144:ef7eb2e8f9f7 1190 * @brief Activate remote wakeup signalling.
<> 144:ef7eb2e8f9f7 1191 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1192 * @retval HAL status
<> 144:ef7eb2e8f9f7 1193 */
<> 144:ef7eb2e8f9f7 1194 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1195 {
<> 144:ef7eb2e8f9f7 1196 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<> 144:ef7eb2e8f9f7 1197
<> 144:ef7eb2e8f9f7 1198 if((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
<> 144:ef7eb2e8f9f7 1199 {
<> 144:ef7eb2e8f9f7 1200 /* Activate Remote wakeup signaling */
<> 144:ef7eb2e8f9f7 1201 USBx_DEVICE->DCTL |= USB_OTG_DCTL_RWUSIG;
<> 144:ef7eb2e8f9f7 1202 }
<> 144:ef7eb2e8f9f7 1203 return HAL_OK;
<> 144:ef7eb2e8f9f7 1204 }
<> 144:ef7eb2e8f9f7 1205
<> 144:ef7eb2e8f9f7 1206 /**
<> 144:ef7eb2e8f9f7 1207 * @brief De-activate remote wakeup signalling.
<> 144:ef7eb2e8f9f7 1208 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1209 * @retval HAL status
<> 144:ef7eb2e8f9f7 1210 */
<> 144:ef7eb2e8f9f7 1211 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1212 {
<> 144:ef7eb2e8f9f7 1213 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<> 144:ef7eb2e8f9f7 1214
<> 144:ef7eb2e8f9f7 1215 /* De-activate Remote wakeup signaling */
<> 144:ef7eb2e8f9f7 1216 USBx_DEVICE->DCTL &= ~(USB_OTG_DCTL_RWUSIG);
<> 144:ef7eb2e8f9f7 1217 return HAL_OK;
<> 144:ef7eb2e8f9f7 1218 }
<> 144:ef7eb2e8f9f7 1219 /**
<> 144:ef7eb2e8f9f7 1220 * @}
<> 144:ef7eb2e8f9f7 1221 */
<> 144:ef7eb2e8f9f7 1222
<> 144:ef7eb2e8f9f7 1223 /** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
<> 144:ef7eb2e8f9f7 1224 * @brief Peripheral State functions
<> 144:ef7eb2e8f9f7 1225 *
<> 144:ef7eb2e8f9f7 1226 @verbatim
<> 144:ef7eb2e8f9f7 1227 ===============================================================================
<> 144:ef7eb2e8f9f7 1228 ##### Peripheral State functions #####
<> 144:ef7eb2e8f9f7 1229 ===============================================================================
<> 144:ef7eb2e8f9f7 1230 [..]
<> 144:ef7eb2e8f9f7 1231 This subsection permits to get in run-time the status of the peripheral
<> 144:ef7eb2e8f9f7 1232 and the data flow.
<> 144:ef7eb2e8f9f7 1233
<> 144:ef7eb2e8f9f7 1234 @endverbatim
<> 144:ef7eb2e8f9f7 1235 * @{
<> 144:ef7eb2e8f9f7 1236 */
<> 144:ef7eb2e8f9f7 1237
<> 144:ef7eb2e8f9f7 1238 /**
<> 144:ef7eb2e8f9f7 1239 * @brief Return the PCD handle state.
<> 144:ef7eb2e8f9f7 1240 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1241 * @retval HAL state
<> 144:ef7eb2e8f9f7 1242 */
<> 144:ef7eb2e8f9f7 1243 PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef *hpcd)
<> 144:ef7eb2e8f9f7 1244 {
<> 144:ef7eb2e8f9f7 1245 return hpcd->State;
<> 144:ef7eb2e8f9f7 1246 }
<> 144:ef7eb2e8f9f7 1247 /**
<> 144:ef7eb2e8f9f7 1248 * @}
<> 144:ef7eb2e8f9f7 1249 */
<> 144:ef7eb2e8f9f7 1250
<> 144:ef7eb2e8f9f7 1251 /**
<> 144:ef7eb2e8f9f7 1252 * @}
<> 144:ef7eb2e8f9f7 1253 */
<> 144:ef7eb2e8f9f7 1254
<> 144:ef7eb2e8f9f7 1255 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 1256 /** @addtogroup PCD_Private_Functions
<> 144:ef7eb2e8f9f7 1257 * @{
<> 144:ef7eb2e8f9f7 1258 */
<> 144:ef7eb2e8f9f7 1259
<> 144:ef7eb2e8f9f7 1260 /**
<> 144:ef7eb2e8f9f7 1261 * @brief Check FIFO for the next packet to be loaded.
<> 144:ef7eb2e8f9f7 1262 * @param hpcd: PCD handle
<> 144:ef7eb2e8f9f7 1263 * @param epnum : endpoint number
<> 144:ef7eb2e8f9f7 1264 * @retval HAL status
<> 144:ef7eb2e8f9f7 1265 */
<> 144:ef7eb2e8f9f7 1266 static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum)
<> 144:ef7eb2e8f9f7 1267 {
<> 144:ef7eb2e8f9f7 1268 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<> 144:ef7eb2e8f9f7 1269 USB_OTG_EPTypeDef *ep;
<> 144:ef7eb2e8f9f7 1270 int32_t len = 0;
<> 144:ef7eb2e8f9f7 1271 uint32_t len32b;
<> 144:ef7eb2e8f9f7 1272 uint32_t fifoemptymsk = 0;
<> 144:ef7eb2e8f9f7 1273
<> 144:ef7eb2e8f9f7 1274 ep = &hpcd->IN_ep[epnum];
<> 144:ef7eb2e8f9f7 1275 len = ep->xfer_len - ep->xfer_count;
<> 144:ef7eb2e8f9f7 1276
<> 144:ef7eb2e8f9f7 1277 if (len > ep->maxpacket)
<> 144:ef7eb2e8f9f7 1278 {
<> 144:ef7eb2e8f9f7 1279 len = ep->maxpacket;
<> 144:ef7eb2e8f9f7 1280 }
<> 144:ef7eb2e8f9f7 1281
<> 144:ef7eb2e8f9f7 1282
<> 144:ef7eb2e8f9f7 1283 len32b = (len + 3) / 4;
<> 144:ef7eb2e8f9f7 1284
<> 144:ef7eb2e8f9f7 1285 while ( (USBx_INEP(epnum)->DTXFSTS & USB_OTG_DTXFSTS_INEPTFSAV) > len32b &&
<> 144:ef7eb2e8f9f7 1286 ep->xfer_count < ep->xfer_len &&
<> 144:ef7eb2e8f9f7 1287 ep->xfer_len != 0)
<> 144:ef7eb2e8f9f7 1288 {
<> 144:ef7eb2e8f9f7 1289 /* Write the FIFO */
<> 144:ef7eb2e8f9f7 1290 len = ep->xfer_len - ep->xfer_count;
<> 144:ef7eb2e8f9f7 1291
<> 144:ef7eb2e8f9f7 1292 if (len > ep->maxpacket)
<> 144:ef7eb2e8f9f7 1293 {
<> 144:ef7eb2e8f9f7 1294 len = ep->maxpacket;
<> 144:ef7eb2e8f9f7 1295 }
<> 144:ef7eb2e8f9f7 1296 len32b = (len + 3) / 4;
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 USB_WritePacket(USBx, ep->xfer_buff, epnum, len, hpcd->Init.dma_enable);
<> 144:ef7eb2e8f9f7 1299
<> 144:ef7eb2e8f9f7 1300 ep->xfer_buff += len;
<> 144:ef7eb2e8f9f7 1301 ep->xfer_count += len;
<> 144:ef7eb2e8f9f7 1302 }
<> 144:ef7eb2e8f9f7 1303
<> 144:ef7eb2e8f9f7 1304 if(len <= 0)
<> 144:ef7eb2e8f9f7 1305 {
<> 144:ef7eb2e8f9f7 1306 fifoemptymsk = 0x1 << epnum;
<> 153:fa9ff456f731 1307 atomic_clr_u32(&USBx_DEVICE->DIEPEMPMSK, fifoemptymsk);
<> 144:ef7eb2e8f9f7 1308
<> 144:ef7eb2e8f9f7 1309 }
<> 144:ef7eb2e8f9f7 1310
<> 144:ef7eb2e8f9f7 1311 return HAL_OK;
<> 144:ef7eb2e8f9f7 1312 }
<> 144:ef7eb2e8f9f7 1313
<> 144:ef7eb2e8f9f7 1314 /**
<> 144:ef7eb2e8f9f7 1315 * @}
<> 144:ef7eb2e8f9f7 1316 */
<> 144:ef7eb2e8f9f7 1317
<> 144:ef7eb2e8f9f7 1318 #endif /* HAL_PCD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1319 /**
<> 144:ef7eb2e8f9f7 1320 * @}
<> 144:ef7eb2e8f9f7 1321 */
<> 144:ef7eb2e8f9f7 1322
<> 144:ef7eb2e8f9f7 1323 /**
<> 144:ef7eb2e8f9f7 1324 * @}
<> 144:ef7eb2e8f9f7 1325 */
<> 144:ef7eb2e8f9f7 1326
<> 144:ef7eb2e8f9f7 1327 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/