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 #include "pg/pg.h"
  61 #include "pg/usb.h"
  62
  63 #ifdef USE_USB_MSC
  64 #include "drivers/usb_msc.h"
  65 #endif
  66
  67 /* Private typedef ----------------------------------------------------------- */
  68 /* Private define ------------------------------------------------------------ */
  69 /* Private macro ------------------------------------------------------------- */
  70 /* Private variables --------------------------------------------------------- */
  71 PCD_HandleTypeDef hpcd;
  72 /* Private function prototypes ----------------------------------------------- */
  73 /* Private functions --------------------------------------------------------- */
  74
  75 /*******************************************************************************
  76                        PCD BSP Routines
  77  *******************************************************************************/
  78
  79 #if defined(USE_USB_FS) && !(defined(STM32H7A3xx) || defined(STM32H7A3xxQ) || defined(STM32H723xx) || defined(STM32H725xx) || defined(STM32H730xx))
  80 void OTG_FS_IRQHandler(void)
  81 #else
  82 void OTG_HS_IRQHandler(void)
  83 #endif
  84 {
  85     HAL_PCD_IRQHandler(&hpcd);
  86 }
  87
  88 /**
  89  * @brief  Initializes the PCD MSP.
  90  * @param  hpcd: PCD handle
  91  * @retval None
  92  */
  93 void HAL_PCD_MspInit(PCD_HandleTypeDef * hpcd)
  94 {
  95     GPIO_InitTypeDef GPIO_InitStruct = {0};
  96
  97 #if defined(STM32H7A3xx) || defined(STM32H7A3xxQ)
  98
  99     // H7A3 uses USB1_OTG_HS in FS mode
 100
 101     UNUSED(hpcd);
 102
 103     __HAL_RCC_GPIOA_CLK_ENABLE();
 104
 105     /**USB GPIO Configuration
 106     PA11     ------> USB_DM
 107     PA12     ------> USB_DP
 108     */
 109     GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
 110     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 111     GPIO_InitStruct.Pull = GPIO_NOPULL;
 112     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 113     GPIO_InitStruct.Alternate  = GPIO_AF10_OTG1_HS;
 114     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 115
 116     /* Peripheral clock enable */
 117     __HAL_RCC_USB1_OTG_HS_CLK_ENABLE();
 118
 119     /* Set USB HS Interrupt priority */
 120     HAL_NVIC_SetPriority(OTG_HS_IRQn, 6, 0);
 121
 122     /* Enable USB HS Interrupt */
 123     HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
 124
 125 #elif defined(STM32H743xx) || defined(STM32H750xx)
 126
 127     if (hpcd->Instance == USB_OTG_FS)
 128     {
 129         __HAL_RCC_GPIOA_CLK_ENABLE();
 130
 131         /* Configure DM DP Pins */
 132         GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
 133         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 134         GPIO_InitStruct.Pull = GPIO_NOPULL;
 135         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 136         GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
 137         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 138
 139         if (hpcd->Init.vbus_sensing_enable == 1) {
 140             /* Configure VBUS Pin */
 141             GPIO_InitStruct.Pin = GPIO_PIN_9;
 142             GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 143             GPIO_InitStruct.Pull = GPIO_NOPULL;
 144             HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 145         }
 146 #ifdef USE_USB_ID
 147
 148         /* Configure ID pin */
 149         GPIO_InitStruct.Pin = GPIO_PIN_10;
 150         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
 151         GPIO_InitStruct.Pull = GPIO_PULLUP;
 152         GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
 153         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 154 #endif
 155
 156         /* Enable USB FS Clocks */
 157         __HAL_RCC_USB2_OTG_FS_CLK_ENABLE();
 158
 159         /* XXX Todo: Configure and enable CRS for HSI48 */
 160
 161         /* Set USBFS Interrupt to the lowest priority */
 162         HAL_NVIC_SetPriority(OTG_FS_IRQn, 6, 0);
 163
 164         /* Enable USBFS Interrupt */
 165         HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
 166
 167     }
 168     else if (hpcd->Instance == USB1_OTG_HS)
 169     {
 170         /* Configure USB FS GPIOs */
 171         __GPIOA_CLK_ENABLE();
 172         __GPIOB_CLK_ENABLE();
 173         __GPIOC_CLK_ENABLE();
 174         __GPIOH_CLK_ENABLE();
 175         __GPIOI_CLK_ENABLE();
 176
 177         /* CLK */
 178         GPIO_InitStruct.Pin = GPIO_PIN_5;
 179         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 180         GPIO_InitStruct.Pull = GPIO_NOPULL;
 181         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 182         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 183         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 184
 185         /* D0 */
 186         GPIO_InitStruct.Pin = GPIO_PIN_3;
 187         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 188         GPIO_InitStruct.Pull = GPIO_NOPULL;
 189         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 190         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 191         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 192
 193         /* D1 D2 D3 D4 D5 D6 D7 */
 194         GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_5 |
 195                 GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;
 196         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 197         GPIO_InitStruct.Pull = GPIO_NOPULL;
 198         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 199         HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 200
 201         /* STP */
 202         GPIO_InitStruct.Pin = GPIO_PIN_0;
 203         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 204         GPIO_InitStruct.Pull = GPIO_NOPULL;
 205         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 206         HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 207
 208         /* NXT */
 209         GPIO_InitStruct.Pin = GPIO_PIN_4;
 210         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 211         GPIO_InitStruct.Pull = GPIO_NOPULL;
 212         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 213         HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
 214
 215         /* DIR */
 216         GPIO_InitStruct.Pin = GPIO_PIN_11;
 217         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 218         GPIO_InitStruct.Pull = GPIO_NOPULL;
 219         GPIO_InitStruct.Alternate = GPIO_AF10_OTG2_HS;
 220         HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
 221         __HAL_RCC_USB1_OTG_HS_ULPI_CLK_ENABLE();
 222
 223         /* Enable USB HS Clocks */
 224         __HAL_RCC_USB1_OTG_HS_CLK_ENABLE();
 225
 226         /* Set USBHS Interrupt to the lowest priority */
 227         HAL_NVIC_SetPriority(OTG_HS_IRQn, 1, 0);
 228
 229         /* Enable USBHS Interrupt */
 230         HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
 231     }
 232
 233 #elif defined(STM32H723xx) || defined(STM32H725xx)
 234     UNUSED(hpcd);
 235
 236     __HAL_RCC_GPIOA_CLK_ENABLE();
 237
 238     /**USB GPIO Configuration
 239     PA11     ------> USB_DM
 240     PA12     ------> USB_DP
 241     */
 242     GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
 243     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 244     GPIO_InitStruct.Pull = GPIO_NOPULL;
 245     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 246     GPIO_InitStruct.Alternate  = GPIO_AF10_OTG1_FS;
 247     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 248
 249     /* Peripheral clock enable */
 250     __HAL_RCC_USB1_OTG_HS_CLK_ENABLE();
 251
 252     /* Set USB FS Interrupt priority */
 253     HAL_NVIC_SetPriority(OTG_HS_IRQn, 6, 0);
 254
 255     /* Enable USB FS Interrupt */
 256     HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
 257 #elif defined(STM32H730xx)
 258     UNUSED(hpcd);
 259
 260     __HAL_RCC_GPIOA_CLK_ENABLE();
 261
 262     /**USB GPIO Configuration
 263     PA11     ------> USB_DM
 264     PA12     ------> USB_DP
 265     */
 266     GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
 267     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 268     GPIO_InitStruct.Pull = GPIO_NOPULL;
 269     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 270     GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_HS;
 271     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 272
 273     /* Enable USB HS Clocks */
 274     __HAL_RCC_USB1_OTG_HS_CLK_ENABLE();
 275
 276     HAL_NVIC_SetPriority(OTG_HS_EP1_OUT_IRQn, 6, 0);
 277     HAL_NVIC_EnableIRQ(OTG_HS_EP1_OUT_IRQn);
 278
 279     HAL_NVIC_SetPriority(OTG_HS_EP1_IN_IRQn, 6, 0);
 280     HAL_NVIC_EnableIRQ(OTG_HS_EP1_IN_IRQn);
 281
 282     HAL_NVIC_SetPriority(OTG_HS_IRQn, 7, 0);
 283     HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
 284
 285 #else
 286 #error Unknown MCU type
 287 #endif
 288 }
 289
 290 /**
 291  * @brief  De-Initializes the PCD MSP.
 292  * @param  hpcd: PCD handle
 293  * @retval None
 294  */
 295 void HAL_PCD_MspDeInit(PCD_HandleTypeDef * hpcd)
 296 {
 297 #if defined(STM32H7A3xx) || defined(STM32H7A3xxQ)
 298     if(hpcd->Instance==USB1_OTG_HS) {
 299
 300         __HAL_RCC_USB1_OTG_HS_CLK_DISABLE();
 301
 302         HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12);
 303
 304         HAL_NVIC_DisableIRQ(OTG_HS_IRQn);
 305
 306         __HAL_RCC_GPIOA_CLK_DISABLE();
 307     }
 308 #elif defined(STM32H743xx) || defined(STM32H750xx)
 309     if (hpcd->Instance == USB2_OTG_FS)
 310     {
 311         /* Disable USB FS Clocks */
 312         __HAL_RCC_USB2_OTG_FS_CLK_DISABLE();
 313     }
 314     else if (hpcd->Instance == USB1_OTG_HS)
 315     {
 316         /* Disable USB HS Clocks */
 317         __HAL_RCC_USB1_OTG_HS_CLK_DISABLE();
 318         __HAL_RCC_USB1_OTG_HS_ULPI_CLK_DISABLE();
 319     }
 320 #elif defined(STM32H723xx) || defined(STM32H725xx) || defined(STM32H730xx)
 321     if(hpcd->Instance==USB1_OTG_HS)
 322     {
 323         /* Peripheral clock disable */
 324         __HAL_RCC_USB1_OTG_HS_CLK_DISABLE();
 325
 326         /**USB GPIO Configuration
 327          PA11     ------> USB_DM
 328          PA12     ------> USB_DP
 329         */
 330         HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12);
 331
 332         /* Peripheral interrupt Deinit*/
 333         HAL_NVIC_DisableIRQ(OTG_HS_IRQn);
 334     }
 335 #else
 336 #error Unknown MCU
 337 #endif
 338 }
 339
 340 /*******************************************************************************
 341                        LL Driver Callbacks (PCD -> USB Device Library)
 342  *******************************************************************************/
 343
 344 /**
 345  * @brief  SetupStage callback.
 346  * @param  hpcd: PCD handle
 347  * @retval None
 348  */
 349 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef * hpcd)
 350 {
 351     USBD_LL_SetupStage(hpcd->pData, (uint8_t *) hpcd->Setup);
 352 }
 353
 354 /**
 355  * @brief  DataOut Stage callback.
 356  * @param  hpcd: PCD handle
 357  * @param  epnum: Endpoint Number
 358  * @retval None
 359  */
 360 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 361 {
 362     USBD_LL_DataOutStage(hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
 363 }
 364
 365 /**
 366  * @brief  DataIn Stage callback.
 367  * @param  hpcd: PCD handle
 368  * @param  epnum: Endpoint Number
 369  * @retval None
 370  */
 371 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 372 {
 373     USBD_LL_DataInStage(hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
 374 }
 375
 376 /**
 377  * @brief  SOF callback.
 378  * @param  hpcd: PCD handle
 379  * @retval None
 380  */
 381 void HAL_PCD_SOFCallback(PCD_HandleTypeDef * hpcd)
 382 {
 383     USBD_LL_SOF(hpcd->pData);
 384 }
 385
 386 /**
 387  * @brief  Reset callback.
 388  * @param  hpcd: PCD handle
 389  * @retval None
 390  */
 391 void HAL_PCD_ResetCallback(PCD_HandleTypeDef * hpcd)
 392 {
 393     USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
 394
 395     /* Set USB Current Speed */
 396     switch (hpcd->Init.speed)
 397     {
 398     case PCD_SPEED_HIGH:
 399         speed = USBD_SPEED_HIGH;
 400         break;
 401
 402     case PCD_SPEED_FULL:
 403         speed = USBD_SPEED_FULL;
 404         break;
 405
 406     default:
 407         speed = USBD_SPEED_FULL;
 408         break;
 409     }
 410
 411     /* Reset Device */
 412     USBD_LL_Reset(hpcd->pData);
 413
 414     USBD_LL_SetSpeed(hpcd->pData, speed);
 415 }
 416
 417 /**
 418  * @brief  Suspend callback.
 419  * @param  hpcd: PCD handle
 420  * @retval None
 421  */
 422 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef * hpcd)
 423 {
 424     USBD_LL_Suspend(hpcd->pData);
 425 }
 426
 427 /**
 428  * @brief  Resume callback.
 429  * @param  hpcd: PCD handle
 430  * @retval None
 431  */
 432 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef * hpcd)
 433 {
 434     USBD_LL_Resume(hpcd->pData);
 435 }
 436
 437 /**
 438  * @brief  ISOOUTIncomplete callback.
 439  * @param  hpcd: PCD handle
 440  * @param  epnum: Endpoint Number
 441  * @retval None
 442  */
 443 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 444 {
 445     USBD_LL_IsoOUTIncomplete(hpcd->pData, epnum);
 446 }
 447
 448 /**
 449  * @brief  ISOINIncomplete callback.
 450  * @param  hpcd: PCD handle
 451  * @param  epnum: Endpoint Number
 452  * @retval None
 453  */
 454 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef * hpcd, uint8_t epnum)
 455 {
 456     USBD_LL_IsoINIncomplete(hpcd->pData, epnum);
 457 }
 458
 459 /**
 460  * @brief  ConnectCallback callback.
 461  * @param  hpcd: PCD handle
 462  * @retval None
 463  */
 464 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef * hpcd)
 465 {
 466     USBD_LL_DevConnected(hpcd->pData);
 467 }
 468
 469 /**
 470  * @brief  Disconnect callback.
 471  * @param  hpcd: PCD handle
 472  * @retval None
 473  */
 474 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef * hpcd)
 475 {
 476     USBD_LL_DevDisconnected(hpcd->pData);
 477 }
 478
 479
 480 /*******************************************************************************
 481                        LL Driver Interface (USB Device Library --> PCD)
 482  *******************************************************************************/
 483
 484 /**
 485  * @brief  Initializes the Low Level portion of the Device driver.
 486  * @param  pdev: Device handle
 487  * @retval USBD Status
 488  */
 489 USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef * pdev)
 490 {
 491 #ifdef USE_USB_FS
 492     /* Set LL Driver parameters */
 493 #if defined(STM32H7A3xx) || defined(STM32H7A3xxQ) || defined(STM32H723xx) || defined(STM32H725xx) || defined(STM32H730xx)
 494     hpcd.Instance = USB1_OTG_HS;
 495 #elif defined(STM32H743xx) || defined(STM32H750xx)
 496     hpcd.Instance = USB2_OTG_FS;
 497 #else
 498 #error Unknown MCU type
 499 #endif
 500     hpcd.Init.dev_endpoints = 9;
 501     hpcd.Init.use_dedicated_ep1 = DISABLE;
 502     hpcd.Init.ep0_mps = DEP0CTL_MPS_64;
 503     hpcd.Init.low_power_enable = DISABLE;
 504     hpcd.Init.phy_itface = PCD_PHY_EMBEDDED;
 505     hpcd.Init.Sof_enable = DISABLE;
 506     hpcd.Init.battery_charging_enable = DISABLE;
 507     hpcd.Init.speed = PCD_SPEED_FULL;
 508     hpcd.Init.vbus_sensing_enable = DISABLE;
 509     hpcd.Init.dma_enable = DISABLE;
 510     hpcd.Init.lpm_enable = DISABLE;
 511
 512     /* Link The driver to the stack */
 513     hpcd.pData = pdev;
 514     pdev->pData = &hpcd;
 515
 516     hpcd.Init.vbus_sensing_enable = 0;
 517
 518     /* Initialize LL Driver */
 519     HAL_PCD_Init(&hpcd);
 520
 521 #ifdef USE_USB_CDC_HID
 522 #ifdef USE_USB_MSC
 523   if (usbDevConfig()->type == COMPOSITE && !mscCheckBootAndReset()) {
 524 #else
 525   if (usbDevConfig()->type == COMPOSITE) {
 526 #endif
 527     HAL_PCDEx_SetRxFiFo(&hpcd, 0x80);
 528     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x20);
 529     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x40);
 530     HAL_PCDEx_SetTxFiFo(&hpcd, 2, 0x20);
 531     HAL_PCDEx_SetTxFiFo(&hpcd, 3, 0x40);
 532   } else {
 533 #endif /* CDC_HID */
 534     HAL_PCDEx_SetRxFiFo(&hpcd, 0x80);
 535     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x40);
 536     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x80);
 537 #ifdef USE_USB_CDC_HID
 538   }
 539 #endif /* CDC_HID */
 540
 541 #endif
 542
 543 #ifdef USE_USB_HS
 544     /* Set LL Driver parameters */
 545     hpcd.Instance = USB1_OTG_HS;
 546     hpcd.Init.dev_endpoints = 8;
 547     hpcd.Init.use_dedicated_ep1 = 0;
 548     hpcd.Init.ep0_mps = 0x40;
 549
 550     /* Be aware that enabling DMA mode will result in data being sent only by
 551      * multiple of 4 packet sizes. This is due to the fact that USB DMA does not
 552      * allow sending data from non word-aligned addresses. For this specific
 553      * application, it is advised to not enable this option unless required. */
 554     hpcd.Init.dma_enable = 0;
 555     hpcd.Init.low_power_enable = 0;
 556     hpcd.Init.lpm_enable = 0;
 557     hpcd.Init.phy_itface = PCD_PHY_ULPI;
 558     hpcd.Init.Sof_enable = 0;
 559     hpcd.Init.speed = PCD_SPEED_HIGH;
 560     hpcd.Init.vbus_sensing_enable = 0;
 561
 562     /* Link The driver to the stack */
 563     hpcd.pData = pdev;
 564     pdev->pData = &hpcd;
 565
 566     /* Initialize LL Driver */
 567     HAL_PCD_Init(&hpcd);
 568
 569     HAL_PCDEx_SetRxFiFo(&hpcd, 0x200);
 570     HAL_PCDEx_SetTxFiFo(&hpcd, 0, 0x80);
 571     HAL_PCDEx_SetTxFiFo(&hpcd, 1, 0x174);
 572 #endif
 573
 574     return USBD_OK;
 575 }
 576
 577 /**
 578  * @brief  De-Initializes the Low Level portion of the Device driver.
 579  * @param  pdev: Device handle
 580  * @retval USBD Status
 581  */
 582 USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef * pdev)
 583 {
 584     HAL_PCD_DeInit(pdev->pData);
 585     return USBD_OK;
 586 }
 587
 588 /**
 589  * @brief  Starts the Low Level portion of the Device driver.
 590  * @param  pdev: Device handle
 591  * @retval USBD Status
 592  */
 593 USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef * pdev)
 594 {
 595     HAL_PCD_Start(pdev->pData);
 596     return USBD_OK;
 597 }
 598
 599 /**
 600  * @brief  Stops the Low Level portion of the Device driver.
 601  * @param  pdev: Device handle
 602  * @retval USBD Status
 603  */
 604 USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef * pdev)
 605 {
 606     HAL_PCD_Stop(pdev->pData);
 607     return USBD_OK;
 608 }
 609
 610 /**
 611  * @brief  Opens an endpoint of the Low Level Driver.
 612  * @param  pdev: Device handle
 613  * @param  ep_addr: Endpoint Number
 614  * @param  ep_type: Endpoint Type
 615  * @param  ep_mps: Endpoint Max Packet Size
 616  * @retval USBD Status
 617  */
 618 USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef * pdev,
 619         uint8_t ep_addr,
 620         uint8_t ep_type, uint16_t ep_mps)
 621 {
 622     HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
 623
 624     return USBD_OK;
 625 }
 626
 627 /**
 628  * @brief  Closes an endpoint of the Low Level Driver.
 629  * @param  pdev: Device handle
 630  * @param  ep_addr: Endpoint Number
 631  * @retval USBD Status
 632  */
 633 USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 634 {
 635     HAL_PCD_EP_Close(pdev->pData, ep_addr);
 636     return USBD_OK;
 637 }
 638
 639 /**
 640  * @brief  Flushes an endpoint of the Low Level Driver.
 641  * @param  pdev: Device handle
 642  * @param  ep_addr: Endpoint Number
 643  * @retval USBD Status
 644  */
 645 USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 646 {
 647     HAL_PCD_EP_Flush(pdev->pData, ep_addr);
 648     return USBD_OK;
 649 }
 650
 651 /**
 652  * @brief  Sets a Stall condition on an endpoint of the Low Level Driver.
 653  * @param  pdev: Device handle
 654  * @param  ep_addr: Endpoint Number
 655  * @retval USBD Status
 656  */
 657 USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 658 {
 659     HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
 660     return USBD_OK;
 661 }
 662
 663 /**
 664  * @brief  Clears a Stall condition on an endpoint of the Low Level Driver.
 665  * @param  pdev: Device handle
 666  * @param  ep_addr: Endpoint Number
 667  * @retval USBD Status
 668  */
 669 USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef * pdev,
 670         uint8_t ep_addr)
 671 {
 672     HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);
 673     return USBD_OK;
 674 }
 675
 676 /**
 677  * @brief  Returns Stall condition.
 678  * @param  pdev: Device handle
 679  * @param  ep_addr: Endpoint Number
 680  * @retval Stall (1: Yes, 0: No)
 681  */
 682 uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 683 {
 684     PCD_HandleTypeDef *hpcd = pdev->pData;
 685
 686     if ((ep_addr & 0x80) == 0x80)
 687     {
 688         return hpcd->IN_ep[ep_addr & 0x7F].is_stall;
 689     }
 690     else
 691     {
 692         return hpcd->OUT_ep[ep_addr & 0x7F].is_stall;
 693     }
 694 }
 695
 696 /**
 697  * @brief  Assigns a USB address to the device.
 698  * @param  pdev: Device handle
 699  * @param  ep_addr: Endpoint Number
 700  * @retval USBD Status
 701  */
 702 USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef * pdev,
 703         uint8_t dev_addr)
 704 {
 705     HAL_PCD_SetAddress(pdev->pData, dev_addr);
 706     return USBD_OK;
 707 }
 708
 709 /**
 710  * @brief  Transmits data over an endpoint.
 711  * @param  pdev: Device handle
 712  * @param  ep_addr: Endpoint Number
 713  * @param  pbuf: Pointer to data to be sent
 714  * @param  size: Data size
 715  * @retval USBD Status
 716  */
 717 USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef * pdev,
 718         uint8_t ep_addr,
 719         uint8_t * pbuf, uint32_t size)
 720 {
 721     /* Get the packet total length */
 722     pdev->ep_in[ep_addr & 0x7F].total_length = size;
 723
 724     HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
 725     return USBD_OK;
 726 }
 727
 728 /**
 729  * @brief  Prepares an endpoint for reception.
 730  * @param  pdev: Device handle
 731  * @param  ep_addr: Endpoint Number
 732  * @param  pbuf: Pointer to data to be received
 733  * @param  size: Data size
 734  * @retval USBD Status
 735  */
 736 USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef * pdev,
 737         uint8_t ep_addr,
 738         uint8_t * pbuf, uint32_t size)
 739 {
 740     HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
 741     return USBD_OK;
 742 }
 743
 744 /**
 745  * @brief  Returns the last transferred packet size.
 746  * @param  pdev: Device handle
 747  * @param  ep_addr: Endpoint Number
 748  * @retval Received Data Size
 749  */
 750 uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef * pdev, uint8_t ep_addr)
 751 {
 752     return HAL_PCD_EP_GetRxCount(pdev->pData, ep_addr);
 753 }
 754
 755 /**
 756  * @brief  Delays routine for the USB Device Library.
 757  * @param  Delay: Delay in ms
 758  * @retval None
 759  */
 760 void USBD_LL_Delay(uint32_t Delay)
 761 {
 762     HAL_Delay(Delay);
 763 }
 764
 765 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/