?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #11189 from klutvott123/move-telemetry-displayport-init
[betaflight.git] / lib / main / STM32G4 / Drivers / STM32G4xx_HAL_Driver / Src / stm32g4xx_hal_pcd.c
blobd4e3d2df5583881e83c5b2a59c5ac66744a44579
1 /**
2 ******************************************************************************
3 * @file stm32g4xx_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 @verbatim
14 ==============================================================================
15 ##### How to use this driver #####
16 ==============================================================================
17 [..]
18 The PCD HAL driver can be used as follows:
19
20 (#) Declare a PCD_HandleTypeDef handle structure, for example:
21 PCD_HandleTypeDef hpcd;
22
23 (#) Fill parameters of Init structure in HCD handle
24
25 (#) Call HAL_PCD_Init() API to initialize the PCD peripheral (Core, Device core, ...)
26
27 (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
28 (##) Enable the PCD/USB Low Level interface clock using
29 (+++) __HAL_RCC_USB_CLK_ENABLE(); For USB Device only FS peripheral
30
31 (##) Initialize the related GPIO clocks
32 (##) Configure PCD pin-out
33 (##) Configure PCD NVIC interrupt
34
35 (#)Associate the Upper USB device stack to the HAL PCD Driver:
36 (##) hpcd.pData = pdev;
37
38 (#)Enable PCD transmission and reception:
39 (##) HAL_PCD_Start();
40
41 @endverbatim
42 ******************************************************************************
43 * @attention
44 *
45 * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
46 * All rights reserved.</center></h2>
47 *
48 * This software component is licensed by ST under BSD 3-Clause license,
49 * the "License"; You may not use this file except in compliance with the
50 * License. You may obtain a copy of the License at:
51 * opensource.org/licenses/BSD-3-Clause
52 *
53 ******************************************************************************
54 */
55
56 /* Includes ------------------------------------------------------------------*/
57 #include "stm32g4xx_hal.h"
58
59 /** @addtogroup STM32G4xx_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
92 /**
93 * @}
94 */
95
96 /* Exported functions --------------------------------------------------------*/
97 /** @defgroup PCD_Exported_Functions PCD Exported Functions
98 * @{
99 */
100
101 /** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
102 * @brief Initialization and Configuration functions
103 *
104 @verbatim
105 ===============================================================================
106 ##### Initialization and de-initialization functions #####
107 ===============================================================================
108 [..] This section provides functions allowing to:
109
110 @endverbatim
111 * @{
112 */
113
114 /**
115 * @brief Initializes the PCD according to the specified
116 * parameters in the PCD_InitTypeDef and initialize the associated handle.
117 * @param hpcd PCD handle
118 * @retval HAL status
119 */
120 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
121 {
122 uint8_t i;
123
124 /* Check the PCD handle allocation */
125 if (hpcd == NULL)
126 {
127 return HAL_ERROR;
128 }
129
130 /* Check the parameters */
131 assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
132
133 if (hpcd->State == HAL_PCD_STATE_RESET)
134 {
135 /* Allocate lock resource and initialize it */
136 hpcd->Lock = HAL_UNLOCKED;
137
138 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
139 hpcd->SOFCallback = HAL_PCD_SOFCallback;
140 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
141 hpcd->ResetCallback = HAL_PCD_ResetCallback;
142 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
143 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
144 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
145 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
146 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback;
147 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback;
148 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback;
149 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback;
150 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback;
151 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback;
152
153 if (hpcd->MspInitCallback == NULL)
154 {
155 hpcd->MspInitCallback = HAL_PCD_MspInit;
156 }
157
158 /* Init the low level hardware */
159 hpcd->MspInitCallback(hpcd);
160 #else
161 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
162 HAL_PCD_MspInit(hpcd);
163 #endif /* (USE_HAL_PCD_REGISTER_CALLBACKS) */
164 }
165
166 hpcd->State = HAL_PCD_STATE_BUSY;
167
168 /* Disable the Interrupts */
169 __HAL_PCD_DISABLE(hpcd);
170
171 /* Init endpoints structures */
172 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
173 {
174 /* Init ep structure */
175 hpcd->IN_ep[i].is_in = 1U;
176 hpcd->IN_ep[i].num = i;
177 hpcd->IN_ep[i].tx_fifo_num = i;
178 /* Control until ep is activated */
179 hpcd->IN_ep[i].type = EP_TYPE_CTRL;
180 hpcd->IN_ep[i].maxpacket = 0U;
181 hpcd->IN_ep[i].xfer_buff = 0U;
182 hpcd->IN_ep[i].xfer_len = 0U;
183 }
184
185 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
186 {
187 hpcd->OUT_ep[i].is_in = 0U;
188 hpcd->OUT_ep[i].num = i;
189 /* Control until ep is activated */
190 hpcd->OUT_ep[i].type = EP_TYPE_CTRL;
191 hpcd->OUT_ep[i].maxpacket = 0U;
192 hpcd->OUT_ep[i].xfer_buff = 0U;
193 hpcd->OUT_ep[i].xfer_len = 0U;
194 }
195
196 /* Init Device */
197 (void)USB_DevInit(hpcd->Instance, hpcd->Init);
198
199 hpcd->USB_Address = 0U;
200 hpcd->State = HAL_PCD_STATE_READY;
201
202 /* Activate LPM */
203 if (hpcd->Init.lpm_enable == 1U)
204 {
205 (void)HAL_PCDEx_ActivateLPM(hpcd);
206 }
207
208 return HAL_OK;
209 }
210
211 /**
212 * @brief DeInitializes the PCD peripheral.
213 * @param hpcd PCD handle
214 * @retval HAL status
215 */
216 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
217 {
218 /* Check the PCD handle allocation */
219 if (hpcd == NULL)
220 {
221 return HAL_ERROR;
222 }
223
224 hpcd->State = HAL_PCD_STATE_BUSY;
225
226 /* Stop Device */
227 (void)HAL_PCD_Stop(hpcd);
228
229 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
230 if (hpcd->MspDeInitCallback == NULL)
231 {
232 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit; /* Legacy weak MspDeInit */
233 }
234
235 /* DeInit the low level hardware */
236 hpcd->MspDeInitCallback(hpcd);
237 #else
238 /* DeInit the low level hardware: CLOCK, NVIC.*/
239 HAL_PCD_MspDeInit(hpcd);
240 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
241
242 hpcd->State = HAL_PCD_STATE_RESET;
243
244 return HAL_OK;
245 }
246
247 /**
248 * @brief Initializes the PCD MSP.
249 * @param hpcd PCD handle
250 * @retval None
251 */
252 __weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
253 {
254 /* Prevent unused argument(s) compilation warning */
255 UNUSED(hpcd);
256
257 /* NOTE : This function should not be modified, when the callback is needed,
258 the HAL_PCD_MspInit could be implemented in the user file
259 */
260 }
261
262 /**
263 * @brief DeInitializes PCD MSP.
264 * @param hpcd PCD handle
265 * @retval None
266 */
267 __weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
268 {
269 /* Prevent unused argument(s) compilation warning */
270 UNUSED(hpcd);
271
272 /* NOTE : This function should not be modified, when the callback is needed,
273 the HAL_PCD_MspDeInit could be implemented in the user file
274 */
275 }
276
277 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
278 /**
279 * @brief Register a User USB PCD Callback
280 * To be used instead of the weak predefined callback
281 * @param hpcd USB PCD handle
282 * @param CallbackID ID of the callback to be registered
283 * This parameter can be one of the following values:
284 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
285 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
286 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
287 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
288 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
289 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
290 * @arg @ref HAL_PCD_DISCONNECT_CB_ID OTG PCD Disconnect callback ID
291 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
292 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
293 * @param pCallback pointer to the Callback function
294 * @retval HAL status
295 */
296 HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd, HAL_PCD_CallbackIDTypeDef CallbackID, pPCD_CallbackTypeDef pCallback)
297 {
298 HAL_StatusTypeDef status = HAL_OK;
299
300 if (pCallback == NULL)
301 {
302 /* Update the error code */
303 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
304 return HAL_ERROR;
305 }
306 /* Process locked */
307 __HAL_LOCK(hpcd);
308
309 if (hpcd->State == HAL_PCD_STATE_READY)
310 {
311 switch (CallbackID)
312 {
313 case HAL_PCD_SOF_CB_ID :
314 hpcd->SOFCallback = pCallback;
315 break;
316
317 case HAL_PCD_SETUPSTAGE_CB_ID :
318 hpcd->SetupStageCallback = pCallback;
319 break;
320
321 case HAL_PCD_RESET_CB_ID :
322 hpcd->ResetCallback = pCallback;
323 break;
324
325 case HAL_PCD_SUSPEND_CB_ID :
326 hpcd->SuspendCallback = pCallback;
327 break;
328
329 case HAL_PCD_RESUME_CB_ID :
330 hpcd->ResumeCallback = pCallback;
331 break;
332
333 case HAL_PCD_CONNECT_CB_ID :
334 hpcd->ConnectCallback = pCallback;
335 break;
336
337 case HAL_PCD_DISCONNECT_CB_ID :
338 hpcd->DisconnectCallback = pCallback;
339 break;
340
341 case HAL_PCD_MSPINIT_CB_ID :
342 hpcd->MspInitCallback = pCallback;
343 break;
344
345 case HAL_PCD_MSPDEINIT_CB_ID :
346 hpcd->MspDeInitCallback = pCallback;
347 break;
348
349 default :
350 /* Update the error code */
351 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
352 /* Return error status */
353 status = HAL_ERROR;
354 break;
355 }
356 }
357 else if (hpcd->State == HAL_PCD_STATE_RESET)
358 {
359 switch (CallbackID)
360 {
361 case HAL_PCD_MSPINIT_CB_ID :
362 hpcd->MspInitCallback = pCallback;
363 break;
364
365 case HAL_PCD_MSPDEINIT_CB_ID :
366 hpcd->MspDeInitCallback = pCallback;
367 break;
368
369 default :
370 /* Update the error code */
371 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
372 /* Return error status */
373 status = HAL_ERROR;
374 break;
375 }
376 }
377 else
378 {
379 /* Update the error code */
380 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
381 /* Return error status */
382 status = HAL_ERROR;
383 }
384
385 /* Release Lock */
386 __HAL_UNLOCK(hpcd);
387 return status;
388 }
389
390 /**
391 * @brief Unregister an USB PCD Callback
392 * USB PCD callabck is redirected to the weak predefined callback
393 * @param hpcd USB PCD handle
394 * @param CallbackID ID of the callback to be unregistered
395 * This parameter can be one of the following values:
396 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
397 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
398 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
399 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
400 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
401 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
402 * @arg @ref HAL_PCD_DISCONNECT_CB_ID OTG PCD Disconnect callback ID
403 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
404 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
405 * @retval HAL status
406 */
407 HAL_StatusTypeDef HAL_PCD_UnRegisterCallback(PCD_HandleTypeDef *hpcd, HAL_PCD_CallbackIDTypeDef CallbackID)
408 {
409 HAL_StatusTypeDef status = HAL_OK;
410
411 /* Process locked */
412 __HAL_LOCK(hpcd);
413
414 /* Setup Legacy weak Callbacks */
415 if (hpcd->State == HAL_PCD_STATE_READY)
416 {
417 switch (CallbackID)
418 {
419 case HAL_PCD_SOF_CB_ID :
420 hpcd->SOFCallback = HAL_PCD_SOFCallback;
421 break;
422
423 case HAL_PCD_SETUPSTAGE_CB_ID :
424 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
425 break;
426
427 case HAL_PCD_RESET_CB_ID :
428 hpcd->ResetCallback = HAL_PCD_ResetCallback;
429 break;
430
431 case HAL_PCD_SUSPEND_CB_ID :
432 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
433 break;
434
435 case HAL_PCD_RESUME_CB_ID :
436 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
437 break;
438
439 case HAL_PCD_CONNECT_CB_ID :
440 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
441 break;
442
443 case HAL_PCD_DISCONNECT_CB_ID :
444 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
445 break;
446
447 case HAL_PCD_MSPINIT_CB_ID :
448 hpcd->MspInitCallback = HAL_PCD_MspInit;
449 break;
450
451 case HAL_PCD_MSPDEINIT_CB_ID :
452 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
453 break;
454
455 default :
456 /* Update the error code */
457 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
458
459 /* Return error status */
460 status = HAL_ERROR;
461 break;
462 }
463 }
464 else if (hpcd->State == HAL_PCD_STATE_RESET)
465 {
466 switch (CallbackID)
467 {
468 case HAL_PCD_MSPINIT_CB_ID :
469 hpcd->MspInitCallback = HAL_PCD_MspInit;
470 break;
471
472 case HAL_PCD_MSPDEINIT_CB_ID :
473 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
474 break;
475
476 default :
477 /* Update the error code */
478 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
479
480 /* Return error status */
481 status = HAL_ERROR;
482 break;
483 }
484 }
485 else
486 {
487 /* Update the error code */
488 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
489
490 /* Return error status */
491 status = HAL_ERROR;
492 }
493
494 /* Release Lock */
495 __HAL_UNLOCK(hpcd);
496 return status;
497 }
498
499 /**
500 * @brief Register USB PCD Data OUT Stage Callback
501 * To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback
502 * @param hpcd PCD handle
503 * @param pCallback pointer to the USB PCD Data OUT Stage Callback function
504 * @retval HAL status
505 */
506 HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd, pPCD_DataOutStageCallbackTypeDef pCallback)
507 {
508 HAL_StatusTypeDef status = HAL_OK;
509
510 if (pCallback == NULL)
511 {
512 /* Update the error code */
513 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
514
515 return HAL_ERROR;
516 }
517
518 /* Process locked */
519 __HAL_LOCK(hpcd);
520
521 if (hpcd->State == HAL_PCD_STATE_READY)
522 {
523 hpcd->DataOutStageCallback = pCallback;
524 }
525 else
526 {
527 /* Update the error code */
528 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
529
530 /* Return error status */
531 status = HAL_ERROR;
532 }
533
534 /* Release Lock */
535 __HAL_UNLOCK(hpcd);
536
537 return status;
538 }
539
540 /**
541 * @brief UnRegister the USB PCD Data OUT Stage Callback
542 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataOutStageCallback() predefined callback
543 * @param hpcd PCD handle
544 * @retval HAL status
545 */
546 HAL_StatusTypeDef HAL_PCD_UnRegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd)
547 {
548 HAL_StatusTypeDef status = HAL_OK;
549
550 /* Process locked */
551 __HAL_LOCK(hpcd);
552
553 if (hpcd->State == HAL_PCD_STATE_READY)
554 {
555 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback; /* Legacy weak DataOutStageCallback */
556 }
557 else
558 {
559 /* Update the error code */
560 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
561
562 /* Return error status */
563 status = HAL_ERROR;
564 }
565
566 /* Release Lock */
567 __HAL_UNLOCK(hpcd);
568
569 return status;
570 }
571
572 /**
573 * @brief Register USB PCD Data IN Stage Callback
574 * To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback
575 * @param hpcd PCD handle
576 * @param pCallback pointer to the USB PCD Data IN Stage Callback function
577 * @retval HAL status
578 */
579 HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd, pPCD_DataInStageCallbackTypeDef pCallback)
580 {
581 HAL_StatusTypeDef status = HAL_OK;
582
583 if (pCallback == NULL)
584 {
585 /* Update the error code */
586 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
587
588 return HAL_ERROR;
589 }
590
591 /* Process locked */
592 __HAL_LOCK(hpcd);
593
594 if (hpcd->State == HAL_PCD_STATE_READY)
595 {
596 hpcd->DataInStageCallback = pCallback;
597 }
598 else
599 {
600 /* Update the error code */
601 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
602
603 /* Return error status */
604 status = HAL_ERROR;
605 }
606
607 /* Release Lock */
608 __HAL_UNLOCK(hpcd);
609
610 return status;
611 }
612
613 /**
614 * @brief UnRegister the USB PCD Data IN Stage Callback
615 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataInStageCallback() predefined callback
616 * @param hpcd PCD handle
617 * @retval HAL status
618 */
619 HAL_StatusTypeDef HAL_PCD_UnRegisterDataInStageCallback(PCD_HandleTypeDef *hpcd)
620 {
621 HAL_StatusTypeDef status = HAL_OK;
622
623 /* Process locked */
624 __HAL_LOCK(hpcd);
625
626 if (hpcd->State == HAL_PCD_STATE_READY)
627 {
628 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback; /* Legacy weak DataInStageCallback */
629 }
630 else
631 {
632 /* Update the error code */
633 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
634
635 /* Return error status */
636 status = HAL_ERROR;
637 }
638
639 /* Release Lock */
640 __HAL_UNLOCK(hpcd);
641
642 return status;
643 }
644
645 /**
646 * @brief Register USB PCD Iso OUT incomplete Callback
647 * To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
648 * @param hpcd PCD handle
649 * @param pCallback pointer to the USB PCD Iso OUT incomplete Callback function
650 * @retval HAL status
651 */
652 HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd, pPCD_IsoOutIncpltCallbackTypeDef pCallback)
653 {
654 HAL_StatusTypeDef status = HAL_OK;
655
656 if (pCallback == NULL)
657 {
658 /* Update the error code */
659 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
660
661 return HAL_ERROR;
662 }
663
664 /* Process locked */
665 __HAL_LOCK(hpcd);
666
667 if (hpcd->State == HAL_PCD_STATE_READY)
668 {
669 hpcd->ISOOUTIncompleteCallback = pCallback;
670 }
671 else
672 {
673 /* Update the error code */
674 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
675
676 /* Return error status */
677 status = HAL_ERROR;
678 }
679
680 /* Release Lock */
681 __HAL_UNLOCK(hpcd);
682
683 return status;
684 }
685
686 /**
687 * @brief UnRegister the USB PCD Iso OUT incomplete Callback
688 * USB PCD Iso OUT incomplete Callback is redirected to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
689 * @param hpcd PCD handle
690 * @retval HAL status
691 */
692 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)
693 {
694 HAL_StatusTypeDef status = HAL_OK;
695
696 /* Process locked */
697 __HAL_LOCK(hpcd);
698
699 if (hpcd->State == HAL_PCD_STATE_READY)
700 {
701 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback; /* Legacy weak ISOOUTIncompleteCallback */
702 }
703 else
704 {
705 /* Update the error code */
706 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
707
708 /* Return error status */
709 status = HAL_ERROR;
710 }
711
712 /* Release Lock */
713 __HAL_UNLOCK(hpcd);
714
715 return status;
716 }
717
718 /**
719 * @brief Register USB PCD Iso IN incomplete Callback
720 * To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
721 * @param hpcd PCD handle
722 * @param pCallback pointer to the USB PCD Iso IN incomplete Callback function
723 * @retval HAL status
724 */
725 HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd, pPCD_IsoInIncpltCallbackTypeDef pCallback)
726 {
727 HAL_StatusTypeDef status = HAL_OK;
728
729 if (pCallback == NULL)
730 {
731 /* Update the error code */
732 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
733
734 return HAL_ERROR;
735 }
736
737 /* Process locked */
738 __HAL_LOCK(hpcd);
739
740 if (hpcd->State == HAL_PCD_STATE_READY)
741 {
742 hpcd->ISOINIncompleteCallback = pCallback;
743 }
744 else
745 {
746 /* Update the error code */
747 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
748
749 /* Return error status */
750 status = HAL_ERROR;
751 }
752
753 /* Release Lock */
754 __HAL_UNLOCK(hpcd);
755
756 return status;
757 }
758
759 /**
760 * @brief UnRegister the USB PCD Iso IN incomplete Callback
761 * USB PCD Iso IN incomplete Callback is redirected to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
762 * @param hpcd PCD handle
763 * @retval HAL status
764 */
765 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)
766 {
767 HAL_StatusTypeDef status = HAL_OK;
768
769 /* Process locked */
770 __HAL_LOCK(hpcd);
771
772 if (hpcd->State == HAL_PCD_STATE_READY)
773 {
774 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback; /* Legacy weak ISOINIncompleteCallback */
775 }
776 else
777 {
778 /* Update the error code */
779 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
780
781 /* Return error status */
782 status = HAL_ERROR;
783 }
784
785 /* Release Lock */
786 __HAL_UNLOCK(hpcd);
787
788 return status;
789 }
790
791 /**
792 * @brief Register USB PCD BCD Callback
793 * To be used instead of the weak HAL_PCDEx_BCD_Callback() predefined callback
794 * @param hpcd PCD handle
795 * @param pCallback pointer to the USB PCD BCD Callback function
796 * @retval HAL status
797 */
798 HAL_StatusTypeDef HAL_PCD_RegisterBcdCallback(PCD_HandleTypeDef *hpcd, pPCD_BcdCallbackTypeDef pCallback)
799 {
800 HAL_StatusTypeDef status = HAL_OK;
801
802 if (pCallback == NULL)
803 {
804 /* Update the error code */
805 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
806
807 return HAL_ERROR;
808 }
809
810 /* Process locked */
811 __HAL_LOCK(hpcd);
812
813 if (hpcd->State == HAL_PCD_STATE_READY)
814 {
815 hpcd->BCDCallback = pCallback;
816 }
817 else
818 {
819 /* Update the error code */
820 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
821
822 /* Return error status */
823 status = HAL_ERROR;
824 }
825
826 /* Release Lock */
827 __HAL_UNLOCK(hpcd);
828
829 return status;
830 }
831
832 /**
833 * @brief UnRegister the USB PCD BCD Callback
834 * USB BCD Callback is redirected to the weak HAL_PCDEx_BCD_Callback() predefined callback
835 * @param hpcd PCD handle
836 * @retval HAL status
837 */
838 HAL_StatusTypeDef HAL_PCD_UnRegisterBcdCallback(PCD_HandleTypeDef *hpcd)
839 {
840 HAL_StatusTypeDef status = HAL_OK;
841
842 /* Process locked */
843 __HAL_LOCK(hpcd);
844
845 if (hpcd->State == HAL_PCD_STATE_READY)
846 {
847 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback; /* Legacy weak HAL_PCDEx_BCD_Callback */
848 }
849 else
850 {
851 /* Update the error code */
852 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
853
854 /* Return error status */
855 status = HAL_ERROR;
856 }
857
858 /* Release Lock */
859 __HAL_UNLOCK(hpcd);
860
861 return status;
862 }
863
864 /**
865 * @brief Register USB PCD LPM Callback
866 * To be used instead of the weak HAL_PCDEx_LPM_Callback() predefined callback
867 * @param hpcd PCD handle
868 * @param pCallback pointer to the USB PCD LPM Callback function
869 * @retval HAL status
870 */
871 HAL_StatusTypeDef HAL_PCD_RegisterLpmCallback(PCD_HandleTypeDef *hpcd, pPCD_LpmCallbackTypeDef pCallback)
872 {
873 HAL_StatusTypeDef status = HAL_OK;
874
875 if (pCallback == NULL)
876 {
877 /* Update the error code */
878 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
879
880 return HAL_ERROR;
881 }
882
883 /* Process locked */
884 __HAL_LOCK(hpcd);
885
886 if (hpcd->State == HAL_PCD_STATE_READY)
887 {
888 hpcd->LPMCallback = pCallback;
889 }
890 else
891 {
892 /* Update the error code */
893 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
894
895 /* Return error status */
896 status = HAL_ERROR;
897 }
898
899 /* Release Lock */
900 __HAL_UNLOCK(hpcd);
901
902 return status;
903 }
904
905 /**
906 * @brief UnRegister the USB PCD LPM Callback
907 * USB LPM Callback is redirected to the weak HAL_PCDEx_LPM_Callback() predefined callback
908 * @param hpcd PCD handle
909 * @retval HAL status
910 */
911 HAL_StatusTypeDef HAL_PCD_UnRegisterLpmCallback(PCD_HandleTypeDef *hpcd)
912 {
913 HAL_StatusTypeDef status = HAL_OK;
914
915 /* Process locked */
916 __HAL_LOCK(hpcd);
917
918 if (hpcd->State == HAL_PCD_STATE_READY)
919 {
920 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback; /* Legacy weak HAL_PCDEx_LPM_Callback */
921 }
922 else
923 {
924 /* Update the error code */
925 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
926
927 /* Return error status */
928 status = HAL_ERROR;
929 }
930
931 /* Release Lock */
932 __HAL_UNLOCK(hpcd);
933
934 return status;
935 }
936 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
937
938 /**
939 * @}
940 */
941
942 /** @defgroup PCD_Exported_Functions_Group2 Input and Output operation functions
943 * @brief Data transfers functions
944 *
945 @verbatim
946 ===============================================================================
947 ##### IO operation functions #####
948 ===============================================================================
949 [..]
950 This subsection provides a set of functions allowing to manage the PCD data
951 transfers.
952
953 @endverbatim
954 * @{
955 */
956
957 /**
958 * @brief Start the USB device
959 * @param hpcd PCD handle
960 * @retval HAL status
961 */
962 HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
963 {
964 __HAL_LOCK(hpcd);
965 (void)USB_DevConnect(hpcd->Instance);
966 __HAL_PCD_ENABLE(hpcd);
967 __HAL_UNLOCK(hpcd);
968 return HAL_OK;
969 }
970
971 /**
972 * @brief Stop the USB device.
973 * @param hpcd PCD handle
974 * @retval HAL status
975 */
976 HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
977 {
978 __HAL_LOCK(hpcd);
979 __HAL_PCD_DISABLE(hpcd);
980
981 (void)USB_StopDevice(hpcd->Instance);
982
983 __HAL_UNLOCK(hpcd);
984
985 return HAL_OK;
986 }
987
988
989 /**
990 * @brief This function handles PCD interrupt request.
991 * @param hpcd PCD handle
992 * @retval HAL status
993 */
994 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
995 {
996 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_CTR))
997 {
998 /* servicing of the endpoint correct transfer interrupt */
999 /* clear of the CTR flag into the sub */
1000 (void)PCD_EP_ISR_Handler(hpcd);
1001 }
1002
1003 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_RESET))
1004 {
1005 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
1006
1007 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1008 hpcd->ResetCallback(hpcd);
1009 #else
1010 HAL_PCD_ResetCallback(hpcd);
1011 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1012
1013 (void)HAL_PCD_SetAddress(hpcd, 0U);
1014 }
1015
1016 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_PMAOVR))
1017 {
1018 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
1019 }
1020
1021 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_ERR))
1022 {
1023 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
1024 }
1025
1026 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_WKUP))
1027 {
1028 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_LPMODE);
1029 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_FSUSP);
1030
1031 if (hpcd->LPM_State == LPM_L1)
1032 {
1033 hpcd->LPM_State = LPM_L0;
1034 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1035 hpcd->LPMCallback(hpcd, PCD_LPM_L0_ACTIVE);
1036 #else
1037 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
1038 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1039 }
1040
1041 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1042 hpcd->ResumeCallback(hpcd);
1043 #else
1044 HAL_PCD_ResumeCallback(hpcd);
1045 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1046
1047 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
1048 }
1049
1050 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_SUSP))
1051 {
1052 /* Force low-power mode in the macrocell */
1053 hpcd->Instance->CNTR |= USB_CNTR_FSUSP;
1054
1055 /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
1056 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);
1057
1058 hpcd->Instance->CNTR |= USB_CNTR_LPMODE;
1059
1060 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_WKUP) == 0U)
1061 {
1062 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1063 hpcd->SuspendCallback(hpcd);
1064 #else
1065 HAL_PCD_SuspendCallback(hpcd);
1066 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1067 }
1068 }
1069
1070 /* Handle LPM Interrupt */
1071 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_L1REQ))
1072 {
1073 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_L1REQ);
1074 if (hpcd->LPM_State == LPM_L0)
1075 {
1076 /* Force suspend and low-power mode before going to L1 state*/
1077 hpcd->Instance->CNTR |= USB_CNTR_LPMODE;
1078 hpcd->Instance->CNTR |= USB_CNTR_FSUSP;
1079
1080 hpcd->LPM_State = LPM_L1;
1081 hpcd->BESL = ((uint32_t)hpcd->Instance->LPMCSR & USB_LPMCSR_BESL) >> 2;
1082 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1083 hpcd->LPMCallback(hpcd, PCD_LPM_L1_ACTIVE);
1084 #else
1085 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
1086 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1087 }
1088 else
1089 {
1090 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1091 hpcd->SuspendCallback(hpcd);
1092 #else
1093 HAL_PCD_SuspendCallback(hpcd);
1094 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1095 }
1096 }
1097
1098 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_SOF))
1099 {
1100 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
1101
1102 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1103 hpcd->SOFCallback(hpcd);
1104 #else
1105 HAL_PCD_SOFCallback(hpcd);
1106 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1107 }
1108
1109 if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_ESOF))
1110 {
1111 /* clear ESOF flag in ISTR */
1112 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
1113 }
1114 }
1115
1116
1117 /**
1118 * @brief Data OUT stage callback.
1119 * @param hpcd PCD handle
1120 * @param epnum endpoint number
1121 * @retval None
1122 */
1123 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1124 {
1125 /* Prevent unused argument(s) compilation warning */
1126 UNUSED(hpcd);
1127 UNUSED(epnum);
1128
1129 /* NOTE : This function should not be modified, when the callback is needed,
1130 the HAL_PCD_DataOutStageCallback could be implemented in the user file
1131 */
1132 }
1133
1134 /**
1135 * @brief Data IN stage callback
1136 * @param hpcd PCD handle
1137 * @param epnum endpoint number
1138 * @retval None
1139 */
1140 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1141 {
1142 /* Prevent unused argument(s) compilation warning */
1143 UNUSED(hpcd);
1144 UNUSED(epnum);
1145
1146 /* NOTE : This function should not be modified, when the callback is needed,
1147 the HAL_PCD_DataInStageCallback could be implemented in the user file
1148 */
1149 }
1150 /**
1151 * @brief Setup stage callback
1152 * @param hpcd PCD handle
1153 * @retval None
1154 */
1155 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
1156 {
1157 /* Prevent unused argument(s) compilation warning */
1158 UNUSED(hpcd);
1159
1160 /* NOTE : This function should not be modified, when the callback is needed,
1161 the HAL_PCD_SetupStageCallback could be implemented in the user file
1162 */
1163 }
1164
1165 /**
1166 * @brief USB Start Of Frame callback.
1167 * @param hpcd PCD handle
1168 * @retval None
1169 */
1170 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
1171 {
1172 /* Prevent unused argument(s) compilation warning */
1173 UNUSED(hpcd);
1174
1175 /* NOTE : This function should not be modified, when the callback is needed,
1176 the HAL_PCD_SOFCallback could be implemented in the user file
1177 */
1178 }
1179
1180 /**
1181 * @brief USB Reset callback.
1182 * @param hpcd PCD handle
1183 * @retval None
1184 */
1185 __weak void HAL_PCD_ResetCallback(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_ResetCallback could be implemented in the user file
1192 */
1193 }
1194
1195 /**
1196 * @brief Suspend event callback.
1197 * @param hpcd PCD handle
1198 * @retval None
1199 */
1200 __weak void HAL_PCD_SuspendCallback(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_SuspendCallback could be implemented in the user file
1207 */
1208 }
1209
1210 /**
1211 * @brief Resume event callback.
1212 * @param hpcd PCD handle
1213 * @retval None
1214 */
1215 __weak void HAL_PCD_ResumeCallback(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_ResumeCallback could be implemented in the user file
1222 */
1223 }
1224
1225 /**
1226 * @brief Incomplete ISO OUT callback.
1227 * @param hpcd PCD handle
1228 * @param epnum endpoint number
1229 * @retval None
1230 */
1231 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1232 {
1233 /* Prevent unused argument(s) compilation warning */
1234 UNUSED(hpcd);
1235 UNUSED(epnum);
1236
1237 /* NOTE : This function should not be modified, when the callback is needed,
1238 the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
1239 */
1240 }
1241
1242 /**
1243 * @brief Incomplete ISO IN callback.
1244 * @param hpcd PCD handle
1245 * @param epnum endpoint number
1246 * @retval None
1247 */
1248 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1249 {
1250 /* Prevent unused argument(s) compilation warning */
1251 UNUSED(hpcd);
1252 UNUSED(epnum);
1253
1254 /* NOTE : This function should not be modified, when the callback is needed,
1255 the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
1256 */
1257 }
1258
1259 /**
1260 * @brief Connection event callback.
1261 * @param hpcd PCD handle
1262 * @retval None
1263 */
1264 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
1265 {
1266 /* Prevent unused argument(s) compilation warning */
1267 UNUSED(hpcd);
1268
1269 /* NOTE : This function should not be modified, when the callback is needed,
1270 the HAL_PCD_ConnectCallback could be implemented in the user file
1271 */
1272 }
1273
1274 /**
1275 * @brief Disconnection event callback.
1276 * @param hpcd PCD handle
1277 * @retval None
1278 */
1279 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
1280 {
1281 /* Prevent unused argument(s) compilation warning */
1282 UNUSED(hpcd);
1283
1284 /* NOTE : This function should not be modified, when the callback is needed,
1285 the HAL_PCD_DisconnectCallback could be implemented in the user file
1286 */
1287 }
1288
1289 /**
1290 * @}
1291 */
1292
1293 /** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
1294 * @brief management functions
1295 *
1296 @verbatim
1297 ===============================================================================
1298 ##### Peripheral Control functions #####
1299 ===============================================================================
1300 [..]
1301 This subsection provides a set of functions allowing to control the PCD data
1302 transfers.
1303
1304 @endverbatim
1305 * @{
1306 */
1307
1308 /**
1309 * @brief Connect the USB device
1310 * @param hpcd PCD handle
1311 * @retval HAL status
1312 */
1313 HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
1314 {
1315 __HAL_LOCK(hpcd);
1316 (void)USB_DevConnect(hpcd->Instance);
1317 __HAL_UNLOCK(hpcd);
1318 return HAL_OK;
1319 }
1320
1321 /**
1322 * @brief Disconnect the USB device.
1323 * @param hpcd PCD handle
1324 * @retval HAL status
1325 */
1326 HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
1327 {
1328 __HAL_LOCK(hpcd);
1329 (void)USB_DevDisconnect(hpcd->Instance);
1330 __HAL_UNLOCK(hpcd);
1331 return HAL_OK;
1332 }
1333
1334 /**
1335 * @brief Set the USB Device address.
1336 * @param hpcd PCD handle
1337 * @param address new device address
1338 * @retval HAL status
1339 */
1340 HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
1341 {
1342 __HAL_LOCK(hpcd);
1343 hpcd->USB_Address = address;
1344 (void)USB_SetDevAddress(hpcd->Instance, address);
1345 __HAL_UNLOCK(hpcd);
1346 return HAL_OK;
1347 }
1348 /**
1349 * @brief Open and configure an endpoint.
1350 * @param hpcd PCD handle
1351 * @param ep_addr endpoint address
1352 * @param ep_mps endpoint max packet size
1353 * @param ep_type endpoint type
1354 * @retval HAL status
1355 */
1356 HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint16_t ep_mps, uint8_t ep_type)
1357 {
1358 HAL_StatusTypeDef ret = HAL_OK;
1359 PCD_EPTypeDef *ep;
1360
1361 if ((ep_addr & 0x80U) == 0x80U)
1362 {
1363 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1364 ep->is_in = 1U;
1365 }
1366 else
1367 {
1368 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1369 ep->is_in = 0U;
1370 }
1371
1372 ep->num = ep_addr & EP_ADDR_MSK;
1373 ep->maxpacket = ep_mps;
1374 ep->type = ep_type;
1375
1376 if (ep->is_in != 0U)
1377 {
1378 /* Assign a Tx FIFO */
1379 ep->tx_fifo_num = ep->num;
1380 }
1381 /* Set initial data PID. */
1382 if (ep_type == EP_TYPE_BULK)
1383 {
1384 ep->data_pid_start = 0U;
1385 }
1386
1387 __HAL_LOCK(hpcd);
1388 (void)USB_ActivateEndpoint(hpcd->Instance, ep);
1389 __HAL_UNLOCK(hpcd);
1390
1391 return ret;
1392 }
1393
1394 /**
1395 * @brief Deactivate an endpoint.
1396 * @param hpcd PCD handle
1397 * @param ep_addr endpoint address
1398 * @retval HAL status
1399 */
1400 HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1401 {
1402 PCD_EPTypeDef *ep;
1403
1404 if ((ep_addr & 0x80U) == 0x80U)
1405 {
1406 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1407 ep->is_in = 1U;
1408 }
1409 else
1410 {
1411 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1412 ep->is_in = 0U;
1413 }
1414 ep->num = ep_addr & EP_ADDR_MSK;
1415
1416 __HAL_LOCK(hpcd);
1417 (void)USB_DeactivateEndpoint(hpcd->Instance, ep);
1418 __HAL_UNLOCK(hpcd);
1419 return HAL_OK;
1420 }
1421
1422
1423 /**
1424 * @brief Receive an amount of data.
1425 * @param hpcd PCD handle
1426 * @param ep_addr endpoint address
1427 * @param pBuf pointer to the reception buffer
1428 * @param len amount of data to be received
1429 * @retval HAL status
1430 */
1431 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
1432 {
1433 PCD_EPTypeDef *ep;
1434
1435 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1436
1437 /*setup and start the Xfer */
1438 ep->xfer_buff = pBuf;
1439 ep->xfer_len = len;
1440 ep->xfer_count = 0U;
1441 ep->is_in = 0U;
1442 ep->num = ep_addr & EP_ADDR_MSK;
1443
1444 if ((ep_addr & EP_ADDR_MSK) == 0U)
1445 {
1446 (void)USB_EP0StartXfer(hpcd->Instance, ep);
1447 }
1448 else
1449 {
1450 (void)USB_EPStartXfer(hpcd->Instance, ep);
1451 }
1452
1453 return HAL_OK;
1454 }
1455
1456 /**
1457 * @brief Get Received Data Size
1458 * @param hpcd PCD handle
1459 * @param ep_addr endpoint address
1460 * @retval Data Size
1461 */
1462 uint32_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1463 {
1464 return hpcd->OUT_ep[ep_addr & EP_ADDR_MSK].xfer_count;
1465 }
1466 /**
1467 * @brief Send an amount of data
1468 * @param hpcd PCD handle
1469 * @param ep_addr endpoint address
1470 * @param pBuf pointer to the transmission buffer
1471 * @param len amount of data to be sent
1472 * @retval HAL status
1473 */
1474 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
1475 {
1476 PCD_EPTypeDef *ep;
1477
1478 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1479
1480 /*setup and start the Xfer */
1481 ep->xfer_buff = pBuf;
1482 ep->xfer_len = len;
1483 ep->xfer_count = 0U;
1484 ep->is_in = 1U;
1485 ep->num = ep_addr & EP_ADDR_MSK;
1486
1487 if ((ep_addr & EP_ADDR_MSK) == 0U)
1488 {
1489 (void)USB_EP0StartXfer(hpcd->Instance, ep);
1490 }
1491 else
1492 {
1493 (void)USB_EPStartXfer(hpcd->Instance, ep);
1494 }
1495
1496 return HAL_OK;
1497 }
1498
1499 /**
1500 * @brief Set a STALL condition over an endpoint
1501 * @param hpcd PCD handle
1502 * @param ep_addr endpoint address
1503 * @retval HAL status
1504 */
1505 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1506 {
1507 PCD_EPTypeDef *ep;
1508
1509 if (((uint32_t)ep_addr & EP_ADDR_MSK) > hpcd->Init.dev_endpoints)
1510 {
1511 return HAL_ERROR;
1512 }
1513
1514 if ((0x80U & ep_addr) == 0x80U)
1515 {
1516 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1517 ep->is_in = 1U;
1518 }
1519 else
1520 {
1521 ep = &hpcd->OUT_ep[ep_addr];
1522 ep->is_in = 0U;
1523 }
1524
1525 ep->is_stall = 1U;
1526 ep->num = ep_addr & EP_ADDR_MSK;
1527
1528 __HAL_LOCK(hpcd);
1529
1530 (void)USB_EPSetStall(hpcd->Instance, ep);
1531 if ((ep_addr & EP_ADDR_MSK) == 0U)
1532 {
1533 (void)USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
1534 }
1535 __HAL_UNLOCK(hpcd);
1536
1537 return HAL_OK;
1538 }
1539
1540 /**
1541 * @brief Clear a STALL condition over in an endpoint
1542 * @param hpcd PCD handle
1543 * @param ep_addr endpoint address
1544 * @retval HAL status
1545 */
1546 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1547 {
1548 PCD_EPTypeDef *ep;
1549
1550 if (((uint32_t)ep_addr & 0x0FU) > hpcd->Init.dev_endpoints)
1551 {
1552 return HAL_ERROR;
1553 }
1554
1555 if ((0x80U & ep_addr) == 0x80U)
1556 {
1557 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1558 ep->is_in = 1U;
1559 }
1560 else
1561 {
1562 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1563 ep->is_in = 0U;
1564 }
1565
1566 ep->is_stall = 0U;
1567 ep->num = ep_addr & EP_ADDR_MSK;
1568
1569 __HAL_LOCK(hpcd);
1570 (void)USB_EPClearStall(hpcd->Instance, ep);
1571 __HAL_UNLOCK(hpcd);
1572
1573 return HAL_OK;
1574 }
1575
1576 /**
1577 * @brief Flush an endpoint
1578 * @param hpcd PCD handle
1579 * @param ep_addr endpoint address
1580 * @retval HAL status
1581 */
1582 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1583 {
1584 /* Prevent unused argument(s) compilation warning */
1585 UNUSED(hpcd);
1586 UNUSED(ep_addr);
1587
1588 return HAL_OK;
1589 }
1590
1591 /**
1592 * @brief Activate remote wakeup signalling
1593 * @param hpcd PCD handle
1594 * @retval HAL status
1595 */
1596 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
1597 {
1598 return (USB_ActivateRemoteWakeup(hpcd->Instance));
1599 }
1600
1601 /**
1602 * @brief De-activate remote wakeup signalling.
1603 * @param hpcd PCD handle
1604 * @retval HAL status
1605 */
1606 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
1607 {
1608 return (USB_DeActivateRemoteWakeup(hpcd->Instance));
1609 }
1610
1611 /**
1612 * @}
1613 */
1614
1615 /** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
1616 * @brief Peripheral State functions
1617 *
1618 @verbatim
1619 ===============================================================================
1620 ##### Peripheral State functions #####
1621 ===============================================================================
1622 [..]
1623 This subsection permits to get in run-time the status of the peripheral
1624 and the data flow.
1625
1626 @endverbatim
1627 * @{
1628 */
1629
1630 /**
1631 * @brief Return the PCD handle state.
1632 * @param hpcd PCD handle
1633 * @retval HAL state
1634 */
1635 PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef *hpcd)
1636 {
1637 return hpcd->State;
1638 }
1639
1640 /**
1641 * @}
1642 */
1643
1644 /**
1645 * @}
1646 */
1647
1648 /* Private functions ---------------------------------------------------------*/
1649 /** @addtogroup PCD_Private_Functions
1650 * @{
1651 */
1652
1653
1654 /**
1655 * @brief This function handles PCD Endpoint interrupt request.
1656 * @param hpcd PCD handle
1657 * @retval HAL status
1658 */
1659 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
1660 {
1661 PCD_EPTypeDef *ep;
1662 uint16_t count;
1663 uint16_t wIstr;
1664 uint16_t wEPVal;
1665 uint8_t epindex;
1666
1667 /* stay in loop while pending interrupts */
1668 while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)
1669 {
1670 wIstr = hpcd->Instance->ISTR;
1671 /* extract highest priority endpoint number */
1672 epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
1673
1674 if (epindex == 0U)
1675 {
1676 /* Decode and service control endpoint interrupt */
1677
1678 /* DIR bit = origin of the interrupt */
1679 if ((wIstr & USB_ISTR_DIR) == 0U)
1680 {
1681 /* DIR = 0 */
1682
1683 /* DIR = 0 => IN int */
1684 /* DIR = 0 implies that (EP_CTR_TX = 1) always */
1685 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1686 ep = &hpcd->IN_ep[0];
1687
1688 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
1689 ep->xfer_buff += ep->xfer_count;
1690
1691 /* TX COMPLETE */
1692 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1693 hpcd->DataInStageCallback(hpcd, 0U);
1694 #else
1695 HAL_PCD_DataInStageCallback(hpcd, 0U);
1696 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1697
1698 if ((hpcd->USB_Address > 0U) && (ep->xfer_len == 0U))
1699 {
1700 hpcd->Instance->DADDR = ((uint16_t)hpcd->USB_Address | USB_DADDR_EF);
1701 hpcd->USB_Address = 0U;
1702 }
1703 }
1704 else
1705 {
1706 /* DIR = 1 */
1707
1708 /* DIR = 1 & CTR_RX => SETUP or OUT int */
1709 /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
1710 ep = &hpcd->OUT_ep[0];
1711 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
1712
1713 if ((wEPVal & USB_EP_SETUP) != 0U)
1714 {
1715 /* Get SETUP Packet*/
1716 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1717 USB_ReadPMA(hpcd->Instance, (uint8_t *)hpcd->Setup, ep->pmaadress, (uint16_t)ep->xfer_count);
1718 /* SETUP bit kept frozen while CTR_RX = 1*/
1719 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1720
1721 /* Process SETUP Packet*/
1722 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1723 hpcd->SetupStageCallback(hpcd);
1724 #else
1725 HAL_PCD_SetupStageCallback(hpcd);
1726 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1727 }
1728
1729 else if ((wEPVal & USB_EP_CTR_RX) != 0U)
1730 {
1731 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
1732 /* Get Control Data OUT Packet*/
1733 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1734
1735 if (ep->xfer_count != 0U)
1736 {
1737 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, (uint16_t)ep->xfer_count);
1738 ep->xfer_buff += ep->xfer_count;
1739 }
1740
1741 /* Process Control Data OUT Packet*/
1742 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1743 hpcd->DataOutStageCallback(hpcd, 0U);
1744 #else
1745 HAL_PCD_DataOutStageCallback(hpcd, 0U);
1746 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1747
1748 PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
1749 PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
1750 }
1751 }
1752 }
1753 else
1754 {
1755 /* Decode and service non control endpoints interrupt */
1756
1757 /* process related endpoint register */
1758 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, epindex);
1759 if ((wEPVal & USB_EP_CTR_RX) != 0U)
1760 {
1761 /* clear int flag */
1762 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
1763 ep = &hpcd->OUT_ep[epindex];
1764
1765 /* OUT double Buffering*/
1766 if (ep->doublebuffer == 0U)
1767 {
1768 count = (uint16_t)PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
1769 if (count != 0U)
1770 {
1771 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
1772 }
1773 }
1774 else
1775 {
1776 if ((PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX) != 0U)
1777 {
1778 /*read from endpoint BUF0Addr buffer*/
1779 count = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
1780 if (count != 0U)
1781 {
1782 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
1783 }
1784 }
1785 else
1786 {
1787 /*read from endpoint BUF1Addr buffer*/
1788 count = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
1789 if (count != 0U)
1790 {
1791 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
1792 }
1793 }
1794 /* free EP OUT Buffer */
1795 PCD_FreeUserBuffer(hpcd->Instance, ep->num, 0U);
1796 }
1797 /*multi-packet on the NON control OUT endpoint*/
1798 ep->xfer_count += count;
1799 ep->xfer_buff += count;
1800
1801 if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
1802 {
1803 /* RX COMPLETE */
1804 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1805 hpcd->DataOutStageCallback(hpcd, ep->num);
1806 #else
1807 HAL_PCD_DataOutStageCallback(hpcd, ep->num);
1808 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1809 }
1810 else
1811 {
1812 (void)HAL_PCD_EP_Receive(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
1813 }
1814
1815 } /* if((wEPVal & EP_CTR_RX) */
1816
1817 if ((wEPVal & USB_EP_CTR_TX) != 0U)
1818 {
1819 ep = &hpcd->IN_ep[epindex];
1820
1821 /* clear int flag */
1822 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
1823
1824 /*multi-packet on the NON control IN endpoint*/
1825 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
1826 ep->xfer_buff += ep->xfer_count;
1827
1828 /* Zero Length Packet? */
1829 if (ep->xfer_len == 0U)
1830 {
1831 /* TX COMPLETE */
1832 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1833 hpcd->DataInStageCallback(hpcd, ep->num);
1834 #else
1835 HAL_PCD_DataInStageCallback(hpcd, ep->num);
1836 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1837 }
1838 else
1839 {
1840 (void)HAL_PCD_EP_Transmit(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
1841 }
1842 }
1843 }
1844 }
1845 return HAL_OK;
1846 }
1847
1848
1849 /**
1850 * @}
1851 */
1852 #endif /* defined (USB) */
1853 #endif /* HAL_PCD_MODULE_ENABLED */
1854
1855 /**
1856 * @}
1857 */
1858
1859 /**
1860 * @}
1861 */
1862
1863 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/