Tux Leon / mbed-dev

mbed library sources. Supersedes mbed-src.

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_pcd.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
Parent:
0:9b334a45a8ff 
This updates the lib to the mbed lib v125

Who changed what in which revision?

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