Toyomasa Watarai / mbed-dev-lpcx1769

Important changes to repositories hosted on mbed.com

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

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

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

Dependents:   LPCXpresso1769_blinky

Fork of mbed-dev by mbed official

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

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

Who changed what in which revision?

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