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_STM32F0/device/stm32f0xx_hal_pcd.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
180:96ed750bd169 
mbed library release version 165

Who changed what in which revision?

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