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