zain aftab / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_pcd.c@636:a11c0372f0ba, 2015-09-30 (annotated)

Committer:
mbed_official
Date:
Wed Sep 30 17:00:09 2015 +0100
Revision:
636:a11c0372f0ba
Parent:
490:119543c9f674 
Synchronized with git revision d29c98dae61be0946ddf3a3c641c7726056f9452



Full URL: https://github.com/mbedmicro/mbed/commit/d29c98dae61be0946ddf3a3c641c7726056f9452/



Added support for SAMW25

Who changed what in which revision?

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