Subversion Repositories dashGPS

Rev

Rev 16 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : Target/usbd_conf.c
  5.   * @version        : v2.0_Cube
  6.   * @brief          : This file implements the board support package for the USB device library
  7.   ******************************************************************************
  8.   * @attention
  9.   *
  10.   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  11.   * All rights reserved.</center></h2>
  12.   *
  13.   * This software component is licensed by ST under Ultimate Liberty license
  14.   * SLA0044, the "License"; You may not use this file except in compliance with
  15.   * the License. You may obtain a copy of the License at:
  16.   *                             www.st.com/SLA0044
  17.   *
  18.   ******************************************************************************
  19.   */
  20. /* USER CODE END Header */
  21.  
  22. /* Includes ------------------------------------------------------------------*/
  23. #include "stm32f1xx.h"
  24. #include "stm32f1xx_hal.h"
  25. #include "usbd_def.h"
  26. #include "usbd_core.h"
  27. #include "usbd_cdc.h"
  28.  
  29. /* USER CODE BEGIN Includes */
  30.  
  31. /* USER CODE END Includes */
  32.  
  33. /* Private typedef -----------------------------------------------------------*/
  34. /* Private define ------------------------------------------------------------*/
  35. /* Private macro -------------------------------------------------------------*/
  36.  
  37. /* USER CODE BEGIN PV */
  38. /* Private variables ---------------------------------------------------------*/
  39.  
  40. /* USER CODE END PV */
  41.  
  42. PCD_HandleTypeDef hpcd_USB_FS;
  43. void Error_Handler(void);
  44.  
  45. /* USER CODE BEGIN 0 */
  46.  
  47. /* USER CODE END 0 */
  48.  
  49. /* USER CODE BEGIN PFP */
  50. /* Private function prototypes -----------------------------------------------*/
  51.  
  52. /* USER CODE END PFP */
  53.  
  54. /* Private functions ---------------------------------------------------------*/
  55. static USBD_StatusTypeDef USBD_Get_USB_Status(HAL_StatusTypeDef hal_status);
  56. /* USER CODE BEGIN 1 */
  57.  
  58. /* USER CODE END 1 */
  59. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  60. static void PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state);
  61. #else
  62. void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state);
  63. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  64.  
  65. /*******************************************************************************
  66.                        LL Driver Callbacks (PCD -> USB Device Library)
  67. *******************************************************************************/
  68. /* MSP Init */
  69.  
  70. void HAL_PCD_MspInit(PCD_HandleTypeDef* pcdHandle)
  71. {
  72.   if(pcdHandle->Instance==USB)
  73.   {
  74.   /* USER CODE BEGIN USB_MspInit 0 */
  75.  
  76.   /* USER CODE END USB_MspInit 0 */
  77.     /* Peripheral clock enable */
  78.     __HAL_RCC_USB_CLK_ENABLE();
  79.  
  80.     /* Peripheral interrupt init */
  81.     HAL_NVIC_SetPriority(USB_HP_CAN1_TX_IRQn, 0, 0);
  82.     HAL_NVIC_EnableIRQ(USB_HP_CAN1_TX_IRQn);
  83.     HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 0, 0);
  84.     HAL_NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
  85.   /* USER CODE BEGIN USB_MspInit 1 */
  86.  
  87.   /* USER CODE END USB_MspInit 1 */
  88.   }
  89. }
  90.  
  91. void HAL_PCD_MspDeInit(PCD_HandleTypeDef* pcdHandle)
  92. {
  93.   if(pcdHandle->Instance==USB)
  94.   {
  95.   /* USER CODE BEGIN USB_MspDeInit 0 */
  96.  
  97.   /* USER CODE END USB_MspDeInit 0 */
  98.     /* Peripheral clock disable */
  99.     __HAL_RCC_USB_CLK_DISABLE();
  100.  
  101.     /* Peripheral interrupt Deinit*/
  102.     HAL_NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);
  103.  
  104.     HAL_NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
  105.  
  106.   /* USER CODE BEGIN USB_MspDeInit 1 */
  107.  
  108.   /* USER CODE END USB_MspDeInit 1 */
  109.   }
  110. }
  111.  
  112. /**
  113.   * @brief  Setup stage callback
  114.   * @param  hpcd: PCD handle
  115.   * @retval None
  116.   */
  117. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  118. static void PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
  119. #else
  120. void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
  121. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  122. {
  123.   USBD_LL_SetupStage((USBD_HandleTypeDef*)hpcd->pData, (uint8_t *)hpcd->Setup);
  124. }
  125.  
  126. /**
  127.   * @brief  Data Out stage callback.
  128.   * @param  hpcd: PCD handle
  129.   * @param  epnum: Endpoint number
  130.   * @retval None
  131.   */
  132. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  133. static void PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  134. #else
  135. void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  136. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  137. {
  138.   USBD_LL_DataOutStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
  139. }
  140.  
  141. /**
  142.   * @brief  Data In stage callback.
  143.   * @param  hpcd: PCD handle
  144.   * @param  epnum: Endpoint number
  145.   * @retval None
  146.   */
  147. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  148. static void PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  149. #else
  150. void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  151. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  152. {
  153.   USBD_LL_DataInStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
  154. }
  155.  
  156. /**
  157.   * @brief  SOF callback.
  158.   * @param  hpcd: PCD handle
  159.   * @retval None
  160.   */
  161. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  162. static void PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
  163. #else
  164. void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
  165. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  166. {
  167.   USBD_LL_SOF((USBD_HandleTypeDef*)hpcd->pData);
  168. }
  169.  
  170. /**
  171.   * @brief  Reset callback.
  172.   * @param  hpcd: PCD handle
  173.   * @retval None
  174.   */
  175. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  176. static void PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
  177. #else
  178. void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
  179. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  180. {
  181.   USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
  182.  
  183.   if ( hpcd->Init.speed != PCD_SPEED_FULL)
  184.   {
  185.     Error_Handler();
  186.   }
  187.     /* Set Speed. */
  188.   USBD_LL_SetSpeed((USBD_HandleTypeDef*)hpcd->pData, speed);
  189.  
  190.   /* Reset Device. */
  191.   USBD_LL_Reset((USBD_HandleTypeDef*)hpcd->pData);
  192. }
  193.  
  194. /**
  195.   * @brief  Suspend callback.
  196.   * When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
  197.   * @param  hpcd: PCD handle
  198.   * @retval None
  199.   */
  200. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  201. static void PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
  202. #else
  203. void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
  204. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  205. {
  206.   /* Inform USB library that core enters in suspend Mode. */
  207.   USBD_LL_Suspend((USBD_HandleTypeDef*)hpcd->pData);
  208.   /* Enter in STOP mode. */
  209.   /* USER CODE BEGIN 2 */
  210.   if (hpcd->Init.low_power_enable)
  211.   {
  212.     /* Set SLEEPDEEP bit and SleepOnExit of Cortex System Control Register. */
  213.     SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
  214.   }
  215.   /* USER CODE END 2 */
  216. }
  217.  
  218. /**
  219.   * @brief  Resume callback.
  220.   * When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
  221.   * @param  hpcd: PCD handle
  222.   * @retval None
  223.   */
  224. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  225. static void PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
  226. #else
  227. void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
  228. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  229. {
  230.   /* USER CODE BEGIN 3 */
  231.  
  232.   /* USER CODE END 3 */
  233.   USBD_LL_Resume((USBD_HandleTypeDef*)hpcd->pData);
  234. }
  235.  
  236. /**
  237.   * @brief  ISOOUTIncomplete callback.
  238.   * @param  hpcd: PCD handle
  239.   * @param  epnum: Endpoint number
  240.   * @retval None
  241.   */
  242. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  243. static void PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  244. #else
  245. void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  246. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  247. {
  248.   USBD_LL_IsoOUTIncomplete((USBD_HandleTypeDef*)hpcd->pData, epnum);
  249. }
  250.  
  251. /**
  252.   * @brief  ISOINIncomplete callback.
  253.   * @param  hpcd: PCD handle
  254.   * @param  epnum: Endpoint number
  255.   * @retval None
  256.   */
  257. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  258. static void PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  259. #else
  260. void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
  261. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  262. {
  263.   USBD_LL_IsoINIncomplete((USBD_HandleTypeDef*)hpcd->pData, epnum);
  264. }
  265.  
  266. /**
  267.   * @brief  Connect callback.
  268.   * @param  hpcd: PCD handle
  269.   * @retval None
  270.   */
  271. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  272. static void PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
  273. #else
  274. void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
  275. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  276. {
  277.   USBD_LL_DevConnected((USBD_HandleTypeDef*)hpcd->pData);
  278. }
  279.  
  280. /**
  281.   * @brief  Disconnect callback.
  282.   * @param  hpcd: PCD handle
  283.   * @retval None
  284.   */
  285. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  286. static void PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
  287. #else
  288. void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
  289. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  290. {
  291.   USBD_LL_DevDisconnected((USBD_HandleTypeDef*)hpcd->pData);
  292. }
  293.  
  294. /*******************************************************************************
  295.                        LL Driver Interface (USB Device Library --> PCD)
  296. *******************************************************************************/
  297.  
  298. /**
  299.   * @brief  Initializes the low level portion of the device driver.
  300.   * @param  pdev: Device handle
  301.   * @retval USBD status
  302.   */
  303. USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev)
  304. {
  305.   /* Init USB Ip. */
  306.   /* Link the driver to the stack. */
  307.   hpcd_USB_FS.pData = pdev;
  308.   pdev->pData = &hpcd_USB_FS;
  309.  
  310.   hpcd_USB_FS.Instance = USB;
  311.   hpcd_USB_FS.Init.dev_endpoints = 8;
  312.   hpcd_USB_FS.Init.speed = PCD_SPEED_FULL;
  313.   hpcd_USB_FS.Init.low_power_enable = DISABLE;
  314.   hpcd_USB_FS.Init.lpm_enable = DISABLE;
  315.   hpcd_USB_FS.Init.battery_charging_enable = DISABLE;
  316.   if (HAL_PCD_Init(&hpcd_USB_FS) != HAL_OK)
  317.   {
  318.     Error_Handler( );
  319.   }
  320.  
  321. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  322.   /* Register USB PCD CallBacks */
  323.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_SOF_CB_ID, PCD_SOFCallback);
  324.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_SETUPSTAGE_CB_ID, PCD_SetupStageCallback);
  325.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_RESET_CB_ID, PCD_ResetCallback);
  326.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_SUSPEND_CB_ID, PCD_SuspendCallback);
  327.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_RESUME_CB_ID, PCD_ResumeCallback);
  328.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_CONNECT_CB_ID, PCD_ConnectCallback);
  329.   HAL_PCD_RegisterCallback(&hpcd_USB_FS, HAL_PCD_DISCONNECT_CB_ID, PCD_DisconnectCallback);
  330.  
  331.   HAL_PCD_RegisterDataOutStageCallback(&hpcd_USB_FS, PCD_DataOutStageCallback);
  332.   HAL_PCD_RegisterDataInStageCallback(&hpcd_USB_FS, PCD_DataInStageCallback);
  333.   HAL_PCD_RegisterIsoOutIncpltCallback(&hpcd_USB_FS, PCD_ISOOUTIncompleteCallback);
  334.   HAL_PCD_RegisterIsoInIncpltCallback(&hpcd_USB_FS, PCD_ISOINIncompleteCallback);
  335. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  336.   /* USER CODE BEGIN EndPoint_Configuration */
  337.   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x00 , PCD_SNG_BUF, 0x18);
  338.   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x80 , PCD_SNG_BUF, 0x58);
  339.   /* USER CODE END EndPoint_Configuration */
  340.   /* USER CODE BEGIN EndPoint_Configuration_CDC */
  341.   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x81 , PCD_SNG_BUF, 0xC0);
  342.   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x01 , PCD_SNG_BUF, 0x110);
  343.   HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x82 , PCD_SNG_BUF, 0x100);
  344.   /* USER CODE END EndPoint_Configuration_CDC */
  345.   return USBD_OK;
  346. }
  347.  
  348. /**
  349.   * @brief  De-Initializes the low level portion of the device driver.
  350.   * @param  pdev: Device handle
  351.   * @retval USBD status
  352.   */
  353. USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev)
  354. {
  355.   HAL_StatusTypeDef hal_status = HAL_OK;
  356.   USBD_StatusTypeDef usb_status = USBD_OK;
  357.  
  358.   hal_status = HAL_PCD_DeInit(pdev->pData);
  359.  
  360.   usb_status =  USBD_Get_USB_Status(hal_status);
  361.  
  362.   return usb_status;
  363. }
  364.  
  365. /**
  366.   * @brief  Starts the low level portion of the device driver.
  367.   * @param  pdev: Device handle
  368.   * @retval USBD status
  369.   */
  370. USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
  371. {
  372.   HAL_StatusTypeDef hal_status = HAL_OK;
  373.   USBD_StatusTypeDef usb_status = USBD_OK;
  374.  
  375.   hal_status = HAL_PCD_Start(pdev->pData);
  376.  
  377.   usb_status =  USBD_Get_USB_Status(hal_status);
  378.  
  379.   return usb_status;
  380. }
  381.  
  382. /**
  383.   * @brief  Stops the low level portion of the device driver.
  384.   * @param  pdev: Device handle
  385.   * @retval USBD status
  386.   */
  387. USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev)
  388. {
  389.   HAL_StatusTypeDef hal_status = HAL_OK;
  390.   USBD_StatusTypeDef usb_status = USBD_OK;
  391.  
  392.   hal_status = HAL_PCD_Stop(pdev->pData);
  393.  
  394.   usb_status =  USBD_Get_USB_Status(hal_status);
  395.  
  396.   return usb_status;
  397. }
  398.  
  399. /**
  400.   * @brief  Opens an endpoint of the low level driver.
  401.   * @param  pdev: Device handle
  402.   * @param  ep_addr: Endpoint number
  403.   * @param  ep_type: Endpoint type
  404.   * @param  ep_mps: Endpoint max packet size
  405.   * @retval USBD status
  406.   */
  407. USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t ep_type, uint16_t ep_mps)
  408. {
  409.   HAL_StatusTypeDef hal_status = HAL_OK;
  410.   USBD_StatusTypeDef usb_status = USBD_OK;
  411.  
  412.   hal_status = HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
  413.  
  414.   usb_status =  USBD_Get_USB_Status(hal_status);
  415.  
  416.   return usb_status;
  417. }
  418.  
  419. /**
  420.   * @brief  Closes an endpoint of the low level driver.
  421.   * @param  pdev: Device handle
  422.   * @param  ep_addr: Endpoint number
  423.   * @retval USBD status
  424.   */
  425. USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  426. {
  427.   HAL_StatusTypeDef hal_status = HAL_OK;
  428.   USBD_StatusTypeDef usb_status = USBD_OK;
  429.  
  430.   hal_status = HAL_PCD_EP_Close(pdev->pData, ep_addr);
  431.  
  432.   usb_status =  USBD_Get_USB_Status(hal_status);
  433.  
  434.   return usb_status;
  435. }
  436.  
  437. /**
  438.   * @brief  Flushes an endpoint of the Low Level Driver.
  439.   * @param  pdev: Device handle
  440.   * @param  ep_addr: Endpoint number
  441.   * @retval USBD status
  442.   */
  443. USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  444. {
  445.   HAL_StatusTypeDef hal_status = HAL_OK;
  446.   USBD_StatusTypeDef usb_status = USBD_OK;
  447.  
  448.   hal_status = HAL_PCD_EP_Flush(pdev->pData, ep_addr);
  449.  
  450.   usb_status =  USBD_Get_USB_Status(hal_status);
  451.  
  452.   return usb_status;
  453. }
  454.  
  455. /**
  456.   * @brief  Sets a Stall condition on an endpoint of the Low Level Driver.
  457.   * @param  pdev: Device handle
  458.   * @param  ep_addr: Endpoint number
  459.   * @retval USBD status
  460.   */
  461. USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  462. {
  463.   HAL_StatusTypeDef hal_status = HAL_OK;
  464.   USBD_StatusTypeDef usb_status = USBD_OK;
  465.  
  466.   hal_status = HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
  467.  
  468.   usb_status =  USBD_Get_USB_Status(hal_status);
  469.  
  470.   return usb_status;
  471. }
  472.  
  473. /**
  474.   * @brief  Clears a Stall condition on an endpoint of the Low Level Driver.
  475.   * @param  pdev: Device handle
  476.   * @param  ep_addr: Endpoint number
  477.   * @retval USBD status
  478.   */
  479. USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  480. {
  481.   HAL_StatusTypeDef hal_status = HAL_OK;
  482.   USBD_StatusTypeDef usb_status = USBD_OK;
  483.  
  484.   hal_status = HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);
  485.  
  486.   usb_status =  USBD_Get_USB_Status(hal_status);
  487.  
  488.   return usb_status;
  489. }
  490.  
  491. /**
  492.   * @brief  Returns Stall condition.
  493.   * @param  pdev: Device handle
  494.   * @param  ep_addr: Endpoint number
  495.   * @retval Stall (1: Yes, 0: No)
  496.   */
  497. uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  498. {
  499.   PCD_HandleTypeDef *hpcd = (PCD_HandleTypeDef*) pdev->pData;
  500.  
  501.   if((ep_addr & 0x80) == 0x80)
  502.   {
  503.     return hpcd->IN_ep[ep_addr & 0x7F].is_stall;
  504.   }
  505.   else
  506.   {
  507.     return hpcd->OUT_ep[ep_addr & 0x7F].is_stall;
  508.   }
  509. }
  510.  
  511. /**
  512.   * @brief  Assigns a USB address to the device.
  513.   * @param  pdev: Device handle
  514.   * @param  dev_addr: Device address
  515.   * @retval USBD status
  516.   */
  517. USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev, uint8_t dev_addr)
  518. {
  519.   HAL_StatusTypeDef hal_status = HAL_OK;
  520.   USBD_StatusTypeDef usb_status = USBD_OK;
  521.  
  522.   hal_status = HAL_PCD_SetAddress(pdev->pData, dev_addr);
  523.  
  524.   usb_status =  USBD_Get_USB_Status(hal_status);
  525.  
  526.   return usb_status;
  527. }
  528.  
  529. /**
  530.   * @brief  Transmits data over an endpoint.
  531.   * @param  pdev: Device handle
  532.   * @param  ep_addr: Endpoint number
  533.   * @param  pbuf: Pointer to data to be sent
  534.   * @param  size: Data size
  535.   * @retval USBD status
  536.   */
  537. USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t *pbuf, uint16_t size)
  538. {
  539.   HAL_StatusTypeDef hal_status = HAL_OK;
  540.   USBD_StatusTypeDef usb_status = USBD_OK;
  541.  
  542.   hal_status = HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
  543.  
  544.   usb_status =  USBD_Get_USB_Status(hal_status);
  545.  
  546.   return usb_status;
  547. }
  548.  
  549. /**
  550.   * @brief  Prepares an endpoint for reception.
  551.   * @param  pdev: Device handle
  552.   * @param  ep_addr: Endpoint number
  553.   * @param  pbuf: Pointer to data to be received
  554.   * @param  size: Data size
  555.   * @retval USBD status
  556.   */
  557. USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t *pbuf, uint16_t size)
  558. {
  559.   HAL_StatusTypeDef hal_status = HAL_OK;
  560.   USBD_StatusTypeDef usb_status = USBD_OK;
  561.  
  562.   hal_status = HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
  563.  
  564.   usb_status =  USBD_Get_USB_Status(hal_status);
  565.  
  566.   return usb_status;
  567. }
  568.  
  569. /**
  570.   * @brief  Returns the last transfered packet size.
  571.   * @param  pdev: Device handle
  572.   * @param  ep_addr: Endpoint number
  573.   * @retval Recived Data Size
  574.   */
  575. uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
  576. {
  577.   return HAL_PCD_EP_GetRxCount((PCD_HandleTypeDef*) pdev->pData, ep_addr);
  578. }
  579.  
  580. /**
  581.   * @brief  Delays routine for the USB device library.
  582.   * @param  Delay: Delay in ms
  583.   * @retval None
  584.   */
  585. void USBD_LL_Delay(uint32_t Delay)
  586. {
  587.   HAL_Delay(Delay);
  588. }
  589.  
  590. /**
  591.   * @brief  Static single allocation.
  592.   * @param  size: Size of allocated memory
  593.   * @retval None
  594.   */
  595. void *USBD_static_malloc(uint32_t size)
  596. {
  597.   static uint32_t mem[(sizeof(USBD_CDC_HandleTypeDef)/4)+1];/* On 32-bit boundary */
  598.   return mem;
  599. }
  600.  
  601. /**
  602.   * @brief  Dummy memory free
  603.   * @param  p: Pointer to allocated  memory address
  604.   * @retval None
  605.   */
  606. void USBD_static_free(void *p)
  607. {
  608.  
  609. }
  610.  
  611. /**
  612.   * @brief Software Device Connection
  613.   * @param hpcd: PCD handle
  614.   * @param state: Connection state (0: disconnected / 1: connected)
  615.   * @retval None
  616.   */
  617. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
  618. static void PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
  619. #else
  620. void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
  621. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
  622. {
  623.   /* USER CODE BEGIN 6 */
  624.   if (state == 1)
  625.   {
  626.     /* Configure Low connection state. */
  627.  
  628.   }
  629.   else
  630.   {
  631.     /* Configure High connection state. */
  632.  
  633.   }
  634.   /* USER CODE END 6 */
  635. }
  636.  
  637. /**
  638.   * @brief  Retuns the USB status depending on the HAL status:
  639.   * @param  hal_status: HAL status
  640.   * @retval USB status
  641.   */
  642. USBD_StatusTypeDef USBD_Get_USB_Status(HAL_StatusTypeDef hal_status)
  643. {
  644.   USBD_StatusTypeDef usb_status = USBD_OK;
  645.  
  646.   switch (hal_status)
  647.   {
  648.     case HAL_OK :
  649.       usb_status = USBD_OK;
  650.     break;
  651.     case HAL_ERROR :
  652.       usb_status = USBD_FAIL;
  653.     break;
  654.     case HAL_BUSY :
  655.       usb_status = USBD_BUSY;
  656.     break;
  657.     case HAL_TIMEOUT :
  658.       usb_status = USBD_FAIL;
  659.     break;
  660.     default :
  661.       usb_status = USBD_FAIL;
  662.     break;
  663.   }
  664.   return usb_status;
  665. }
  666.  
  667. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  668.