gabriel della-monica / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_pcd.c@394:83f921546702, 2014-11-07 (annotated)

Committer:
mbed_official
Date:
Fri Nov 07 15:45:07 2014 +0000
Revision:
394:83f921546702
Parent:
targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_pcd.c@354:e67efb2aab0e 
Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e



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



Tests: Fix cpputest testrunner

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****/