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