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