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@151:5eaa88a5bcc7, 2016-11-24 (annotated)

Committer:
<>
Date:
Thu Nov 24 17:03:03 2016 +0000
Revision:
151:5eaa88a5bcc7
Parent:
149:156823d33999
Child:
186:707f6e361f3e
This updates the lib to the mbed lib v130

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