1 /**
2 ******************************************************************************
3 * @file stm32f0xx_hal_pcd.c
4 * @author MCD Application Team
5 * @brief PCD HAL module driver.
6 * This file provides firmware functions to manage the following
7 * functionalities of the USB Peripheral Controller:
8 * + Initialization and de-initialization functions
9 * + IO operation functions
10 * + Peripheral Control functions
11 * + Peripheral State functions
12 *
13 ******************************************************************************
14 * @attention
15 *
16 * Copyright (c) 2016 STMicroelectronics.
17 * All rights reserved.
18 *
19 * This software is licensed under terms that can be found in the LICENSE file
20 * in the root directory of this software component.
21 * If no LICENSE file comes with this software, it is provided AS-IS.
22 *
23 ******************************************************************************
24 @verbatim
25 ==============================================================================
26 ##### How to use this driver #####
27 ==============================================================================
28 [..]
29 The PCD HAL driver can be used as follows:
30
31 (#) Declare a PCD_HandleTypeDef handle structure, for example:
32 PCD_HandleTypeDef hpcd;
33
34 (#) Fill parameters of Init structure in HCD handle
35
36 (#) Call HAL_PCD_Init() API to initialize the PCD peripheral (Core, Device core, ...)
37
38 (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
39 (##) Enable the PCD/USB Low Level interface clock using
40 (+++) __HAL_RCC_USB_CLK_ENABLE(); For USB Device FS peripheral
41
42 (##) Initialize the related GPIO clocks
43 (##) Configure PCD pin-out
44 (##) Configure PCD NVIC interrupt
45
46 (#)Associate the Upper USB device stack to the HAL PCD Driver:
47 (##) hpcd.pData = pdev;
48
49 (#)Enable PCD transmission and reception:
50 (##) HAL_PCD_Start();
51
52 @endverbatim
53 ******************************************************************************
54 */
55
56 /* Includes ------------------------------------------------------------------*/
57 #include "stm32f0xx_hal.h"
58
59 /** @addtogroup STM32F0xx_HAL_Driver
60 * @{
61 */
62
63 /** @defgroup PCD PCD
64 * @brief PCD HAL module driver
65 * @{
66 */
67
68 #ifdef HAL_PCD_MODULE_ENABLED
69
70 #if defined (USB)
71
72 /* Private types -------------------------------------------------------------*/
73 /* Private variables ---------------------------------------------------------*/
74 /* Private constants ---------------------------------------------------------*/
75 /* Private macros ------------------------------------------------------------*/
76 /** @defgroup PCD_Private_Macros PCD Private Macros
77 * @{
78 */
79 #define PCD_MIN(a, b) (((a) < (b)) ? (a) : (b))
80 #define PCD_MAX(a, b) (((a) > (b)) ? (a) : (b))
81 /**
82 * @}
83 */
84
85 /* Private functions prototypes ----------------------------------------------*/
86 /** @defgroup PCD_Private_Functions PCD Private Functions
87 * @{
88 */
89
90 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
91 #if (USE_USB_DOUBLE_BUFFER == 1U)
92 static HAL_StatusTypeDef HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
93 static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
94 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
95
96 /**
97 * @}
98 */
99
100 /* Exported functions --------------------------------------------------------*/
101 /** @defgroup PCD_Exported_Functions PCD Exported Functions
102 * @{
103 */
104
105 /** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
106 * @brief Initialization and Configuration functions
107 *
108 @verbatim
109 ===============================================================================
110 ##### Initialization and de-initialization functions #####
111 ===============================================================================
112 [..] This section provides functions allowing to:
113
114 @endverbatim
115 * @{
116 */
117
118 /**
119 * @brief Initializes the PCD according to the specified
120 * parameters in the PCD_InitTypeDef and initialize the associated handle.
121 * @param hpcd PCD handle
122 * @retval HAL status
123 */
HAL_PCD_Init(PCD_HandleTypeDef * hpcd)124 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
125 {
126 uint8_t i;
127
128 /* Check the PCD handle allocation */
129 if (hpcd == NULL)
130 {
131 return HAL_ERROR;
132 }
133
134 /* Check the parameters */
135 assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
136
137 if (hpcd->State == HAL_PCD_STATE_RESET)
138 {
139 /* Allocate lock resource and initialize it */
140 hpcd->Lock = HAL_UNLOCKED;
141
142 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
143 hpcd->SOFCallback = HAL_PCD_SOFCallback;
144 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
145 hpcd->ResetCallback = HAL_PCD_ResetCallback;
146 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
147 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
148 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
149 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
150 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback;
151 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback;
152 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback;
153 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback;
154 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback;
155 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback;
156
157 if (hpcd->MspInitCallback == NULL)
158 {
159 hpcd->MspInitCallback = HAL_PCD_MspInit;
160 }
161
162 /* Init the low level hardware */
163 hpcd->MspInitCallback(hpcd);
164 #else
165 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
166 HAL_PCD_MspInit(hpcd);
167 #endif /* (USE_HAL_PCD_REGISTER_CALLBACKS) */
168 }
169
170 hpcd->State = HAL_PCD_STATE_BUSY;
171
172 /* Disable the Interrupts */
173 __HAL_PCD_DISABLE(hpcd);
174
175 /* Init endpoints structures */
176 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
177 {
178 /* Init ep structure */
179 hpcd->IN_ep[i].is_in = 1U;
180 hpcd->IN_ep[i].num = i;
181 /* Control until ep is activated */
182 hpcd->IN_ep[i].type = EP_TYPE_CTRL;
183 hpcd->IN_ep[i].maxpacket = 0U;
184 hpcd->IN_ep[i].xfer_buff = 0U;
185 hpcd->IN_ep[i].xfer_len = 0U;
186 }
187
188 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
189 {
190 hpcd->OUT_ep[i].is_in = 0U;
191 hpcd->OUT_ep[i].num = i;
192 /* Control until ep is activated */
193 hpcd->OUT_ep[i].type = EP_TYPE_CTRL;
194 hpcd->OUT_ep[i].maxpacket = 0U;
195 hpcd->OUT_ep[i].xfer_buff = 0U;
196 hpcd->OUT_ep[i].xfer_len = 0U;
197 }
198
199 /* Init Device */
200 (void)USB_DevInit(hpcd->Instance, hpcd->Init);
201
202 hpcd->USB_Address = 0U;
203 hpcd->State = HAL_PCD_STATE_READY;
204
205 /* Activate LPM */
206 if (hpcd->Init.lpm_enable == 1U)
207 {
208 (void)HAL_PCDEx_ActivateLPM(hpcd);
209 }
210
211 return HAL_OK;
212 }
213
214 /**
215 * @brief DeInitializes the PCD peripheral.
216 * @param hpcd PCD handle
217 * @retval HAL status
218 */
HAL_PCD_DeInit(PCD_HandleTypeDef * hpcd)219 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
220 {
221 /* Check the PCD handle allocation */
222 if (hpcd == NULL)
223 {
224 return HAL_ERROR;
225 }
226
227 hpcd->State = HAL_PCD_STATE_BUSY;
228
229 /* Stop Device */
230 if (USB_StopDevice(hpcd->Instance) != HAL_OK)
231 {
232 return HAL_ERROR;
233 }
234
235 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
236 if (hpcd->MspDeInitCallback == NULL)
237 {
238 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit; /* Legacy weak MspDeInit */
239 }
240
241 /* DeInit the low level hardware */
242 hpcd->MspDeInitCallback(hpcd);
243 #else
244 /* DeInit the low level hardware: CLOCK, NVIC.*/
245 HAL_PCD_MspDeInit(hpcd);
246 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
247
248 hpcd->State = HAL_PCD_STATE_RESET;
249
250 return HAL_OK;
251 }
252
253 /**
254 * @brief Initializes the PCD MSP.
255 * @param hpcd PCD handle
256 * @retval None
257 */
HAL_PCD_MspInit(PCD_HandleTypeDef * hpcd)258 __weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
259 {
260 /* Prevent unused argument(s) compilation warning */
261 UNUSED(hpcd);
262
263 /* NOTE : This function should not be modified, when the callback is needed,
264 the HAL_PCD_MspInit could be implemented in the user file
265 */
266 }
267
268 /**
269 * @brief DeInitializes PCD MSP.
270 * @param hpcd PCD handle
271 * @retval None
272 */
HAL_PCD_MspDeInit(PCD_HandleTypeDef * hpcd)273 __weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
274 {
275 /* Prevent unused argument(s) compilation warning */
276 UNUSED(hpcd);
277
278 /* NOTE : This function should not be modified, when the callback is needed,
279 the HAL_PCD_MspDeInit could be implemented in the user file
280 */
281 }
282
283 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
284 /**
285 * @brief Register a User USB PCD Callback
286 * To be used instead of the weak predefined callback
287 * @param hpcd USB PCD handle
288 * @param CallbackID ID of the callback to be registered
289 * This parameter can be one of the following values:
290 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
291 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
292 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
293 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
294 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
295 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
296 * @arg @ref HAL_PCD_DISCONNECT_CB_ID USB PCD Disconnect callback ID
297 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
298 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
299 * @param pCallback pointer to the Callback function
300 * @retval HAL status
301 */
HAL_PCD_RegisterCallback(PCD_HandleTypeDef * hpcd,HAL_PCD_CallbackIDTypeDef CallbackID,pPCD_CallbackTypeDef pCallback)302 HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd,
303 HAL_PCD_CallbackIDTypeDef CallbackID,
304 pPCD_CallbackTypeDef pCallback)
305 {
306 HAL_StatusTypeDef status = HAL_OK;
307
308 if (pCallback == NULL)
309 {
310 /* Update the error code */
311 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
312 return HAL_ERROR;
313 }
314 /* Process locked */
315 __HAL_LOCK(hpcd);
316
317 if (hpcd->State == HAL_PCD_STATE_READY)
318 {
319 switch (CallbackID)
320 {
321 case HAL_PCD_SOF_CB_ID :
322 hpcd->SOFCallback = pCallback;
323 break;
324
325 case HAL_PCD_SETUPSTAGE_CB_ID :
326 hpcd->SetupStageCallback = pCallback;
327 break;
328
329 case HAL_PCD_RESET_CB_ID :
330 hpcd->ResetCallback = pCallback;
331 break;
332
333 case HAL_PCD_SUSPEND_CB_ID :
334 hpcd->SuspendCallback = pCallback;
335 break;
336
337 case HAL_PCD_RESUME_CB_ID :
338 hpcd->ResumeCallback = pCallback;
339 break;
340
341 case HAL_PCD_CONNECT_CB_ID :
342 hpcd->ConnectCallback = pCallback;
343 break;
344
345 case HAL_PCD_DISCONNECT_CB_ID :
346 hpcd->DisconnectCallback = pCallback;
347 break;
348
349 case HAL_PCD_MSPINIT_CB_ID :
350 hpcd->MspInitCallback = pCallback;
351 break;
352
353 case HAL_PCD_MSPDEINIT_CB_ID :
354 hpcd->MspDeInitCallback = pCallback;
355 break;
356
357 default :
358 /* Update the error code */
359 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
360 /* Return error status */
361 status = HAL_ERROR;
362 break;
363 }
364 }
365 else if (hpcd->State == HAL_PCD_STATE_RESET)
366 {
367 switch (CallbackID)
368 {
369 case HAL_PCD_MSPINIT_CB_ID :
370 hpcd->MspInitCallback = pCallback;
371 break;
372
373 case HAL_PCD_MSPDEINIT_CB_ID :
374 hpcd->MspDeInitCallback = pCallback;
375 break;
376
377 default :
378 /* Update the error code */
379 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
380 /* Return error status */
381 status = HAL_ERROR;
382 break;
383 }
384 }
385 else
386 {
387 /* Update the error code */
388 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
389 /* Return error status */
390 status = HAL_ERROR;
391 }
392
393 /* Release Lock */
394 __HAL_UNLOCK(hpcd);
395 return status;
396 }
397
398 /**
399 * @brief Unregister an USB PCD Callback
400 * USB PCD callback is redirected to the weak predefined callback
401 * @param hpcd USB PCD handle
402 * @param CallbackID ID of the callback to be unregistered
403 * This parameter can be one of the following values:
404 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
405 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
406 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
407 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
408 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
409 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
410 * @arg @ref HAL_PCD_DISCONNECT_CB_ID USB PCD Disconnect callback ID
411 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
412 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
413 * @retval HAL status
414 */
HAL_PCD_UnRegisterCallback(PCD_HandleTypeDef * hpcd,HAL_PCD_CallbackIDTypeDef CallbackID)415 HAL_StatusTypeDef HAL_PCD_UnRegisterCallback(PCD_HandleTypeDef *hpcd, HAL_PCD_CallbackIDTypeDef CallbackID)
416 {
417 HAL_StatusTypeDef status = HAL_OK;
418
419 /* Process locked */
420 __HAL_LOCK(hpcd);
421
422 /* Setup Legacy weak Callbacks */
423 if (hpcd->State == HAL_PCD_STATE_READY)
424 {
425 switch (CallbackID)
426 {
427 case HAL_PCD_SOF_CB_ID :
428 hpcd->SOFCallback = HAL_PCD_SOFCallback;
429 break;
430
431 case HAL_PCD_SETUPSTAGE_CB_ID :
432 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
433 break;
434
435 case HAL_PCD_RESET_CB_ID :
436 hpcd->ResetCallback = HAL_PCD_ResetCallback;
437 break;
438
439 case HAL_PCD_SUSPEND_CB_ID :
440 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
441 break;
442
443 case HAL_PCD_RESUME_CB_ID :
444 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
445 break;
446
447 case HAL_PCD_CONNECT_CB_ID :
448 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
449 break;
450
451 case HAL_PCD_DISCONNECT_CB_ID :
452 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
453 break;
454
455 case HAL_PCD_MSPINIT_CB_ID :
456 hpcd->MspInitCallback = HAL_PCD_MspInit;
457 break;
458
459 case HAL_PCD_MSPDEINIT_CB_ID :
460 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
461 break;
462
463 default :
464 /* Update the error code */
465 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
466
467 /* Return error status */
468 status = HAL_ERROR;
469 break;
470 }
471 }
472 else if (hpcd->State == HAL_PCD_STATE_RESET)
473 {
474 switch (CallbackID)
475 {
476 case HAL_PCD_MSPINIT_CB_ID :
477 hpcd->MspInitCallback = HAL_PCD_MspInit;
478 break;
479
480 case HAL_PCD_MSPDEINIT_CB_ID :
481 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
482 break;
483
484 default :
485 /* Update the error code */
486 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
487
488 /* Return error status */
489 status = HAL_ERROR;
490 break;
491 }
492 }
493 else
494 {
495 /* Update the error code */
496 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
497
498 /* Return error status */
499 status = HAL_ERROR;
500 }
501
502 /* Release Lock */
503 __HAL_UNLOCK(hpcd);
504 return status;
505 }
506
507 /**
508 * @brief Register USB PCD Data OUT Stage Callback
509 * To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback
510 * @param hpcd PCD handle
511 * @param pCallback pointer to the USB PCD Data OUT Stage Callback function
512 * @retval HAL status
513 */
HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef * hpcd,pPCD_DataOutStageCallbackTypeDef pCallback)514 HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd,
515 pPCD_DataOutStageCallbackTypeDef pCallback)
516 {
517 HAL_StatusTypeDef status = HAL_OK;
518
519 if (pCallback == NULL)
520 {
521 /* Update the error code */
522 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
523
524 return HAL_ERROR;
525 }
526
527 /* Process locked */
528 __HAL_LOCK(hpcd);
529
530 if (hpcd->State == HAL_PCD_STATE_READY)
531 {
532 hpcd->DataOutStageCallback = pCallback;
533 }
534 else
535 {
536 /* Update the error code */
537 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
538
539 /* Return error status */
540 status = HAL_ERROR;
541 }
542
543 /* Release Lock */
544 __HAL_UNLOCK(hpcd);
545
546 return status;
547 }
548
549 /**
550 * @brief Unregister the USB PCD Data OUT Stage Callback
551 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataOutStageCallback() predefined callback
552 * @param hpcd PCD handle
553 * @retval HAL status
554 */
HAL_PCD_UnRegisterDataOutStageCallback(PCD_HandleTypeDef * hpcd)555 HAL_StatusTypeDef HAL_PCD_UnRegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd)
556 {
557 HAL_StatusTypeDef status = HAL_OK;
558
559 /* Process locked */
560 __HAL_LOCK(hpcd);
561
562 if (hpcd->State == HAL_PCD_STATE_READY)
563 {
564 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback; /* Legacy weak DataOutStageCallback */
565 }
566 else
567 {
568 /* Update the error code */
569 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
570
571 /* Return error status */
572 status = HAL_ERROR;
573 }
574
575 /* Release Lock */
576 __HAL_UNLOCK(hpcd);
577
578 return status;
579 }
580
581 /**
582 * @brief Register USB PCD Data IN Stage Callback
583 * To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback
584 * @param hpcd PCD handle
585 * @param pCallback pointer to the USB PCD Data IN Stage Callback function
586 * @retval HAL status
587 */
HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef * hpcd,pPCD_DataInStageCallbackTypeDef pCallback)588 HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd,
589 pPCD_DataInStageCallbackTypeDef pCallback)
590 {
591 HAL_StatusTypeDef status = HAL_OK;
592
593 if (pCallback == NULL)
594 {
595 /* Update the error code */
596 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
597
598 return HAL_ERROR;
599 }
600
601 /* Process locked */
602 __HAL_LOCK(hpcd);
603
604 if (hpcd->State == HAL_PCD_STATE_READY)
605 {
606 hpcd->DataInStageCallback = pCallback;
607 }
608 else
609 {
610 /* Update the error code */
611 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
612
613 /* Return error status */
614 status = HAL_ERROR;
615 }
616
617 /* Release Lock */
618 __HAL_UNLOCK(hpcd);
619
620 return status;
621 }
622
623 /**
624 * @brief Unregister the USB PCD Data IN Stage Callback
625 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataInStageCallback() predefined callback
626 * @param hpcd PCD handle
627 * @retval HAL status
628 */
HAL_PCD_UnRegisterDataInStageCallback(PCD_HandleTypeDef * hpcd)629 HAL_StatusTypeDef HAL_PCD_UnRegisterDataInStageCallback(PCD_HandleTypeDef *hpcd)
630 {
631 HAL_StatusTypeDef status = HAL_OK;
632
633 /* Process locked */
634 __HAL_LOCK(hpcd);
635
636 if (hpcd->State == HAL_PCD_STATE_READY)
637 {
638 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback; /* Legacy weak DataInStageCallback */
639 }
640 else
641 {
642 /* Update the error code */
643 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
644
645 /* Return error status */
646 status = HAL_ERROR;
647 }
648
649 /* Release Lock */
650 __HAL_UNLOCK(hpcd);
651
652 return status;
653 }
654
655 /**
656 * @brief Register USB PCD Iso OUT incomplete Callback
657 * To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
658 * @param hpcd PCD handle
659 * @param pCallback pointer to the USB PCD Iso OUT incomplete Callback function
660 * @retval HAL status
661 */
HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef * hpcd,pPCD_IsoOutIncpltCallbackTypeDef pCallback)662 HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd,
663 pPCD_IsoOutIncpltCallbackTypeDef pCallback)
664 {
665 HAL_StatusTypeDef status = HAL_OK;
666
667 if (pCallback == NULL)
668 {
669 /* Update the error code */
670 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
671
672 return HAL_ERROR;
673 }
674
675 /* Process locked */
676 __HAL_LOCK(hpcd);
677
678 if (hpcd->State == HAL_PCD_STATE_READY)
679 {
680 hpcd->ISOOUTIncompleteCallback = pCallback;
681 }
682 else
683 {
684 /* Update the error code */
685 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
686
687 /* Return error status */
688 status = HAL_ERROR;
689 }
690
691 /* Release Lock */
692 __HAL_UNLOCK(hpcd);
693
694 return status;
695 }
696
697 /**
698 * @brief Unregister the USB PCD Iso OUT incomplete Callback
699 * USB PCD Iso OUT incomplete Callback is redirected
700 * to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
701 * @param hpcd PCD handle
702 * @retval HAL status
703 */
HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef * hpcd)704 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)
705 {
706 HAL_StatusTypeDef status = HAL_OK;
707
708 /* Process locked */
709 __HAL_LOCK(hpcd);
710
711 if (hpcd->State == HAL_PCD_STATE_READY)
712 {
713 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback; /* Legacy weak ISOOUTIncompleteCallback */
714 }
715 else
716 {
717 /* Update the error code */
718 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
719
720 /* Return error status */
721 status = HAL_ERROR;
722 }
723
724 /* Release Lock */
725 __HAL_UNLOCK(hpcd);
726
727 return status;
728 }
729
730 /**
731 * @brief Register USB PCD Iso IN incomplete Callback
732 * To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
733 * @param hpcd PCD handle
734 * @param pCallback pointer to the USB PCD Iso IN incomplete Callback function
735 * @retval HAL status
736 */
HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef * hpcd,pPCD_IsoInIncpltCallbackTypeDef pCallback)737 HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd,
738 pPCD_IsoInIncpltCallbackTypeDef pCallback)
739 {
740 HAL_StatusTypeDef status = HAL_OK;
741
742 if (pCallback == NULL)
743 {
744 /* Update the error code */
745 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
746
747 return HAL_ERROR;
748 }
749
750 /* Process locked */
751 __HAL_LOCK(hpcd);
752
753 if (hpcd->State == HAL_PCD_STATE_READY)
754 {
755 hpcd->ISOINIncompleteCallback = pCallback;
756 }
757 else
758 {
759 /* Update the error code */
760 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
761
762 /* Return error status */
763 status = HAL_ERROR;
764 }
765
766 /* Release Lock */
767 __HAL_UNLOCK(hpcd);
768
769 return status;
770 }
771
772 /**
773 * @brief Unregister the USB PCD Iso IN incomplete Callback
774 * USB PCD Iso IN incomplete Callback is redirected
775 * to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
776 * @param hpcd PCD handle
777 * @retval HAL status
778 */
HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef * hpcd)779 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)
780 {
781 HAL_StatusTypeDef status = HAL_OK;
782
783 /* Process locked */
784 __HAL_LOCK(hpcd);
785
786 if (hpcd->State == HAL_PCD_STATE_READY)
787 {
788 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback; /* Legacy weak ISOINIncompleteCallback */
789 }
790 else
791 {
792 /* Update the error code */
793 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
794
795 /* Return error status */
796 status = HAL_ERROR;
797 }
798
799 /* Release Lock */
800 __HAL_UNLOCK(hpcd);
801
802 return status;
803 }
804
805 /**
806 * @brief Register USB PCD BCD Callback
807 * To be used instead of the weak HAL_PCDEx_BCD_Callback() predefined callback
808 * @param hpcd PCD handle
809 * @param pCallback pointer to the USB PCD BCD Callback function
810 * @retval HAL status
811 */
HAL_PCD_RegisterBcdCallback(PCD_HandleTypeDef * hpcd,pPCD_BcdCallbackTypeDef pCallback)812 HAL_StatusTypeDef HAL_PCD_RegisterBcdCallback(PCD_HandleTypeDef *hpcd, pPCD_BcdCallbackTypeDef pCallback)
813 {
814 HAL_StatusTypeDef status = HAL_OK;
815
816 if (pCallback == NULL)
817 {
818 /* Update the error code */
819 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
820
821 return HAL_ERROR;
822 }
823
824 /* Process locked */
825 __HAL_LOCK(hpcd);
826
827 if (hpcd->State == HAL_PCD_STATE_READY)
828 {
829 hpcd->BCDCallback = pCallback;
830 }
831 else
832 {
833 /* Update the error code */
834 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
835
836 /* Return error status */
837 status = HAL_ERROR;
838 }
839
840 /* Release Lock */
841 __HAL_UNLOCK(hpcd);
842
843 return status;
844 }
845
846 /**
847 * @brief Unregister the USB PCD BCD Callback
848 * USB BCD Callback is redirected to the weak HAL_PCDEx_BCD_Callback() predefined callback
849 * @param hpcd PCD handle
850 * @retval HAL status
851 */
HAL_PCD_UnRegisterBcdCallback(PCD_HandleTypeDef * hpcd)852 HAL_StatusTypeDef HAL_PCD_UnRegisterBcdCallback(PCD_HandleTypeDef *hpcd)
853 {
854 HAL_StatusTypeDef status = HAL_OK;
855
856 /* Process locked */
857 __HAL_LOCK(hpcd);
858
859 if (hpcd->State == HAL_PCD_STATE_READY)
860 {
861 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback; /* Legacy weak HAL_PCDEx_BCD_Callback */
862 }
863 else
864 {
865 /* Update the error code */
866 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
867
868 /* Return error status */
869 status = HAL_ERROR;
870 }
871
872 /* Release Lock */
873 __HAL_UNLOCK(hpcd);
874
875 return status;
876 }
877
878 /**
879 * @brief Register USB PCD LPM Callback
880 * To be used instead of the weak HAL_PCDEx_LPM_Callback() predefined callback
881 * @param hpcd PCD handle
882 * @param pCallback pointer to the USB PCD LPM Callback function
883 * @retval HAL status
884 */
HAL_PCD_RegisterLpmCallback(PCD_HandleTypeDef * hpcd,pPCD_LpmCallbackTypeDef pCallback)885 HAL_StatusTypeDef HAL_PCD_RegisterLpmCallback(PCD_HandleTypeDef *hpcd, pPCD_LpmCallbackTypeDef pCallback)
886 {
887 HAL_StatusTypeDef status = HAL_OK;
888
889 if (pCallback == NULL)
890 {
891 /* Update the error code */
892 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
893
894 return HAL_ERROR;
895 }
896
897 /* Process locked */
898 __HAL_LOCK(hpcd);
899
900 if (hpcd->State == HAL_PCD_STATE_READY)
901 {
902 hpcd->LPMCallback = pCallback;
903 }
904 else
905 {
906 /* Update the error code */
907 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
908
909 /* Return error status */
910 status = HAL_ERROR;
911 }
912
913 /* Release Lock */
914 __HAL_UNLOCK(hpcd);
915
916 return status;
917 }
918
919 /**
920 * @brief Unregister the USB PCD LPM Callback
921 * USB LPM Callback is redirected to the weak HAL_PCDEx_LPM_Callback() predefined callback
922 * @param hpcd PCD handle
923 * @retval HAL status
924 */
HAL_PCD_UnRegisterLpmCallback(PCD_HandleTypeDef * hpcd)925 HAL_StatusTypeDef HAL_PCD_UnRegisterLpmCallback(PCD_HandleTypeDef *hpcd)
926 {
927 HAL_StatusTypeDef status = HAL_OK;
928
929 /* Process locked */
930 __HAL_LOCK(hpcd);
931
932 if (hpcd->State == HAL_PCD_STATE_READY)
933 {
934 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback; /* Legacy weak HAL_PCDEx_LPM_Callback */
935 }
936 else
937 {
938 /* Update the error code */
939 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
940
941 /* Return error status */
942 status = HAL_ERROR;
943 }
944
945 /* Release Lock */
946 __HAL_UNLOCK(hpcd);
947
948 return status;
949 }
950 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
951
952 /**
953 * @}
954 */
955
956 /** @defgroup PCD_Exported_Functions_Group2 Input and Output operation functions
957 * @brief Data transfers functions
958 *
959 @verbatim
960 ===============================================================================
961 ##### IO operation functions #####
962 ===============================================================================
963 [..]
964 This subsection provides a set of functions allowing to manage the PCD data
965 transfers.
966
967 @endverbatim
968 * @{
969 */
970
971 /**
972 * @brief Start the USB device
973 * @param hpcd PCD handle
974 * @retval HAL status
975 */
HAL_PCD_Start(PCD_HandleTypeDef * hpcd)976 HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
977 {
978 __HAL_LOCK(hpcd);
979 __HAL_PCD_ENABLE(hpcd);
980 (void)USB_DevConnect(hpcd->Instance);
981 __HAL_UNLOCK(hpcd);
982
983 return HAL_OK;
984 }
985
986 /**
987 * @brief Stop the USB device.
988 * @param hpcd PCD handle
989 * @retval HAL status
990 */
HAL_PCD_Stop(PCD_HandleTypeDef * hpcd)991 HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
992 {
993 __HAL_LOCK(hpcd);
994 __HAL_PCD_DISABLE(hpcd);
995 (void)USB_DevDisconnect(hpcd->Instance);
996 __HAL_UNLOCK(hpcd);
997
998 return HAL_OK;
999 }
1000
1001
1002 /**
1003 * @brief This function handles PCD interrupt request.
1004 * @param hpcd PCD handle
1005 * @retval HAL status
1006 */
HAL_PCD_IRQHandler(PCD_HandleTypeDef * hpcd)1007 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
1008 {
1009 uint32_t wIstr = USB_ReadInterrupts(hpcd->Instance);
1010
1011 if ((wIstr & USB_ISTR_CTR) == USB_ISTR_CTR)
1012 {
1013 /* servicing of the endpoint correct transfer interrupt */
1014 /* clear of the CTR flag into the sub */
1015 (void)PCD_EP_ISR_Handler(hpcd);
1016
1017 return;
1018 }
1019
1020 if ((wIstr & USB_ISTR_RESET) == USB_ISTR_RESET)
1021 {
1022 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
1023
1024 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1025 hpcd->ResetCallback(hpcd);
1026 #else
1027 HAL_PCD_ResetCallback(hpcd);
1028 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1029
1030 (void)HAL_PCD_SetAddress(hpcd, 0U);
1031
1032 return;
1033 }
1034
1035 if ((wIstr & USB_ISTR_PMAOVR) == USB_ISTR_PMAOVR)
1036 {
1037 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
1038
1039 return;
1040 }
1041
1042 if ((wIstr & USB_ISTR_ERR) == USB_ISTR_ERR)
1043 {
1044 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
1045
1046 return;
1047 }
1048
1049 if ((wIstr & USB_ISTR_WKUP) == USB_ISTR_WKUP)
1050 {
1051 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_LPMODE);
1052 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_FSUSP);
1053
1054 if (hpcd->LPM_State == LPM_L1)
1055 {
1056 hpcd->LPM_State = LPM_L0;
1057 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1058 hpcd->LPMCallback(hpcd, PCD_LPM_L0_ACTIVE);
1059 #else
1060 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
1061 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1062 }
1063
1064 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1065 hpcd->ResumeCallback(hpcd);
1066 #else
1067 HAL_PCD_ResumeCallback(hpcd);
1068 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1069
1070 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
1071
1072 return;
1073 }
1074
1075 if ((wIstr & USB_ISTR_SUSP) == USB_ISTR_SUSP)
1076 {
1077 /* Force low-power mode in the macrocell */
1078 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_FSUSP;
1079
1080 /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
1081 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);
1082
1083 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_LPMODE;
1084
1085 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1086 hpcd->SuspendCallback(hpcd);
1087 #else
1088 HAL_PCD_SuspendCallback(hpcd);
1089 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1090
1091 return;
1092 }
1093
1094 /* Handle LPM Interrupt */
1095 if ((wIstr & USB_ISTR_L1REQ) == USB_ISTR_L1REQ)
1096 {
1097 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_L1REQ);
1098 if (hpcd->LPM_State == LPM_L0)
1099 {
1100 /* Force suspend and low-power mode before going to L1 state*/
1101 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_LPMODE;
1102 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_FSUSP;
1103
1104 hpcd->LPM_State = LPM_L1;
1105 hpcd->BESL = ((uint32_t)hpcd->Instance->LPMCSR & USB_LPMCSR_BESL) >> 2;
1106 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1107 hpcd->LPMCallback(hpcd, PCD_LPM_L1_ACTIVE);
1108 #else
1109 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
1110 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1111 }
1112 else
1113 {
1114 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1115 hpcd->SuspendCallback(hpcd);
1116 #else
1117 HAL_PCD_SuspendCallback(hpcd);
1118 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1119 }
1120
1121 return;
1122 }
1123
1124 if ((wIstr & USB_ISTR_SOF) == USB_ISTR_SOF)
1125 {
1126 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
1127
1128 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1129 hpcd->SOFCallback(hpcd);
1130 #else
1131 HAL_PCD_SOFCallback(hpcd);
1132 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1133
1134 return;
1135 }
1136
1137 if ((wIstr & USB_ISTR_ESOF) == USB_ISTR_ESOF)
1138 {
1139 /* clear ESOF flag in ISTR */
1140 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
1141
1142 return;
1143 }
1144 }
1145
1146
1147 /**
1148 * @brief Data OUT stage callback.
1149 * @param hpcd PCD handle
1150 * @param epnum endpoint number
1151 * @retval None
1152 */
HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1153 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1154 {
1155 /* Prevent unused argument(s) compilation warning */
1156 UNUSED(hpcd);
1157 UNUSED(epnum);
1158
1159 /* NOTE : This function should not be modified, when the callback is needed,
1160 the HAL_PCD_DataOutStageCallback could be implemented in the user file
1161 */
1162 }
1163
1164 /**
1165 * @brief Data IN stage callback
1166 * @param hpcd PCD handle
1167 * @param epnum endpoint number
1168 * @retval None
1169 */
HAL_PCD_DataInStageCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1170 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1171 {
1172 /* Prevent unused argument(s) compilation warning */
1173 UNUSED(hpcd);
1174 UNUSED(epnum);
1175
1176 /* NOTE : This function should not be modified, when the callback is needed,
1177 the HAL_PCD_DataInStageCallback could be implemented in the user file
1178 */
1179 }
1180 /**
1181 * @brief Setup stage callback
1182 * @param hpcd PCD handle
1183 * @retval None
1184 */
HAL_PCD_SetupStageCallback(PCD_HandleTypeDef * hpcd)1185 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
1186 {
1187 /* Prevent unused argument(s) compilation warning */
1188 UNUSED(hpcd);
1189
1190 /* NOTE : This function should not be modified, when the callback is needed,
1191 the HAL_PCD_SetupStageCallback could be implemented in the user file
1192 */
1193 }
1194
1195 /**
1196 * @brief USB Start Of Frame callback.
1197 * @param hpcd PCD handle
1198 * @retval None
1199 */
HAL_PCD_SOFCallback(PCD_HandleTypeDef * hpcd)1200 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
1201 {
1202 /* Prevent unused argument(s) compilation warning */
1203 UNUSED(hpcd);
1204
1205 /* NOTE : This function should not be modified, when the callback is needed,
1206 the HAL_PCD_SOFCallback could be implemented in the user file
1207 */
1208 }
1209
1210 /**
1211 * @brief USB Reset callback.
1212 * @param hpcd PCD handle
1213 * @retval None
1214 */
HAL_PCD_ResetCallback(PCD_HandleTypeDef * hpcd)1215 __weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
1216 {
1217 /* Prevent unused argument(s) compilation warning */
1218 UNUSED(hpcd);
1219
1220 /* NOTE : This function should not be modified, when the callback is needed,
1221 the HAL_PCD_ResetCallback could be implemented in the user file
1222 */
1223 }
1224
1225 /**
1226 * @brief Suspend event callback.
1227 * @param hpcd PCD handle
1228 * @retval None
1229 */
HAL_PCD_SuspendCallback(PCD_HandleTypeDef * hpcd)1230 __weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
1231 {
1232 /* Prevent unused argument(s) compilation warning */
1233 UNUSED(hpcd);
1234
1235 /* NOTE : This function should not be modified, when the callback is needed,
1236 the HAL_PCD_SuspendCallback could be implemented in the user file
1237 */
1238 }
1239
1240 /**
1241 * @brief Resume event callback.
1242 * @param hpcd PCD handle
1243 * @retval None
1244 */
HAL_PCD_ResumeCallback(PCD_HandleTypeDef * hpcd)1245 __weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
1246 {
1247 /* Prevent unused argument(s) compilation warning */
1248 UNUSED(hpcd);
1249
1250 /* NOTE : This function should not be modified, when the callback is needed,
1251 the HAL_PCD_ResumeCallback could be implemented in the user file
1252 */
1253 }
1254
1255 /**
1256 * @brief Incomplete ISO OUT callback.
1257 * @param hpcd PCD handle
1258 * @param epnum endpoint number
1259 * @retval None
1260 */
HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1261 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1262 {
1263 /* Prevent unused argument(s) compilation warning */
1264 UNUSED(hpcd);
1265 UNUSED(epnum);
1266
1267 /* NOTE : This function should not be modified, when the callback is needed,
1268 the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
1269 */
1270 }
1271
1272 /**
1273 * @brief Incomplete ISO IN callback.
1274 * @param hpcd PCD handle
1275 * @param epnum endpoint number
1276 * @retval None
1277 */
HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1278 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1279 {
1280 /* Prevent unused argument(s) compilation warning */
1281 UNUSED(hpcd);
1282 UNUSED(epnum);
1283
1284 /* NOTE : This function should not be modified, when the callback is needed,
1285 the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
1286 */
1287 }
1288
1289 /**
1290 * @brief Connection event callback.
1291 * @param hpcd PCD handle
1292 * @retval None
1293 */
HAL_PCD_ConnectCallback(PCD_HandleTypeDef * hpcd)1294 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
1295 {
1296 /* Prevent unused argument(s) compilation warning */
1297 UNUSED(hpcd);
1298
1299 /* NOTE : This function should not be modified, when the callback is needed,
1300 the HAL_PCD_ConnectCallback could be implemented in the user file
1301 */
1302 }
1303
1304 /**
1305 * @brief Disconnection event callback.
1306 * @param hpcd PCD handle
1307 * @retval None
1308 */
HAL_PCD_DisconnectCallback(PCD_HandleTypeDef * hpcd)1309 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
1310 {
1311 /* Prevent unused argument(s) compilation warning */
1312 UNUSED(hpcd);
1313
1314 /* NOTE : This function should not be modified, when the callback is needed,
1315 the HAL_PCD_DisconnectCallback could be implemented in the user file
1316 */
1317 }
1318
1319 /**
1320 * @}
1321 */
1322
1323 /** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
1324 * @brief management functions
1325 *
1326 @verbatim
1327 ===============================================================================
1328 ##### Peripheral Control functions #####
1329 ===============================================================================
1330 [..]
1331 This subsection provides a set of functions allowing to control the PCD data
1332 transfers.
1333
1334 @endverbatim
1335 * @{
1336 */
1337
1338 /**
1339 * @brief Connect the USB device
1340 * @param hpcd PCD handle
1341 * @retval HAL status
1342 */
HAL_PCD_DevConnect(PCD_HandleTypeDef * hpcd)1343 HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
1344 {
1345 __HAL_LOCK(hpcd);
1346 (void)USB_DevConnect(hpcd->Instance);
1347 __HAL_UNLOCK(hpcd);
1348
1349 return HAL_OK;
1350 }
1351
1352 /**
1353 * @brief Disconnect the USB device.
1354 * @param hpcd PCD handle
1355 * @retval HAL status
1356 */
HAL_PCD_DevDisconnect(PCD_HandleTypeDef * hpcd)1357 HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
1358 {
1359 __HAL_LOCK(hpcd);
1360 (void)USB_DevDisconnect(hpcd->Instance);
1361 __HAL_UNLOCK(hpcd);
1362
1363 return HAL_OK;
1364 }
1365
1366 /**
1367 * @brief Set the USB Device address.
1368 * @param hpcd PCD handle
1369 * @param address new device address
1370 * @retval HAL status
1371 */
HAL_PCD_SetAddress(PCD_HandleTypeDef * hpcd,uint8_t address)1372 HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
1373 {
1374 __HAL_LOCK(hpcd);
1375 hpcd->USB_Address = address;
1376 (void)USB_SetDevAddress(hpcd->Instance, address);
1377 __HAL_UNLOCK(hpcd);
1378
1379 return HAL_OK;
1380 }
1381 /**
1382 * @brief Open and configure an endpoint.
1383 * @param hpcd PCD handle
1384 * @param ep_addr endpoint address
1385 * @param ep_mps endpoint max packet size
1386 * @param ep_type endpoint type
1387 * @retval HAL status
1388 */
HAL_PCD_EP_Open(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint16_t ep_mps,uint8_t ep_type)1389 HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
1390 uint16_t ep_mps, uint8_t ep_type)
1391 {
1392 HAL_StatusTypeDef ret = HAL_OK;
1393 PCD_EPTypeDef *ep;
1394
1395 if ((ep_addr & 0x80U) == 0x80U)
1396 {
1397 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1398 ep->is_in = 1U;
1399 }
1400 else
1401 {
1402 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1403 ep->is_in = 0U;
1404 }
1405
1406 ep->num = ep_addr & EP_ADDR_MSK;
1407 ep->maxpacket = ep_mps;
1408 ep->type = ep_type;
1409
1410 /* Set initial data PID. */
1411 if (ep_type == EP_TYPE_BULK)
1412 {
1413 ep->data_pid_start = 0U;
1414 }
1415
1416 __HAL_LOCK(hpcd);
1417 (void)USB_ActivateEndpoint(hpcd->Instance, ep);
1418 __HAL_UNLOCK(hpcd);
1419
1420 return ret;
1421 }
1422
1423 /**
1424 * @brief Deactivate an endpoint.
1425 * @param hpcd PCD handle
1426 * @param ep_addr endpoint address
1427 * @retval HAL status
1428 */
HAL_PCD_EP_Close(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1429 HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1430 {
1431 PCD_EPTypeDef *ep;
1432
1433 if ((ep_addr & 0x80U) == 0x80U)
1434 {
1435 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1436 ep->is_in = 1U;
1437 }
1438 else
1439 {
1440 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1441 ep->is_in = 0U;
1442 }
1443 ep->num = ep_addr & EP_ADDR_MSK;
1444
1445 __HAL_LOCK(hpcd);
1446 (void)USB_DeactivateEndpoint(hpcd->Instance, ep);
1447 __HAL_UNLOCK(hpcd);
1448 return HAL_OK;
1449 }
1450
1451
1452 /**
1453 * @brief Receive an amount of data.
1454 * @param hpcd PCD handle
1455 * @param ep_addr endpoint address
1456 * @param pBuf pointer to the reception buffer
1457 * @param len amount of data to be received
1458 * @retval HAL status
1459 */
HAL_PCD_EP_Receive(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint8_t * pBuf,uint32_t len)1460 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
1461 {
1462 PCD_EPTypeDef *ep;
1463
1464 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1465
1466 /*setup and start the Xfer */
1467 ep->xfer_buff = pBuf;
1468 ep->xfer_len = len;
1469 ep->xfer_count = 0U;
1470 ep->is_in = 0U;
1471 ep->num = ep_addr & EP_ADDR_MSK;
1472
1473 (void)USB_EPStartXfer(hpcd->Instance, ep);
1474
1475 return HAL_OK;
1476 }
1477
1478 /**
1479 * @brief Get Received Data Size
1480 * @param hpcd PCD handle
1481 * @param ep_addr endpoint address
1482 * @retval Data Size
1483 */
HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1484 uint32_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1485 {
1486 return hpcd->OUT_ep[ep_addr & EP_ADDR_MSK].xfer_count;
1487 }
1488 /**
1489 * @brief Send an amount of data
1490 * @param hpcd PCD handle
1491 * @param ep_addr endpoint address
1492 * @param pBuf pointer to the transmission buffer
1493 * @param len amount of data to be sent
1494 * @retval HAL status
1495 */
HAL_PCD_EP_Transmit(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint8_t * pBuf,uint32_t len)1496 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
1497 {
1498 PCD_EPTypeDef *ep;
1499
1500 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1501
1502 /*setup and start the Xfer */
1503 ep->xfer_buff = pBuf;
1504 ep->xfer_len = len;
1505 ep->xfer_fill_db = 1U;
1506 ep->xfer_len_db = len;
1507 ep->xfer_count = 0U;
1508 ep->is_in = 1U;
1509 ep->num = ep_addr & EP_ADDR_MSK;
1510
1511 (void)USB_EPStartXfer(hpcd->Instance, ep);
1512
1513 return HAL_OK;
1514 }
1515
1516 /**
1517 * @brief Set a STALL condition over an endpoint
1518 * @param hpcd PCD handle
1519 * @param ep_addr endpoint address
1520 * @retval HAL status
1521 */
HAL_PCD_EP_SetStall(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1522 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1523 {
1524 PCD_EPTypeDef *ep;
1525
1526 if (((uint32_t)ep_addr & EP_ADDR_MSK) > hpcd->Init.dev_endpoints)
1527 {
1528 return HAL_ERROR;
1529 }
1530
1531 if ((0x80U & ep_addr) == 0x80U)
1532 {
1533 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1534 ep->is_in = 1U;
1535 }
1536 else
1537 {
1538 ep = &hpcd->OUT_ep[ep_addr];
1539 ep->is_in = 0U;
1540 }
1541
1542 ep->is_stall = 1U;
1543 ep->num = ep_addr & EP_ADDR_MSK;
1544
1545 __HAL_LOCK(hpcd);
1546
1547 (void)USB_EPSetStall(hpcd->Instance, ep);
1548
1549 __HAL_UNLOCK(hpcd);
1550
1551 return HAL_OK;
1552 }
1553
1554 /**
1555 * @brief Clear a STALL condition over in an endpoint
1556 * @param hpcd PCD handle
1557 * @param ep_addr endpoint address
1558 * @retval HAL status
1559 */
HAL_PCD_EP_ClrStall(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1560 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1561 {
1562 PCD_EPTypeDef *ep;
1563
1564 if (((uint32_t)ep_addr & 0x0FU) > hpcd->Init.dev_endpoints)
1565 {
1566 return HAL_ERROR;
1567 }
1568
1569 if ((0x80U & ep_addr) == 0x80U)
1570 {
1571 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1572 ep->is_in = 1U;
1573 }
1574 else
1575 {
1576 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1577 ep->is_in = 0U;
1578 }
1579
1580 ep->is_stall = 0U;
1581 ep->num = ep_addr & EP_ADDR_MSK;
1582
1583 __HAL_LOCK(hpcd);
1584 (void)USB_EPClearStall(hpcd->Instance, ep);
1585 __HAL_UNLOCK(hpcd);
1586
1587 return HAL_OK;
1588 }
1589
1590 /**
1591 * @brief Abort an USB EP transaction.
1592 * @param hpcd PCD handle
1593 * @param ep_addr endpoint address
1594 * @retval HAL status
1595 */
HAL_PCD_EP_Abort(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1596 HAL_StatusTypeDef HAL_PCD_EP_Abort(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1597 {
1598 HAL_StatusTypeDef ret;
1599 PCD_EPTypeDef *ep;
1600
1601 if ((0x80U & ep_addr) == 0x80U)
1602 {
1603 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1604 }
1605 else
1606 {
1607 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1608 }
1609
1610 /* Stop Xfer */
1611 ret = USB_EPStopXfer(hpcd->Instance, ep);
1612
1613 return ret;
1614 }
1615
1616 /**
1617 * @brief Flush an endpoint
1618 * @param hpcd PCD handle
1619 * @param ep_addr endpoint address
1620 * @retval HAL status
1621 */
HAL_PCD_EP_Flush(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1622 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1623 {
1624 /* Prevent unused argument(s) compilation warning */
1625 UNUSED(hpcd);
1626 UNUSED(ep_addr);
1627
1628 return HAL_OK;
1629 }
1630
1631 /**
1632 * @brief Activate remote wakeup signalling
1633 * @param hpcd PCD handle
1634 * @retval HAL status
1635 */
HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef * hpcd)1636 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
1637 {
1638 return (USB_ActivateRemoteWakeup(hpcd->Instance));
1639 }
1640
1641 /**
1642 * @brief De-activate remote wakeup signalling.
1643 * @param hpcd PCD handle
1644 * @retval HAL status
1645 */
HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef * hpcd)1646 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
1647 {
1648 return (USB_DeActivateRemoteWakeup(hpcd->Instance));
1649 }
1650
1651 /**
1652 * @}
1653 */
1654
1655 /** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
1656 * @brief Peripheral State functions
1657 *
1658 @verbatim
1659 ===============================================================================
1660 ##### Peripheral State functions #####
1661 ===============================================================================
1662 [..]
1663 This subsection permits to get in run-time the status of the peripheral
1664 and the data flow.
1665
1666 @endverbatim
1667 * @{
1668 */
1669
1670 /**
1671 * @brief Return the PCD handle state.
1672 * @param hpcd PCD handle
1673 * @retval HAL state
1674 */
HAL_PCD_GetState(PCD_HandleTypeDef * hpcd)1675 PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef *hpcd)
1676 {
1677 return hpcd->State;
1678 }
1679
1680 /**
1681 * @}
1682 */
1683
1684 /**
1685 * @}
1686 */
1687
1688 /* Private functions ---------------------------------------------------------*/
1689 /** @addtogroup PCD_Private_Functions
1690 * @{
1691 */
1692
1693
1694 /**
1695 * @brief This function handles PCD Endpoint interrupt request.
1696 * @param hpcd PCD handle
1697 * @retval HAL status
1698 */
PCD_EP_ISR_Handler(PCD_HandleTypeDef * hpcd)1699 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
1700 {
1701 PCD_EPTypeDef *ep;
1702 uint16_t count;
1703 uint16_t wIstr;
1704 uint16_t wEPVal;
1705 uint16_t TxPctSize;
1706 uint8_t epindex;
1707
1708 #if (USE_USB_DOUBLE_BUFFER != 1U)
1709 count = 0U;
1710 #endif /* USE_USB_DOUBLE_BUFFER */
1711
1712 /* stay in loop while pending interrupts */
1713 while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)
1714 {
1715 wIstr = hpcd->Instance->ISTR;
1716
1717 /* extract highest priority endpoint number */
1718 epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
1719
1720 if (epindex == 0U)
1721 {
1722 /* Decode and service control endpoint interrupt */
1723
1724 /* DIR bit = origin of the interrupt */
1725 if ((wIstr & USB_ISTR_DIR) == 0U)
1726 {
1727 /* DIR = 0 */
1728
1729 /* DIR = 0 => IN int */
1730 /* DIR = 0 implies that (EP_CTR_TX = 1) always */
1731 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1732 ep = &hpcd->IN_ep[0];
1733
1734 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
1735 ep->xfer_buff += ep->xfer_count;
1736
1737 /* TX COMPLETE */
1738 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1739 hpcd->DataInStageCallback(hpcd, 0U);
1740 #else
1741 HAL_PCD_DataInStageCallback(hpcd, 0U);
1742 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1743
1744 if ((hpcd->USB_Address > 0U) && (ep->xfer_len == 0U))
1745 {
1746 hpcd->Instance->DADDR = ((uint16_t)hpcd->USB_Address | USB_DADDR_EF);
1747 hpcd->USB_Address = 0U;
1748 }
1749 }
1750 else
1751 {
1752 /* DIR = 1 */
1753
1754 /* DIR = 1 & CTR_RX => SETUP or OUT int */
1755 /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
1756 ep = &hpcd->OUT_ep[0];
1757 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
1758
1759 if ((wEPVal & USB_EP_SETUP) != 0U)
1760 {
1761 /* Get SETUP Packet */
1762 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1763
1764 USB_ReadPMA(hpcd->Instance, (uint8_t *)hpcd->Setup,
1765 ep->pmaadress, (uint16_t)ep->xfer_count);
1766
1767 /* SETUP bit kept frozen while CTR_RX = 1 */
1768 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1769
1770 /* Process SETUP Packet*/
1771 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1772 hpcd->SetupStageCallback(hpcd);
1773 #else
1774 HAL_PCD_SetupStageCallback(hpcd);
1775 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1776 }
1777 else if ((wEPVal & USB_EP_CTR_RX) != 0U)
1778 {
1779 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1780
1781 /* Get Control Data OUT Packet */
1782 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1783
1784 if ((ep->xfer_count != 0U) && (ep->xfer_buff != 0U))
1785 {
1786 USB_ReadPMA(hpcd->Instance, ep->xfer_buff,
1787 ep->pmaadress, (uint16_t)ep->xfer_count);
1788
1789 ep->xfer_buff += ep->xfer_count;
1790
1791 /* Process Control Data OUT Packet */
1792 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1793 hpcd->DataOutStageCallback(hpcd, 0U);
1794 #else
1795 HAL_PCD_DataOutStageCallback(hpcd, 0U);
1796 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1797 }
1798
1799 wEPVal = (uint16_t)PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
1800
1801 if (((wEPVal & USB_EP_SETUP) == 0U) && ((wEPVal & USB_EP_RX_STRX) != USB_EP_RX_VALID))
1802 {
1803 PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
1804 PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
1805 }
1806 }
1807 }
1808 }
1809 else
1810 {
1811 /* Decode and service non control endpoints interrupt */
1812 /* process related endpoint register */
1813 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, epindex);
1814
1815 if ((wEPVal & USB_EP_CTR_RX) != 0U)
1816 {
1817 /* clear int flag */
1818 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
1819 ep = &hpcd->OUT_ep[epindex];
1820
1821 /* OUT Single Buffering */
1822 if (ep->doublebuffer == 0U)
1823 {
1824 count = (uint16_t)PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1825
1826 if (count != 0U)
1827 {
1828 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
1829 }
1830 }
1831 #if (USE_USB_DOUBLE_BUFFER == 1U)
1832 else
1833 {
1834 /* manage double buffer bulk out */
1835 if (ep->type == EP_TYPE_BULK)
1836 {
1837 count = HAL_PCD_EP_DB_Receive(hpcd, ep, wEPVal);
1838 }
1839 else /* manage double buffer iso out */
1840 {
1841 /* free EP OUT Buffer */
1842 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
1843
1844 if ((PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX) != 0U)
1845 {
1846 /* read from endpoint BUF0Addr buffer */
1847 count = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
1848
1849 if (count != 0U)
1850 {
1851 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
1852 }
1853 }
1854 else
1855 {
1856 /* read from endpoint BUF1Addr buffer */
1857 count = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
1858
1859 if (count != 0U)
1860 {
1861 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
1862 }
1863 }
1864 }
1865 }
1866 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
1867
1868 /* multi-packet on the NON control OUT endpoint */
1869 ep->xfer_count += count;
1870 ep->xfer_buff += count;
1871
1872 if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
1873 {
1874 /* RX COMPLETE */
1875 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1876 hpcd->DataOutStageCallback(hpcd, ep->num);
1877 #else
1878 HAL_PCD_DataOutStageCallback(hpcd, ep->num);
1879 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1880 }
1881 else
1882 {
1883 (void)USB_EPStartXfer(hpcd->Instance, ep);
1884 }
1885 }
1886
1887 if ((wEPVal & USB_EP_CTR_TX) != 0U)
1888 {
1889 ep = &hpcd->IN_ep[epindex];
1890
1891 /* clear int flag */
1892 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
1893
1894 if (ep->type == EP_TYPE_ISOC)
1895 {
1896 ep->xfer_len = 0U;
1897
1898 #if (USE_USB_DOUBLE_BUFFER == 1U)
1899 if (ep->doublebuffer != 0U)
1900 {
1901 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
1902 {
1903 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
1904 }
1905 else
1906 {
1907 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
1908 }
1909 }
1910 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
1911
1912 /* TX COMPLETE */
1913 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1914 hpcd->DataInStageCallback(hpcd, ep->num);
1915 #else
1916 HAL_PCD_DataInStageCallback(hpcd, ep->num);
1917 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1918 }
1919 else
1920 {
1921 /* Manage Single Buffer Transaction */
1922 if ((wEPVal & USB_EP_KIND) == 0U)
1923 {
1924 /* multi-packet on the NON control IN endpoint */
1925 TxPctSize = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
1926
1927 if (ep->xfer_len > TxPctSize)
1928 {
1929 ep->xfer_len -= TxPctSize;
1930 }
1931 else
1932 {
1933 ep->xfer_len = 0U;
1934 }
1935
1936 /* Zero Length Packet? */
1937 if (ep->xfer_len == 0U)
1938 {
1939 /* TX COMPLETE */
1940 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1941 hpcd->DataInStageCallback(hpcd, ep->num);
1942 #else
1943 HAL_PCD_DataInStageCallback(hpcd, ep->num);
1944 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1945 }
1946 else
1947 {
1948 /* Transfer is not yet Done */
1949 ep->xfer_buff += TxPctSize;
1950 ep->xfer_count += TxPctSize;
1951 (void)USB_EPStartXfer(hpcd->Instance, ep);
1952 }
1953 }
1954 #if (USE_USB_DOUBLE_BUFFER == 1U)
1955 /* Double Buffer bulk IN (bulk transfer Len > Ep_Mps) */
1956 else
1957 {
1958 (void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
1959 }
1960 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
1961 }
1962 }
1963 }
1964 }
1965
1966 return HAL_OK;
1967 }
1968
1969
1970 #if (USE_USB_DOUBLE_BUFFER == 1U)
1971 /**
1972 * @brief Manage double buffer bulk out transaction from ISR
1973 * @param hpcd PCD handle
1974 * @param ep current endpoint handle
1975 * @param wEPVal Last snapshot of EPRx register value taken in ISR
1976 * @retval HAL status
1977 */
HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef * hpcd,PCD_EPTypeDef * ep,uint16_t wEPVal)1978 static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd,
1979 PCD_EPTypeDef *ep, uint16_t wEPVal)
1980 {
1981 uint16_t count;
1982
1983 /* Manage Buffer0 OUT */
1984 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
1985 {
1986 /* Get count of received Data on buffer0 */
1987 count = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
1988
1989 if (ep->xfer_len >= count)
1990 {
1991 ep->xfer_len -= count;
1992 }
1993 else
1994 {
1995 ep->xfer_len = 0U;
1996 }
1997
1998 if (ep->xfer_len == 0U)
1999 {
2000 /* set NAK to OUT endpoint since double buffer is enabled */
2001 PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_NAK);
2002 }
2003
2004 /* Check if Buffer1 is in blocked state which requires to toggle */
2005 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
2006 {
2007 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
2008 }
2009
2010 if (count != 0U)
2011 {
2012 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
2013 }
2014 }
2015 /* Manage Buffer 1 DTOG_RX=0 */
2016 else
2017 {
2018 /* Get count of received data */
2019 count = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
2020
2021 if (ep->xfer_len >= count)
2022 {
2023 ep->xfer_len -= count;
2024 }
2025 else
2026 {
2027 ep->xfer_len = 0U;
2028 }
2029
2030 if (ep->xfer_len == 0U)
2031 {
2032 /* set NAK on the current endpoint */
2033 PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_NAK);
2034 }
2035
2036 /*Need to FreeUser Buffer*/
2037 if ((wEPVal & USB_EP_DTOG_TX) == 0U)
2038 {
2039 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
2040 }
2041
2042 if (count != 0U)
2043 {
2044 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
2045 }
2046 }
2047
2048 return count;
2049 }
2050
2051
2052 /**
2053 * @brief Manage double buffer bulk IN transaction from ISR
2054 * @param hpcd PCD handle
2055 * @param ep current endpoint handle
2056 * @param wEPVal Last snapshot of EPRx register value taken in ISR
2057 * @retval HAL status
2058 */
HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef * hpcd,PCD_EPTypeDef * ep,uint16_t wEPVal)2059 static HAL_StatusTypeDef HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef *hpcd,
2060 PCD_EPTypeDef *ep, uint16_t wEPVal)
2061 {
2062 uint32_t len;
2063 uint16_t TxPctSize;
2064
2065 /* Data Buffer0 ACK received */
2066 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
2067 {
2068 /* multi-packet on the NON control IN endpoint */
2069 TxPctSize = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
2070
2071 if (ep->xfer_len > TxPctSize)
2072 {
2073 ep->xfer_len -= TxPctSize;
2074 }
2075 else
2076 {
2077 ep->xfer_len = 0U;
2078 }
2079
2080 /* Transfer is completed */
2081 if (ep->xfer_len == 0U)
2082 {
2083 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2084 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2085
2086 /* TX COMPLETE */
2087 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2088 hpcd->DataInStageCallback(hpcd, ep->num);
2089 #else
2090 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2091 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2092
2093 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
2094 {
2095 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2096 }
2097 }
2098 else /* Transfer is not yet Done */
2099 {
2100 /* need to Free USB Buff */
2101 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
2102 {
2103 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2104 }
2105
2106 /* Still there is data to Fill in the next Buffer */
2107 if (ep->xfer_fill_db == 1U)
2108 {
2109 ep->xfer_buff += TxPctSize;
2110 ep->xfer_count += TxPctSize;
2111
2112 /* Calculate the len of the new buffer to fill */
2113 if (ep->xfer_len_db >= ep->maxpacket)
2114 {
2115 len = ep->maxpacket;
2116 ep->xfer_len_db -= len;
2117 }
2118 else if (ep->xfer_len_db == 0U)
2119 {
2120 len = TxPctSize;
2121 ep->xfer_fill_db = 0U;
2122 }
2123 else
2124 {
2125 ep->xfer_fill_db = 0U;
2126 len = ep->xfer_len_db;
2127 ep->xfer_len_db = 0U;
2128 }
2129
2130 /* Write remaining Data to Buffer */
2131 /* Set the Double buffer counter for pma buffer1 */
2132 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, len);
2133
2134 /* Copy user buffer to USB PMA */
2135 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, (uint16_t)len);
2136 }
2137 }
2138 }
2139 else /* Data Buffer1 ACK received */
2140 {
2141 /* multi-packet on the NON control IN endpoint */
2142 TxPctSize = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
2143
2144 if (ep->xfer_len >= TxPctSize)
2145 {
2146 ep->xfer_len -= TxPctSize;
2147 }
2148 else
2149 {
2150 ep->xfer_len = 0U;
2151 }
2152
2153 /* Transfer is completed */
2154 if (ep->xfer_len == 0U)
2155 {
2156 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2157 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2158
2159 /* TX COMPLETE */
2160 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2161 hpcd->DataInStageCallback(hpcd, ep->num);
2162 #else
2163 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2164 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2165
2166 /* need to Free USB Buff */
2167 if ((wEPVal & USB_EP_DTOG_RX) == 0U)
2168 {
2169 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2170 }
2171 }
2172 else /* Transfer is not yet Done */
2173 {
2174 /* need to Free USB Buff */
2175 if ((wEPVal & USB_EP_DTOG_RX) == 0U)
2176 {
2177 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2178 }
2179
2180 /* Still there is data to Fill in the next Buffer */
2181 if (ep->xfer_fill_db == 1U)
2182 {
2183 ep->xfer_buff += TxPctSize;
2184 ep->xfer_count += TxPctSize;
2185
2186 /* Calculate the len of the new buffer to fill */
2187 if (ep->xfer_len_db >= ep->maxpacket)
2188 {
2189 len = ep->maxpacket;
2190 ep->xfer_len_db -= len;
2191 }
2192 else if (ep->xfer_len_db == 0U)
2193 {
2194 len = TxPctSize;
2195 ep->xfer_fill_db = 0U;
2196 }
2197 else
2198 {
2199 len = ep->xfer_len_db;
2200 ep->xfer_len_db = 0U;
2201 ep->xfer_fill_db = 0;
2202 }
2203
2204 /* Set the Double buffer counter for pmabuffer1 */
2205 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, len);
2206
2207 /* Copy the user buffer to USB PMA */
2208 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, (uint16_t)len);
2209 }
2210 }
2211 }
2212
2213 /*enable endpoint IN*/
2214 PCD_SET_EP_TX_STATUS(hpcd->Instance, ep->num, USB_EP_TX_VALID);
2215
2216 return HAL_OK;
2217 }
2218 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
2219
2220
2221
2222 /**
2223 * @}
2224 */
2225 #endif /* defined (USB) */
2226 #endif /* HAL_PCD_MODULE_ENABLED */
2227
2228 /**
2229 * @}
2230 */
2231
2232 /**
2233 * @}
2234 */
2235
