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