src/main/vcp_hal/usbd_conf_stm32h7xx.c

   1 /**
   2  * usbd_conf.c adopted from
   3  * STM32Cube_FW_H7_V1.3.0/Projects/STM32H743I_EVAL/Applications/USB_Device/CDC_Standalone
   4  **/
   5
   6 /**
   7  ******************************************************************************
   8  * @file    USB_Device/CDC_Standalone/Src/usbd_conf.c
   9  * @author  MCD Application Team
  10  * @brief   This file implements the USB Device library callbacks and MSP
  11  ******************************************************************************
  12  * @attention
  13  *
  14  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
  15  * All rights reserved.</center></h2>
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted, provided that the following conditions are met:
  19  *
  20  * 1. Redistribution of source code must retain the above copyright notice,
  21  *    this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright notice,
  23  *    this list of conditions and the following disclaimer in the documentation
  24  *    and/or other materials provided with the distribution.
  25  * 3. Neither the name of STMicroelectronics nor the names of other
  26  *    contributors to this software may be used to endorse or promote products
  27  *    derived from this software without specific written permission.
  28  * 4. This software, including modifications and/or derivative works of this
  29  *    software, must execute solely and exclusively on microcontroller or
  30  *    microprocessor devices manufactured by or for STMicroelectronics.
  31  * 5. Redistribution and use of this software other than as permitted under
  32  *    this license is void and will automatically terminate your rights under
  33  *    this license.
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
  36  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
  37  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  38  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
  39  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
  40  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  41  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  42  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  43  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  44  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  45  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  46  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  47  *
  48  ******************************************************************************
  49  */
  50
  51 /* Includes ------------------------------------------------------------------ */
  52 #include "stm32h7xx_hal.h"
  53 #include "usbd_conf.h"
  54 #include "usbd_core.h"
  55 #include "usbd_desc.h"
  56 #include "usbd_cdc.h"
  57 #include "usbd_cdc_interface.h"
  58
  59 #include "platform.h"
  60
  61 #ifdef USE_USB_MSC
  62 #include "drivers/usb_msc.h"
  63 #endif
  64
  65 /* Private typedef ----------------------------------------------------------- */
  66 /* Private define ------------------------------------------------------------ */
  67 /* Private macro ------------------------------------------------------------- */
  68 /* Private variables --------------------------------------------------------- */
  69 PCD_HandleTypeDef hpcd;
  70 /* Private function prototypes ----------------------------------------------- */
  71 /* Private functions --------------------------------------------------------- */
  72
  73 /*******************************************************************************
  74                        PCD BSP Routines
  75  *******************************************************************************/
  76
  77 #ifdef USE_USB_FS
  78 void OTG_FS_IRQHandler(void)
  79 #else
  80 void OTG_HS_IRQHandler(void)
  81 #endif
  82 {
  83     HAL_PCD_IRQHandler(&hpcd);
  84 }
  85
  86 /**
  87  * @brief  Initializes the PCD MSP.
  88  * @param  hpcd: PCD handle
  89  * @retval None
  90  */
  91 void HAL_PCD_MspInit(PCD_HandleTypeDef * hpcd)
  92 {
  93     GPIO_InitTypeDef GPIO_InitStruct;
  94
  95     if (hpcd->Instance == USB_OTG_FS)
  96     {
  97         __HAL_RCC_GPIOA_CLK_ENABLE();
  98
  99         /* Configure DM DP Pins */
 100         GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
 101         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 102         GPIO_InitStruct.Pull = GPIO_NOPULL;
 103         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 104         GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
 105         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 106
 107         if (hpcd->Init.vbus_sensing_enable == 1) {
 108             /* Configure VBUS Pin */
 109             GPIO_InitStruct.Pin = GPIO_PIN_9;
 110             GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 111             GPIO_InitStruct.Pull = GPIO_NOPULL;
 112             HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 113         }
 114 #ifdef USE_USB_ID
 115
 116         /* Configure ID pin */
 117         GPIO_InitStruct.Pin = GPIO_PIN_10;
 118         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
 119         GPIO_InitStruct.Pull = GPIO_PULLUP;
 120         GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
 121         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 122 #endif
 123
 124         /* Enable USB FS Clocks */
 125         __HAL_RCC_USB2_OTG_FS_CLK_ENABLE();
 126
 127         /* XXX Todo: Configure and enable CRS for HSI48 */
 128
 129         /* Set USBFS Interrupt to the lowest priority */
 130         HAL_NVIC_SetPriority(OTG_FS_IRQn, 6, 0);
 131
 132         /* Enable USBFS Interrupt */
 133         HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
 134
 135     }
 136     else if (hpcd->Instance == USB1_OTG_HS)
 137     {
 138         /* Configure USB FS GPIOs */
 139         __GPIOA_CLK_ENABLE();
 140         __GPIOB_CLK_ENABLE();
 141         __GPIOC_CLK_ENABLE();
 142         __GPIOH_CLK_ENABLE();
 143         __GPIOI_CLK_ENABLE();
 144
 145         /* CLK */
 146         GPIO_InitStruct.Pin = GPIO_PIN_5;
 147         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 148         GPIO_InitStruct.Pull = GPIO_NOPULL;
 149         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 150         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 151         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 152
 153         /* D0 */
 154         GPIO_InitStruct.Pin = GPIO_PIN_3;
 155         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 156         GPIO_InitStruct.Pull = GPIO_NOPULL;
 157         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 158         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 159         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 160
 161         /* D1 D2 D3 D4 D5 D6 D7 */
 162         GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_5 |
 163                 GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;
 164         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 165         GPIO_InitStruct.Pull = GPIO_NOPULL;
 166         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 167         HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 168
 169         /* STP */
 170         GPIO_InitStruct.Pin = GPIO_PIN_0;
 171         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 172         GPIO_InitStruct.Pull = GPIO_NOPULL;
 173         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 174         HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 175
 176         /* NXT */
 177         GPIO_InitStruct.Pin = GPIO_PIN_4;
 178         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 179         GPIO_InitStruct.Pull = GPIO_NOPULL;
 180         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 181         HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
 182
 183         /* DIR */
 184         GPIO_InitStruct.Pin = GPIO_PIN_11;
 185         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 186         GPIO_InitStruct.Pull = GPIO_NOPULL;
 187         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 188         HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
 189         __HAL_RCC_USB1_OTG_HS_ULPI_CLK_ENABLE();
 190
 191         /* Enable USB HS Clocks */
 192         __HAL_RCC_USB1_OTG_HS_CLK_ENABLE();
 193
 194         /* Set USBHS Interrupt to the lowest priority */
 195         HAL_NVIC_SetPriority(OTG_HS_IRQn, 1, 0);
 196
 197         /* Enable USBHS Interrupt */
 198         HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
 199     }
 200 }
 201
 202 /**
 203  * @brief  De-Initializes the PCD MSP.
 204  * @param  hpcd: PCD handle
 205  * @retval None
 206  */
 207 void HAL_PCD_MspDeInit(PCD_HandleTypeDef * hpcd)
 208 {
 209     if (hpcd->Instance == USB2_OTG_FS)
 210     {
 211         /* Disable USB FS Clocks */
 212         __HAL_RCC_USB2_OTG_FS_CLK_DISABLE();
 213     }
 214     else if (hpcd->Instance == USB1_OTG_HS)
 215     {
 216         /* Disable USB HS Clocks */
 217         __HAL_RCC_USB1_OTG_HS_CLK_DISABLE();
 218         __HAL_RCC_USB1_OTG_HS_ULPI_CLK_DISABLE();
 219     }
 220 }
 221
 222 /*******************************************************************************
 223                        LL Driver Callbacks (PCD -> USB Device Library)
 224  *******************************************************************************/
 225
 226 /**
 227  * @brief  SetupStage callback.
 228  * @param  hpcd: PCD handle
 229  * @retval None
 230  */
 231 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef * hpcd)
 232 {
 233     USBD_LL_SetupStage(hpcd->pData, (uint8_t *) hpcd->Setup);
 234 }
 235
 236 /**
 237  * @brief  DataOut Stage callback.
 238  * @param  hpcd: PCD handle
 239  * @param  epnum: Endpoint Number
 240  * @retval None
 241  */
 242 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 243 {
 244     USBD_LL_DataOutStage(hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
 245 }
 246
 247 /**
 248  * @brief  DataIn Stage callback.
 249  * @param  hpcd: PCD handle
 250  * @param  epnum: Endpoint Number
 251  * @retval None
 252  */
 253 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 254 {
 255     USBD_LL_DataInStage(hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
 256 }
 257
 258 /**
 259  * @brief  SOF callback.
 260  * @param  hpcd: PCD handle
 261  * @retval None
 262  */
 263 void HAL_PCD_SOFCallback(PCD_HandleTypeDef * hpcd)
 264 {
 265     USBD_LL_SOF(hpcd->pData);
 266 }
 267
 268 /**
 269  * @brief  Reset callback.
 270  * @param  hpcd: PCD handle
 271  * @retval None
 272  */
 273 void HAL_PCD_ResetCallback(PCD_HandleTypeDef * hpcd)
 274 {
 275     USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
 276
 277     /* Set USB Current Speed */
 278     switch (hpcd->Init.speed)
 279     {
 280     case PCD_SPEED_HIGH:
 281         speed = USBD_SPEED_HIGH;
 282         break;
 283
 284     case PCD_SPEED_FULL:
 285         speed = USBD_SPEED_FULL;
 286         break;
 287
 288     default:
 289         speed = USBD_SPEED_FULL;
 290         break;
 291     }
 292
 293     /* Reset Device */
 294     USBD_LL_Reset(hpcd->pData);
 295
 296     USBD_LL_SetSpeed(hpcd->pData, speed);
 297 }
 298
 299 /**
 300  * @brief  Suspend callback.
 301  * @param  hpcd: PCD handle
 302  * @retval None
 303  */
 304 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef * hpcd)
 305 {
 306     USBD_LL_Suspend(hpcd->pData);
 307 }
 308
 309 /**
 310  * @brief  Resume callback.
 311  * @param  hpcd: PCD handle
 312  * @retval None
 313  */
 314 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef * hpcd)
 315 {
 316     USBD_LL_Resume(hpcd->pData);
 317 }
 318
 319 /**
 320  * @brief  ISOOUTIncomplete callback.
 321  * @param  hpcd: PCD handle
 322  * @param  epnum: Endpoint Number
 323  * @retval None
 324  */
 325 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 326 {
 327     USBD_LL_IsoOUTIncomplete(hpcd->pData, epnum);
 328 }
 329
 330 /**
 331  * @brief  ISOINIncomplete callback.
 332  * @param  hpcd: PCD handle
 333  * @param  epnum: Endpoint Number
 334  * @retval None
 335  */
 336 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 337 {
 338     USBD_LL_IsoINIncomplete(hpcd->pData, epnum);
 339 }
 340
 341 /**
 342  * @brief  ConnectCallback callback.
 343  * @param  hpcd: PCD handle
 344  * @retval None
 345  */
 346 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef * hpcd)
 347 {
 348     USBD_LL_DevConnected(hpcd->pData);
 349 }
 350
 351 /**
 352  * @brief  Disconnect callback.
 353  * @param  hpcd: PCD handle
 354  * @retval None
 355  */
 356 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef * hpcd)
 357 {
 358     USBD_LL_DevDisconnected(hpcd->pData);
 359 }
 360
 361
 362 /*******************************************************************************
 363                        LL Driver Interface (USB Device Library --> PCD)
 364  *******************************************************************************/
 365
 366 /**
 367  * @brief  Initializes the Low Level portion of the Device driver.
 368  * @param  pdev: Device handle
 369  * @retval USBD Status
 370  */
 371 USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef * pdev)
 372 {
 373 #ifdef USE_USB_FS
 374     /* Set LL Driver parameters */
 375     hpcd.Instance = USB2_OTG_FS;
 376     hpcd.Init.dev_endpoints = 9;
 377     hpcd.Init.use_dedicated_ep1 = DISABLE;
 378     hpcd.Init.ep0_mps = DEP0CTL_MPS_64;
 379     hpcd.Init.low_power_enable = DISABLE;
 380     hpcd.Init.phy_itface = PCD_PHY_EMBEDDED;
 381     hpcd.Init.Sof_enable = DISABLE;
 382     hpcd.Init.battery_charging_enable = DISABLE;
 383     hpcd.Init.speed = PCD_SPEED_FULL;
 384     hpcd.Init.vbus_sensing_enable = DISABLE;
 385     hpcd.Init.dma_enable = DISABLE;
 386     hpcd.Init.lpm_enable = DISABLE;
 387
 388     /* Link The driver to the stack */
 389     hpcd.pData = pdev;
 390     pdev->pData = &hpcd;
 391
 392     hpcd.Init.vbus_sensing_enable = 0;
 393
 394     /* Initialize LL Driver */
 395     HAL_PCD_Init(&hpcd);
 396
 397 #ifdef USE_USB_CDC_HID
 398 #ifdef USE_USB_MSC
 399   if (usbDevConfig()->type == COMPOSITE && !mscCheckBoot()) {
 400 #else
 401   if (usbDevConfig()->type == COMPOSITE) {
 402 #endif
 403     HAL_PCDEx_SetRxFiFo(&hpcd, 0x80);
 404     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x20);
 405     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x40);
 406     HAL_PCDEx_SetTxFiFo(&hpcd, 2, 0x20);
 407     HAL_PCDEx_SetTxFiFo(&hpcd, 3, 0x40);
 408   } else {
 409 #endif /* CDC_HID */
 410     HAL_PCDEx_SetRxFiFo(&hpcd, 0x80);
 411     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x40);
 412     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x80);
 413 #ifdef USE_USB_CDC_HID
 414   }
 415 #endif /* CDC_HID */
 416
 417 #endif
 418
 419 #ifdef USE_USB_HS
 420     /* Set LL Driver parameters */
 421     hpcd.Instance = USB1_OTG_HS;
 422     hpcd.Init.dev_endpoints = 8;
 423     hpcd.Init.use_dedicated_ep1 = 0;
 424     hpcd.Init.ep0_mps = 0x40;
 425
 426     /* Be aware that enabling DMA mode will result in data being sent only by
 427      * multiple of 4 packet sizes. This is due to the fact that USB DMA does not
 428      * allow sending data from non word-aligned addresses. For this specific
 429      * application, it is advised to not enable this option unless required. */
 430     hpcd.Init.dma_enable = 0;
 431     hpcd.Init.low_power_enable = 0;
 432     hpcd.Init.lpm_enable = 0;
 433     hpcd.Init.phy_itface = PCD_PHY_ULPI;
 434     hpcd.Init.Sof_enable = 0;
 435     hpcd.Init.speed = PCD_SPEED_HIGH;
 436     hpcd.Init.vbus_sensing_enable = 0;
 437
 438     /* Link The driver to the stack */
 439     hpcd.pData = pdev;
 440     pdev->pData = &hpcd;
 441
 442     /* Initialize LL Driver */
 443     HAL_PCD_Init(&hpcd);
 444
 445     HAL_PCDEx_SetRxFiFo(&hpcd, 0x200);
 446     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x80);
 447     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x174);
 448 #endif
 449
 450     return USBD_OK;
 451 }
 452
 453 /**
 454  * @brief  De-Initializes the Low Level portion of the Device driver.
 455  * @param  pdev: Device handle
 456  * @retval USBD Status
 457  */
 458 USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef * pdev)
 459 {
 460     HAL_PCD_DeInit(pdev->pData);
 461     return USBD_OK;
 462 }
 463
 464 /**
 465  * @brief  Starts the Low Level portion of the Device driver.
 466  * @param  pdev: Device handle
 467  * @retval USBD Status
 468  */
 469 USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef * pdev)
 470 {
 471     HAL_PCD_Start(pdev->pData);
 472     return USBD_OK;
 473 }
 474
 475 /**
 476  * @brief  Stops the Low Level portion of the Device driver.
 477  * @param  pdev: Device handle
 478  * @retval USBD Status
 479  */
 480 USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef * pdev)
 481 {
 482     HAL_PCD_Stop(pdev->pData);
 483     return USBD_OK;
 484 }
 485
 486 /**
 487  * @brief  Opens an endpoint of the Low Level Driver.
 488  * @param  pdev: Device handle
 489  * @param  ep_addr: Endpoint Number
 490  * @param  ep_type: Endpoint Type
 491  * @param  ep_mps: Endpoint Max Packet Size
 492  * @retval USBD Status
 493  */
 494 USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef * pdev,
 495         uint8_t ep_addr,
 496         uint8_t ep_type, uint16_t ep_mps)
 497 {
 498     HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
 499
 500     return USBD_OK;
 501 }
 502
 503 /**
 504  * @brief  Closes an endpoint of the Low Level Driver.
 505  * @param  pdev: Device handle
 506  * @param  ep_addr: Endpoint Number
 507  * @retval USBD Status
 508  */
 509 USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 510 {
 511     HAL_PCD_EP_Close(pdev->pData, ep_addr);
 512     return USBD_OK;
 513 }
 514
 515 /**
 516  * @brief  Flushes an endpoint of the Low Level Driver.
 517  * @param  pdev: Device handle
 518  * @param  ep_addr: Endpoint Number
 519  * @retval USBD Status
 520  */
 521 USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 522 {
 523     HAL_PCD_EP_Flush(pdev->pData, ep_addr);
 524     return USBD_OK;
 525 }
 526
 527 /**
 528  * @brief  Sets a Stall condition on an endpoint of the Low Level Driver.
 529  * @param  pdev: Device handle
 530  * @param  ep_addr: Endpoint Number
 531  * @retval USBD Status
 532  */
 533 USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 534 {
 535     HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
 536     return USBD_OK;
 537 }
 538
 539 /**
 540  * @brief  Clears a Stall condition on an endpoint of the Low Level Driver.
 541  * @param  pdev: Device handle
 542  * @param  ep_addr: Endpoint Number
 543  * @retval USBD Status
 544  */
 545 USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef * pdev,
 546         uint8_t ep_addr)
 547 {
 548     HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);
 549     return USBD_OK;
 550 }
 551
 552 /**
 553  * @brief  Returns Stall condition.
 554  * @param  pdev: Device handle
 555  * @param  ep_addr: Endpoint Number
 556  * @retval Stall (1: Yes, 0: No)
 557  */
 558 uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 559 {
 560     PCD_HandleTypeDef *hpcd = pdev->pData;
 561
 562     if ((ep_addr & 0x80) == 0x80)
 563     {
 564         return hpcd->IN_ep[ep_addr & 0x7F].is_stall;
 565     }
 566     else
 567     {
 568         return hpcd->OUT_ep[ep_addr & 0x7F].is_stall;
 569     }
 570 }
 571
 572 /**
 573  * @brief  Assigns a USB address to the device.
 574  * @param  pdev: Device handle
 575  * @param  ep_addr: Endpoint Number
 576  * @retval USBD Status
 577  */
 578 USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef * pdev,
 579         uint8_t dev_addr)
 580 {
 581     HAL_PCD_SetAddress(pdev->pData, dev_addr);
 582     return USBD_OK;
 583 }
 584
 585 /**
 586  * @brief  Transmits data over an endpoint.
 587  * @param  pdev: Device handle
 588  * @param  ep_addr: Endpoint Number
 589  * @param  pbuf: Pointer to data to be sent
 590  * @param  size: Data size
 591  * @retval USBD Status
 592  */
 593 USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef * pdev,
 594         uint8_t ep_addr,
 595         uint8_t * pbuf, uint16_t size)
 596 {
 597     /* Get the packet total length */
 598     pdev->ep_in[ep_addr & 0x7F].total_length = size;
 599
 600     HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
 601     return USBD_OK;
 602 }
 603
 604 /**
 605  * @brief  Prepares an endpoint for reception.
 606  * @param  pdev: Device handle
 607  * @param  ep_addr: Endpoint Number
 608  * @param  pbuf: Pointer to data to be received
 609  * @param  size: Data size
 610  * @retval USBD Status
 611  */
 612 USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef * pdev,
 613         uint8_t ep_addr,
 614         uint8_t * pbuf, uint16_t size)
 615 {
 616     HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
 617     return USBD_OK;
 618 }
 619
 620 /**
 621  * @brief  Returns the last transferred packet size.
 622  * @param  pdev: Device handle
 623  * @param  ep_addr: Endpoint Number
 624  * @retval Received Data Size
 625  */
 626 uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 627 {
 628     return HAL_PCD_EP_GetRxCount(pdev->pData, ep_addr);
 629 }
 630
 631 /**
 632  * @brief  Delays routine for the USB Device Library.
 633  * @param  Delay: Delay in ms
 634  * @retval None
 635  */
 636 void USBD_LL_Delay(uint32_t Delay)
 637 {
 638     HAL_Delay(Delay);
 639 }
 640
 641 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/