mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_pcd.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

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 489:119543c9f674 5 * @version V1.2.0
mbed_official 489: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 489: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 489: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 489:119543c9f674 77 #if !defined (STM32L031xx) && !defined (STM32L041xx) && !defined (STM32L051xx) && !defined (STM32L061xx) && !defined (STM32L071xx) && !defined (STM32L081xx)
mbed_official 489: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 489: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 489: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 489: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 489: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 489: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 489: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 489: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 489:119543c9f674 1309 #endif /* HAL_PCD_MODULE_ENABLED */
mbed_official 489:119543c9f674 1310 #endif /* #if !defined (STM32L031xx) && !defined (STM32L041xx) && !defined (STM32L051xx) && !defined (STM32L061xx) && !defined (STM32L071xx) && !defined (STM32L081xx) */
mbed_official 489:119543c9f674 1311 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 376:cb4d9db17537 1312