source: S-port/trunk/USB_DEVICE/Target/usbd_conf.c

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