mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

targets/TARGET_STM/TARGET_STM32L0/device/stm32l0xx_hal_pcd.c@186:707f6e361f3e, 2018-06-22 (annotated)

Committer:
Anna Bridge
Date:
Fri Jun 22 16:45:37 2018 +0100
Revision:
186:707f6e361f3e
Parent:
151:5eaa88a5bcc7 
mbed-dev library. Release version 162

Who changed what in which revision?

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