Src/usbd_conf.c

   1 /**
   2   ******************************************************************************
   3   * @file           : usbd_conf.c
   4   * @version        : v2.0_Cube
   5   * @brief          : This file implements the board support package for the USB device library
   6   ******************************************************************************
   7   * This notice applies to any and all portions of this file
   8   * that are not between comment pairs USER CODE BEGIN and
   9   * USER CODE END. Other portions of this file, whether
  10   * inserted by the user or by software development tools
  11   * are owned by their respective copyright owners.
  12   *
  13   * Copyright (c) 2018 STMicroelectronics International N.V.
  14   * All rights reserved.
  15   *
  16   * Redistribution and use in source and binary forms, with or without
  17   * modification, are permitted, provided that the following conditions are met:
  18   *
  19   * 1. Redistribution of source code must retain the above copyright notice,
  20   *    this list of conditions and the following disclaimer.
  21   * 2. Redistributions in binary form must reproduce the above copyright notice,
  22   *    this list of conditions and the following disclaimer in the documentation
  23   *    and/or other materials provided with the distribution.
  24   * 3. Neither the name of STMicroelectronics nor the names of other
  25   *    contributors to this software may be used to endorse or promote products
  26   *    derived from this software without specific written permission.
  27   * 4. This software, including modifications and/or derivative works of this
  28   *    software, must execute solely and exclusively on microcontroller or
  29   *    microprocessor devices manufactured by or for STMicroelectronics.
  30   * 5. Redistribution and use of this software other than as permitted under
  31   *    this license is void and will automatically terminate your rights under
  32   *    this license.
  33   *
  34   * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
  35   * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
  36   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  37   * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
  38   * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
  39   * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  40   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  42   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  43   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  44   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  45   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46   *
  47   ******************************************************************************
  48   */
  49
  50 /* Includes ------------------------------------------------------------------*/
  51 #include "stm32f1xx.h"
  52 #include "stm32f1xx_hal.h"
  53 #include "usbd_def.h"
  54 #include "usbd_core.h"
  55 #include "usbd_dfu.h"
  56
  57 /* USER CODE BEGIN Includes */
  58
  59 /* USER CODE END Includes */
  60
  61 /* Private typedef -----------------------------------------------------------*/
  62 /* Private define ------------------------------------------------------------*/
  63 /* Private macro -------------------------------------------------------------*/
  64
  65 /* USER CODE BEGIN PV */
  66 /* Private variables ---------------------------------------------------------*/
  67
  68 /* USER CODE END PV */
  69
  70 PCD_HandleTypeDef hpcd_USB_FS;
  71 void _Error_Handler(char * file, int line);
  72
  73 /* USER CODE BEGIN 0 */
  74
  75 /* USER CODE END 0 */
  76
  77 /* USER CODE BEGIN PFP */
  78 /* Private function prototypes -----------------------------------------------*/
  79
  80 /* USER CODE END PFP */
  81
  82 /* Private functions ---------------------------------------------------------*/
  83
  84 /* USER CODE BEGIN 1 */
  85
  86 /* USER CODE END 1 */
  87
  88 void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state);
  89
  90 /*******************************************************************************
  91                        LL Driver Callbacks (PCD -> USB Device Library)
  92 *******************************************************************************/
  93 /* MSP Init */
  94
  95 void HAL_PCD_MspInit(PCD_HandleTypeDef* pcdHandle)
  96 {
  97   if(pcdHandle->Instance==USB)
  98   {
  99   /* USER CODE BEGIN USB_MspInit 0 */
 100
 101   /* USER CODE END USB_MspInit 0 */
 102     /* Peripheral clock enable */
 103     __HAL_RCC_USB_CLK_ENABLE();
 104
 105     /* Peripheral interrupt init */
 106     HAL_NVIC_SetPriority(USB_HP_CAN1_TX_IRQn, 0, 0);
 107     HAL_NVIC_EnableIRQ(USB_HP_CAN1_TX_IRQn);
 108     HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 0, 0);
 109     HAL_NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
 110   /* USER CODE BEGIN USB_MspInit 1 */
 111
 112   /* USER CODE END USB_MspInit 1 */
 113   }
 114 }
 115
 116 void HAL_PCD_MspDeInit(PCD_HandleTypeDef* pcdHandle)
 117 {
 118   if(pcdHandle->Instance==USB)
 119   {
 120   /* USER CODE BEGIN USB_MspDeInit 0 */
 121
 122   /* USER CODE END USB_MspDeInit 0 */
 123     /* Peripheral clock disable */
 124     __HAL_RCC_USB_CLK_DISABLE();
 125
 126     /* Peripheral interrupt Deinit*/
 127     HAL_NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);
 128
 129     HAL_NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
 130
 131   /* USER CODE BEGIN USB_MspDeInit 1 */
 132
 133   /* USER CODE END USB_MspDeInit 1 */
 134   }
 135 }
 136
 137 /**
 138   * @brief  Setup stage callback
 139   * @param  hpcd: PCD handle
 140   * @retval None
 141   */
 142 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
 143 {
 144   USBD_LL_SetupStage((USBD_HandleTypeDef*)hpcd->pData, (uint8_t *)hpcd->Setup);
 145 }
 146
 147 /**
 148   * @brief  Data Out stage callback.
 149   * @param  hpcd: PCD handle
 150   * @param  epnum: Endpoint number
 151   * @retval None
 152   */
 153 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 154 {
 155   USBD_LL_DataOutStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
 156 }
 157
 158 /**
 159   * @brief  Data In stage callback.
 160   * @param  hpcd: PCD handle
 161   * @param  epnum: Endpoint number
 162   * @retval None
 163   */
 164 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 165 {
 166   USBD_LL_DataInStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
 167 }
 168
 169 /**
 170   * @brief  SOF callback.
 171   * @param  hpcd: PCD handle
 172   * @retval None
 173   */
 174 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
 175 {
 176   USBD_LL_SOF((USBD_HandleTypeDef*)hpcd->pData);
 177 }
 178
 179 /**
 180   * @brief  Reset callback.
 181   * @param  hpcd: PCD handle
 182   * @retval None
 183   */
 184 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
 185 {
 186   USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
 187
 188   /* Set USB current speed. */
 189   switch (hpcd->Init.speed)
 190   {
 191   case PCD_SPEED_FULL:
 192     speed = USBD_SPEED_FULL;
 193     break;
 194
 195   default:
 196     speed = USBD_SPEED_FULL;
 197     break;
 198   }
 199   USBD_LL_SetSpeed((USBD_HandleTypeDef*)hpcd->pData, speed);
 200
 201   /* Reset Device. */
 202   USBD_LL_Reset((USBD_HandleTypeDef*)hpcd->pData);
 203 }
 204
 205 /**
 206   * @brief  Suspend callback.
 207   * When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
 208   * @param  hpcd: PCD handle
 209   * @retval None
 210   */
 211 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
 212 {
 213   /* Inform USB library that core enters in suspend Mode. */
 214   USBD_LL_Suspend((USBD_HandleTypeDef*)hpcd->pData);
 215   /* Enter in STOP mode. */
 216   /* USER CODE BEGIN 2 */
 217   if (hpcd->Init.low_power_enable)
 218   {
 219     /* Set SLEEPDEEP bit and SleepOnExit of Cortex System Control Register. */
 220     SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
 221   }
 222   /* USER CODE END 2 */
 223 }
 224
 225 /**
 226   * @brief  Resume callback.
 227   * When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
 228   * @param  hpcd: PCD handle
 229   * @retval None
 230   */
 231 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
 232 {
 233   /* USER CODE BEGIN 3 */
 234
 235   /* USER CODE END 3 */
 236   USBD_LL_Resume((USBD_HandleTypeDef*)hpcd->pData);
 237 }
 238
 239 /**
 240   * @brief  ISOOUTIncomplete callback.
 241   * @param  hpcd: PCD handle
 242   * @param  epnum: Endpoint number
 243   * @retval None
 244   */
 245 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 246 {
 247   USBD_LL_IsoOUTIncomplete((USBD_HandleTypeDef*)hpcd->pData, epnum);
 248 }
 249
 250 /**
 251   * @brief  ISOINIncomplete callback.
 252   * @param  hpcd: PCD handle
 253   * @param  epnum: Endpoint number
 254   * @retval None
 255   */
 256 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 257 {
 258   USBD_LL_IsoINIncomplete((USBD_HandleTypeDef*)hpcd->pData, epnum);
 259 }
 260
 261 /**
 262   * @brief  Connect callback.
 263   * @param  hpcd: PCD handle
 264   * @retval None
 265   */
 266 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
 267 {
 268   USBD_LL_DevConnected((USBD_HandleTypeDef*)hpcd->pData);
 269 }
 270
 271 /**
 272   * @brief  Disconnect callback.
 273   * @param  hpcd: PCD handle
 274   * @retval None
 275   */
 276 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
 277 {
 278   USBD_LL_DevDisconnected((USBD_HandleTypeDef*)hpcd->pData);
 279 }
 280
 281 /*******************************************************************************
 282                        LL Driver Interface (USB Device Library --> PCD)
 283 *******************************************************************************/
 284
 285 /**
 286   * @brief  Initializes the low level portion of the device driver.
 287   * @param  pdev: Device handle
 288   * @retval USBD status
 289   */
 290 USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev)
 291 {
 292   /* Init USB Ip. */
 293   /* Link the driver to the stack. */
 294   hpcd_USB_FS.pData = pdev;
 295   pdev->pData = &hpcd_USB_FS;
 296
 297   hpcd_USB_FS.Instance = USB;
 298   hpcd_USB_FS.Init.dev_endpoints = 8;
 299   hpcd_USB_FS.Init.speed = PCD_SPEED_FULL;
 300   hpcd_USB_FS.Init.ep0_mps = DEP0CTL_MPS_64;
 301   hpcd_USB_FS.Init.low_power_enable = DISABLE;
 302   hpcd_USB_FS.Init.lpm_enable = DISABLE;
 303   hpcd_USB_FS.Init.battery_charging_enable = DISABLE;
 304   if (HAL_PCD_Init(&hpcd_USB_FS) != HAL_OK)
 305   {
 306     _Error_Handler(__FILE__, __LINE__);
 307   }
 308
 309   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x00 , PCD_SNG_BUF, 0x18);
 310   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x80 , PCD_SNG_BUF, 0x58);
 311   return USBD_OK;
 312 }
 313
 314 /**
 315   * @brief  De-Initializes the low level portion of the device driver.
 316   * @param  pdev: Device handle
 317   * @retval USBD status
 318   */
 319 USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev)
 320 {
 321   HAL_StatusTypeDef hal_status = HAL_OK;
 322   USBD_StatusTypeDef usb_status = USBD_OK;
 323
 324   hal_status = HAL_PCD_DeInit(pdev->pData);
 325
 326   switch (hal_status) {
 327     case HAL_OK :
 328       usb_status = USBD_OK;
 329     break;
 330     case HAL_ERROR :
 331       usb_status = USBD_FAIL;
 332     break;
 333     case HAL_BUSY :
 334       usb_status = USBD_BUSY;
 335     break;
 336     case HAL_TIMEOUT :
 337       usb_status = USBD_FAIL;
 338     break;
 339     default :
 340       usb_status = USBD_FAIL;
 341     break;
 342   }
 343   return usb_status;
 344 }
 345
 346 /**
 347   * @brief  Starts the low level portion of the device driver.
 348   * @param  pdev: Device handle
 349   * @retval USBD status
 350   */
 351 USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
 352 {
 353   HAL_StatusTypeDef hal_status = HAL_OK;
 354   USBD_StatusTypeDef usb_status = USBD_OK;
 355
 356   hal_status = HAL_PCD_Start(pdev->pData);
 357
 358   switch (hal_status) {
 359     case HAL_OK :
 360       usb_status = USBD_OK;
 361     break;
 362     case HAL_ERROR :
 363       usb_status = USBD_FAIL;
 364     break;
 365     case HAL_BUSY :
 366       usb_status = USBD_BUSY;
 367     break;
 368     case HAL_TIMEOUT :
 369       usb_status = USBD_FAIL;
 370     break;
 371     default :
 372       usb_status = USBD_FAIL;
 373     break;
 374   }
 375   return usb_status;
 376 }
 377
 378 /**
 379   * @brief  Stops the low level portion of the device driver.
 380   * @param  pdev: Device handle
 381   * @retval USBD status
 382   */
 383 USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev)
 384 {
 385   HAL_StatusTypeDef hal_status = HAL_OK;
 386   USBD_StatusTypeDef usb_status = USBD_OK;
 387
 388   hal_status = HAL_PCD_Stop(pdev->pData);
 389
 390   switch (hal_status) {
 391     case HAL_OK :
 392       usb_status = USBD_OK;
 393     break;
 394     case HAL_ERROR :
 395       usb_status = USBD_FAIL;
 396     break;
 397     case HAL_BUSY :
 398       usb_status = USBD_BUSY;
 399     break;
 400     case HAL_TIMEOUT :
 401       usb_status = USBD_FAIL;
 402     break;
 403     default :
 404       usb_status = USBD_FAIL;
 405     break;
 406   }
 407   return usb_status;
 408 }
 409
 410 /**
 411   * @brief  Opens an endpoint of the low level driver.
 412   * @param  pdev: Device handle
 413   * @param  ep_addr: Endpoint number
 414   * @param  ep_type: Endpoint type
 415   * @param  ep_mps: Endpoint max packet size
 416   * @retval USBD status
 417   */
 418 USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t ep_type, uint16_t ep_mps)
 419 {
 420   HAL_StatusTypeDef hal_status = HAL_OK;
 421   USBD_StatusTypeDef usb_status = USBD_OK;
 422
 423   hal_status = HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
 424
 425   switch (hal_status) {
 426     case HAL_OK :
 427       usb_status = USBD_OK;
 428     break;
 429     case HAL_ERROR :
 430       usb_status = USBD_FAIL;
 431     break;
 432     case HAL_BUSY :
 433       usb_status = USBD_BUSY;
 434     break;
 435     case HAL_TIMEOUT :
 436       usb_status = USBD_FAIL;
 437     break;
 438     default :
 439       usb_status = USBD_FAIL;
 440     break;
 441   }
 442   return usb_status;
 443 }
 444
 445 /**
 446   * @brief  Closes an endpoint of the low level driver.
 447   * @param  pdev: Device handle
 448   * @param  ep_addr: Endpoint number
 449   * @retval USBD status
 450   */
 451 USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 452 {
 453   HAL_StatusTypeDef hal_status = HAL_OK;
 454   USBD_StatusTypeDef usb_status = USBD_OK;
 455
 456   hal_status = HAL_PCD_EP_Close(pdev->pData, ep_addr);
 457
 458   switch (hal_status) {
 459     case HAL_OK :
 460       usb_status = USBD_OK;
 461     break;
 462     case HAL_ERROR :
 463       usb_status = USBD_FAIL;
 464     break;
 465     case HAL_BUSY :
 466       usb_status = USBD_BUSY;
 467     break;
 468     case HAL_TIMEOUT :
 469       usb_status = USBD_FAIL;
 470     break;
 471     default :
 472       usb_status = USBD_FAIL;
 473     break;
 474   }
 475   return usb_status;
 476 }
 477
 478 /**
 479   * @brief  Flushes an endpoint of the Low Level Driver.
 480   * @param  pdev: Device handle
 481   * @param  ep_addr: Endpoint number
 482   * @retval USBD status
 483   */
 484 USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 485 {
 486   HAL_StatusTypeDef hal_status = HAL_OK;
 487   USBD_StatusTypeDef usb_status = USBD_OK;
 488
 489   hal_status = HAL_PCD_EP_Flush(pdev->pData, ep_addr);
 490
 491   switch (hal_status) {
 492     case HAL_OK :
 493       usb_status = USBD_OK;
 494     break;
 495     case HAL_ERROR :
 496       usb_status = USBD_FAIL;
 497     break;
 498     case HAL_BUSY :
 499       usb_status = USBD_BUSY;
 500     break;
 501     case HAL_TIMEOUT :
 502       usb_status = USBD_FAIL;
 503     break;
 504     default :
 505       usb_status = USBD_FAIL;
 506     break;
 507   }
 508   return usb_status;
 509 }
 510
 511 /**
 512   * @brief  Sets a Stall condition on an endpoint of the Low Level Driver.
 513   * @param  pdev: Device handle
 514   * @param  ep_addr: Endpoint number
 515   * @retval USBD status
 516   */
 517 USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 518 {
 519   HAL_StatusTypeDef hal_status = HAL_OK;
 520   USBD_StatusTypeDef usb_status = USBD_OK;
 521
 522   hal_status = HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
 523
 524   switch (hal_status) {
 525     case HAL_OK :
 526       usb_status = USBD_OK;
 527     break;
 528     case HAL_ERROR :
 529       usb_status = USBD_FAIL;
 530     break;
 531     case HAL_BUSY :
 532       usb_status = USBD_BUSY;
 533     break;
 534     case HAL_TIMEOUT :
 535       usb_status = USBD_FAIL;
 536     break;
 537     default :
 538       usb_status = USBD_FAIL;
 539     break;
 540   }
 541   return usb_status;
 542 }
 543
 544 /**
 545   * @brief  Clears a Stall condition on an endpoint of the Low Level Driver.
 546   * @param  pdev: Device handle
 547   * @param  ep_addr: Endpoint number
 548   * @retval USBD status
 549   */
 550 USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 551 {
 552   HAL_StatusTypeDef hal_status = HAL_OK;
 553   USBD_StatusTypeDef usb_status = USBD_OK;
 554
 555   hal_status = HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);
 556
 557   switch (hal_status) {
 558     case HAL_OK :
 559       usb_status = USBD_OK;
 560     break;
 561     case HAL_ERROR :
 562       usb_status = USBD_FAIL;
 563     break;
 564     case HAL_BUSY :
 565       usb_status = USBD_BUSY;
 566     break;
 567     case HAL_TIMEOUT :
 568       usb_status = USBD_FAIL;
 569     break;
 570     default :
 571       usb_status = USBD_FAIL;
 572     break;
 573   }
 574   return usb_status;
 575 }
 576
 577 /**
 578   * @brief  Returns Stall condition.
 579   * @param  pdev: Device handle
 580   * @param  ep_addr: Endpoint number
 581   * @retval Stall (1: Yes, 0: No)
 582   */
 583 uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 584 {
 585   PCD_HandleTypeDef *hpcd = (PCD_HandleTypeDef*) pdev->pData;
 586
 587   if((ep_addr & 0x80) == 0x80)
 588   {
 589     return hpcd->IN_ep[ep_addr & 0x7F].is_stall;
 590   }
 591   else
 592   {
 593     return hpcd->OUT_ep[ep_addr & 0x7F].is_stall;
 594   }
 595 }
 596
 597 /**
 598   * @brief  Assigns a USB address to the device.
 599   * @param  pdev: Device handle
 600   * @param  dev_addr: Device address
 601   * @retval USBD status
 602   */
 603 USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev, uint8_t dev_addr)
 604 {
 605   HAL_StatusTypeDef hal_status = HAL_OK;
 606   USBD_StatusTypeDef usb_status = USBD_OK;
 607
 608   hal_status = HAL_PCD_SetAddress(pdev->pData, dev_addr);
 609
 610   switch (hal_status) {
 611     case HAL_OK :
 612       usb_status = USBD_OK;
 613     break;
 614     case HAL_ERROR :
 615       usb_status = USBD_FAIL;
 616     break;
 617     case HAL_BUSY :
 618       usb_status = USBD_BUSY;
 619     break;
 620     case HAL_TIMEOUT :
 621       usb_status = USBD_FAIL;
 622     break;
 623     default :
 624       usb_status = USBD_FAIL;
 625     break;
 626   }
 627   return usb_status;
 628 }
 629
 630 /**
 631   * @brief  Transmits data over an endpoint.
 632   * @param  pdev: Device handle
 633   * @param  ep_addr: Endpoint number
 634   * @param  pbuf: Pointer to data to be sent
 635   * @param  size: Data size
 636   * @retval USBD status
 637   */
 638 USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t *pbuf, uint16_t size)
 639 {
 640   HAL_StatusTypeDef hal_status = HAL_OK;
 641   USBD_StatusTypeDef usb_status = USBD_OK;
 642
 643   hal_status = HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
 644
 645   switch (hal_status) {
 646     case HAL_OK :
 647       usb_status = USBD_OK;
 648     break;
 649     case HAL_ERROR :
 650       usb_status = USBD_FAIL;
 651     break;
 652     case HAL_BUSY :
 653       usb_status = USBD_BUSY;
 654     break;
 655     case HAL_TIMEOUT :
 656       usb_status = USBD_FAIL;
 657     break;
 658     default :
 659       usb_status = USBD_FAIL;
 660     break;
 661   }
 662   return usb_status;
 663 }
 664
 665 /**
 666   * @brief  Prepares an endpoint for reception.
 667   * @param  pdev: Device handle
 668   * @param  ep_addr: Endpoint number
 669   * @param  pbuf: Pointer to data to be received
 670   * @param  size: Data size
 671   * @retval USBD status
 672   */
 673 USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t *pbuf, uint16_t size)
 674 {
 675   HAL_StatusTypeDef hal_status = HAL_OK;
 676   USBD_StatusTypeDef usb_status = USBD_OK;
 677
 678   hal_status = HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
 679
 680   switch (hal_status) {
 681     case HAL_OK :
 682       usb_status = USBD_OK;
 683     break;
 684     case HAL_ERROR :
 685       usb_status = USBD_FAIL;
 686     break;
 687     case HAL_BUSY :
 688       usb_status = USBD_BUSY;
 689     break;
 690     case HAL_TIMEOUT :
 691       usb_status = USBD_FAIL;
 692     break;
 693     default :
 694       usb_status = USBD_FAIL;
 695     break;
 696   }
 697   return usb_status;
 698 }
 699
 700 /**
 701   * @brief  Returns the last transfered packet size.
 702   * @param  pdev: Device handle
 703   * @param  ep_addr: Endpoint number
 704   * @retval Recived Data Size
 705   */
 706 uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
 707 {
 708   return HAL_PCD_EP_GetRxCount((PCD_HandleTypeDef*) pdev->pData, ep_addr);
 709 }
 710
 711 /**
 712   * @brief  Delays routine for the USB device library.
 713   * @param  Delay: Delay in ms
 714   * @retval None
 715   */
 716 void USBD_LL_Delay(uint32_t Delay)
 717 {
 718   HAL_Delay(Delay);
 719 }
 720
 721 /**
 722   * @brief  Static single allocation.
 723   * @param  size: Size of allocated memory
 724   * @retval None
 725   */
 726 void *USBD_static_malloc(uint32_t size)
 727 {
 728   static uint32_t mem[(sizeof(USBD_DFU_HandleTypeDef)/4)+1];/* On 32-bit boundary */
 729   return mem;
 730 }
 731
 732 /**
 733   * @brief  Dummy memory free
 734   * @param  p: Pointer to allocated  memory address
 735   * @retval None
 736   */
 737 void USBD_static_free(void *p)
 738 {
 739
 740 }
 741
 742 /**
 743   * @brief Software Device Connection
 744   * @param hpcd: PCD handle
 745   * @param state: Connection state (0: disconnected / 1: connected)
 746   * @retval None
 747   */
 748 void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
 749 {
 750   /* USER CODE BEGIN 6 */
 751   if (state == 1)
 752   {
 753     /* Configure Low connection state. */
 754
 755   }
 756   else
 757   {
 758     /* Configure High connection state. */
 759
 760   }
 761   /* USER CODE END 6 */
 762 }
 763
 764 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/