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_DISCO_L053C8/stm32l0xx_hal_pcd.c@376:cb4d9db17537, 2014-10-31 (annotated)

Committer:
mbed_official
Date:
Fri Oct 31 11:00:10 2014 +0000
Revision:
376:cb4d9db17537
Synchronized with git revision 07b49da75eac883fc8916d3d6b6962664b8db29e



Full URL: https://github.com/mbedmicro/mbed/commit/07b49da75eac883fc8916d3d6b6962664b8db29e/



Targets: DISCO_L053C8 - new platform - STM32L0 Discovery board

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