shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_pcd.c@181:a4cbdfbbd2f4, 2014-05-07 (annotated)

Committer:
mbed_official
Date:
Wed May 07 13:15:08 2014 +0100
Revision:
181:a4cbdfbbd2f4
Synchronized with git revision 7751e759576c6fd68deccb81ea82bac19ed41745



Full URL: https://github.com/mbedmicro/mbed/commit/7751e759576c6fd68deccb81ea82bac19ed41745/

Who changed what in which revision?

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