1 /**
2 ******************************************************************************
3 * @file stm32l4xx_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_CLK_ENABLE(); For USB Device FS peripheral
41 (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
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 "stm32l4xx_hal.h"
59
60 /** @addtogroup STM32L4xx_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) || defined (USB_OTG_FS)
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)
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) */
95
96 #if defined (USB)
97 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
98 #if (USE_USB_DOUBLE_BUFFER == 1U)
99 static HAL_StatusTypeDef HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
100 static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
101 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
102 #endif /* defined (USB) */
103 /**
104 * @}
105 */
106
107 /* Exported functions --------------------------------------------------------*/
108 /** @defgroup PCD_Exported_Functions PCD Exported Functions
109 * @{
110 */
111
112 /** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
113 * @brief Initialization and Configuration functions
114 *
115 @verbatim
116 ===============================================================================
117 ##### Initialization and de-initialization functions #####
118 ===============================================================================
119 [..] This section provides functions allowing to:
120
121 @endverbatim
122 * @{
123 */
124
125 /**
126 * @brief Initializes the PCD according to the specified
127 * parameters in the PCD_InitTypeDef and initialize the associated handle.
128 * @param hpcd PCD handle
129 * @retval HAL status
130 */
HAL_PCD_Init(PCD_HandleTypeDef * hpcd)131 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
132 {
133 uint8_t i;
134
135 /* Check the PCD handle allocation */
136 if (hpcd == NULL)
137 {
138 return HAL_ERROR;
139 }
140
141 /* Check the parameters */
142 assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
143
144 if (hpcd->State == HAL_PCD_STATE_RESET)
145 {
146 /* Allocate lock resource and initialize it */
147 hpcd->Lock = HAL_UNLOCKED;
148
149 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
150 hpcd->SOFCallback = HAL_PCD_SOFCallback;
151 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
152 hpcd->ResetCallback = HAL_PCD_ResetCallback;
153 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
154 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
155 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
156 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
157 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback;
158 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback;
159 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback;
160 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback;
161 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback;
162 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback;
163
164 if (hpcd->MspInitCallback == NULL)
165 {
166 hpcd->MspInitCallback = HAL_PCD_MspInit;
167 }
168
169 /* Init the low level hardware */
170 hpcd->MspInitCallback(hpcd);
171 #else
172 /* Init the low level hardware : GPIO, CLOCK, NVIC... */
173 HAL_PCD_MspInit(hpcd);
174 #endif /* (USE_HAL_PCD_REGISTER_CALLBACKS) */
175 }
176
177 hpcd->State = HAL_PCD_STATE_BUSY;
178
179 /* Disable DMA mode for FS instance */
180 hpcd->Init.dma_enable = 0U;
181
182 /* Disable the Interrupts */
183 __HAL_PCD_DISABLE(hpcd);
184
185 /*Init the Core (common init.) */
186 if (USB_CoreInit(hpcd->Instance, hpcd->Init) != HAL_OK)
187 {
188 hpcd->State = HAL_PCD_STATE_ERROR;
189 return HAL_ERROR;
190 }
191
192 /* Force Device Mode */
193 if (USB_SetCurrentMode(hpcd->Instance, USB_DEVICE_MODE) != HAL_OK)
194 {
195 hpcd->State = HAL_PCD_STATE_ERROR;
196 return HAL_ERROR;
197 }
198
199 /* Init endpoints structures */
200 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
201 {
202 /* Init ep structure */
203 hpcd->IN_ep[i].is_in = 1U;
204 hpcd->IN_ep[i].num = i;
205 #if defined (USB_OTG_FS)
206 hpcd->IN_ep[i].tx_fifo_num = i;
207 #endif /* defined (USB_OTG_FS) */
208 /* Control until ep is activated */
209 hpcd->IN_ep[i].type = EP_TYPE_CTRL;
210 hpcd->IN_ep[i].maxpacket = 0U;
211 hpcd->IN_ep[i].xfer_buff = 0U;
212 hpcd->IN_ep[i].xfer_len = 0U;
213 }
214
215 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
216 {
217 hpcd->OUT_ep[i].is_in = 0U;
218 hpcd->OUT_ep[i].num = i;
219 /* Control until ep is activated */
220 hpcd->OUT_ep[i].type = EP_TYPE_CTRL;
221 hpcd->OUT_ep[i].maxpacket = 0U;
222 hpcd->OUT_ep[i].xfer_buff = 0U;
223 hpcd->OUT_ep[i].xfer_len = 0U;
224 }
225
226 /* Init Device */
227 if (USB_DevInit(hpcd->Instance, hpcd->Init) != HAL_OK)
228 {
229 hpcd->State = HAL_PCD_STATE_ERROR;
230 return HAL_ERROR;
231 }
232
233 hpcd->USB_Address = 0U;
234 hpcd->State = HAL_PCD_STATE_READY;
235
236 /* Activate LPM */
237 if (hpcd->Init.lpm_enable == 1U)
238 {
239 (void)HAL_PCDEx_ActivateLPM(hpcd);
240 }
241
242 (void)USB_DevDisconnect(hpcd->Instance);
243
244 return HAL_OK;
245 }
246
247 /**
248 * @brief DeInitializes the PCD peripheral.
249 * @param hpcd PCD handle
250 * @retval HAL status
251 */
HAL_PCD_DeInit(PCD_HandleTypeDef * hpcd)252 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
253 {
254 /* Check the PCD handle allocation */
255 if (hpcd == NULL)
256 {
257 return HAL_ERROR;
258 }
259
260 hpcd->State = HAL_PCD_STATE_BUSY;
261
262 /* Stop Device */
263 if (USB_StopDevice(hpcd->Instance) != HAL_OK)
264 {
265 return HAL_ERROR;
266 }
267
268 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
269 if (hpcd->MspDeInitCallback == NULL)
270 {
271 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit; /* Legacy weak MspDeInit */
272 }
273
274 /* DeInit the low level hardware */
275 hpcd->MspDeInitCallback(hpcd);
276 #else
277 /* DeInit the low level hardware: CLOCK, NVIC.*/
278 HAL_PCD_MspDeInit(hpcd);
279 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
280
281 hpcd->State = HAL_PCD_STATE_RESET;
282
283 return HAL_OK;
284 }
285
286 /**
287 * @brief Initializes the PCD MSP.
288 * @param hpcd PCD handle
289 * @retval None
290 */
HAL_PCD_MspInit(PCD_HandleTypeDef * hpcd)291 __weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
292 {
293 /* Prevent unused argument(s) compilation warning */
294 UNUSED(hpcd);
295
296 /* NOTE : This function should not be modified, when the callback is needed,
297 the HAL_PCD_MspInit could be implemented in the user file
298 */
299 }
300
301 /**
302 * @brief DeInitializes PCD MSP.
303 * @param hpcd PCD handle
304 * @retval None
305 */
HAL_PCD_MspDeInit(PCD_HandleTypeDef * hpcd)306 __weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
307 {
308 /* Prevent unused argument(s) compilation warning */
309 UNUSED(hpcd);
310
311 /* NOTE : This function should not be modified, when the callback is needed,
312 the HAL_PCD_MspDeInit could be implemented in the user file
313 */
314 }
315
316 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
317 /**
318 * @brief Register a User USB PCD Callback
319 * To be used instead of the weak predefined callback
320 * @param hpcd USB PCD handle
321 * @param CallbackID ID of the callback to be registered
322 * This parameter can be one of the following values:
323 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
324 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
325 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
326 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
327 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
328 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
329 * @arg @ref HAL_PCD_DISCONNECT_CB_ID USB PCD Disconnect callback ID
330 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
331 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
332 * @param pCallback pointer to the Callback function
333 * @retval HAL status
334 */
HAL_PCD_RegisterCallback(PCD_HandleTypeDef * hpcd,HAL_PCD_CallbackIDTypeDef CallbackID,pPCD_CallbackTypeDef pCallback)335 HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd,
336 HAL_PCD_CallbackIDTypeDef CallbackID,
337 pPCD_CallbackTypeDef pCallback)
338 {
339 HAL_StatusTypeDef status = HAL_OK;
340
341 if (pCallback == NULL)
342 {
343 /* Update the error code */
344 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
345 return HAL_ERROR;
346 }
347 /* Process locked */
348 __HAL_LOCK(hpcd);
349
350 if (hpcd->State == HAL_PCD_STATE_READY)
351 {
352 switch (CallbackID)
353 {
354 case HAL_PCD_SOF_CB_ID :
355 hpcd->SOFCallback = pCallback;
356 break;
357
358 case HAL_PCD_SETUPSTAGE_CB_ID :
359 hpcd->SetupStageCallback = pCallback;
360 break;
361
362 case HAL_PCD_RESET_CB_ID :
363 hpcd->ResetCallback = pCallback;
364 break;
365
366 case HAL_PCD_SUSPEND_CB_ID :
367 hpcd->SuspendCallback = pCallback;
368 break;
369
370 case HAL_PCD_RESUME_CB_ID :
371 hpcd->ResumeCallback = pCallback;
372 break;
373
374 case HAL_PCD_CONNECT_CB_ID :
375 hpcd->ConnectCallback = pCallback;
376 break;
377
378 case HAL_PCD_DISCONNECT_CB_ID :
379 hpcd->DisconnectCallback = pCallback;
380 break;
381
382 case HAL_PCD_MSPINIT_CB_ID :
383 hpcd->MspInitCallback = pCallback;
384 break;
385
386 case HAL_PCD_MSPDEINIT_CB_ID :
387 hpcd->MspDeInitCallback = pCallback;
388 break;
389
390 default :
391 /* Update the error code */
392 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
393 /* Return error status */
394 status = HAL_ERROR;
395 break;
396 }
397 }
398 else if (hpcd->State == HAL_PCD_STATE_RESET)
399 {
400 switch (CallbackID)
401 {
402 case HAL_PCD_MSPINIT_CB_ID :
403 hpcd->MspInitCallback = pCallback;
404 break;
405
406 case HAL_PCD_MSPDEINIT_CB_ID :
407 hpcd->MspDeInitCallback = pCallback;
408 break;
409
410 default :
411 /* Update the error code */
412 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
413 /* Return error status */
414 status = HAL_ERROR;
415 break;
416 }
417 }
418 else
419 {
420 /* Update the error code */
421 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
422 /* Return error status */
423 status = HAL_ERROR;
424 }
425
426 /* Release Lock */
427 __HAL_UNLOCK(hpcd);
428 return status;
429 }
430
431 /**
432 * @brief Unregister an USB PCD Callback
433 * USB PCD callback is redirected to the weak predefined callback
434 * @param hpcd USB PCD handle
435 * @param CallbackID ID of the callback to be unregistered
436 * This parameter can be one of the following values:
437 * @arg @ref HAL_PCD_SOF_CB_ID USB PCD SOF callback ID
438 * @arg @ref HAL_PCD_SETUPSTAGE_CB_ID USB PCD Setup callback ID
439 * @arg @ref HAL_PCD_RESET_CB_ID USB PCD Reset callback ID
440 * @arg @ref HAL_PCD_SUSPEND_CB_ID USB PCD Suspend callback ID
441 * @arg @ref HAL_PCD_RESUME_CB_ID USB PCD Resume callback ID
442 * @arg @ref HAL_PCD_CONNECT_CB_ID USB PCD Connect callback ID
443 * @arg @ref HAL_PCD_DISCONNECT_CB_ID USB PCD Disconnect callback ID
444 * @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
445 * @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
446 * @retval HAL status
447 */
HAL_PCD_UnRegisterCallback(PCD_HandleTypeDef * hpcd,HAL_PCD_CallbackIDTypeDef CallbackID)448 HAL_StatusTypeDef HAL_PCD_UnRegisterCallback(PCD_HandleTypeDef *hpcd, HAL_PCD_CallbackIDTypeDef CallbackID)
449 {
450 HAL_StatusTypeDef status = HAL_OK;
451
452 /* Process locked */
453 __HAL_LOCK(hpcd);
454
455 /* Setup Legacy weak Callbacks */
456 if (hpcd->State == HAL_PCD_STATE_READY)
457 {
458 switch (CallbackID)
459 {
460 case HAL_PCD_SOF_CB_ID :
461 hpcd->SOFCallback = HAL_PCD_SOFCallback;
462 break;
463
464 case HAL_PCD_SETUPSTAGE_CB_ID :
465 hpcd->SetupStageCallback = HAL_PCD_SetupStageCallback;
466 break;
467
468 case HAL_PCD_RESET_CB_ID :
469 hpcd->ResetCallback = HAL_PCD_ResetCallback;
470 break;
471
472 case HAL_PCD_SUSPEND_CB_ID :
473 hpcd->SuspendCallback = HAL_PCD_SuspendCallback;
474 break;
475
476 case HAL_PCD_RESUME_CB_ID :
477 hpcd->ResumeCallback = HAL_PCD_ResumeCallback;
478 break;
479
480 case HAL_PCD_CONNECT_CB_ID :
481 hpcd->ConnectCallback = HAL_PCD_ConnectCallback;
482 break;
483
484 case HAL_PCD_DISCONNECT_CB_ID :
485 hpcd->DisconnectCallback = HAL_PCD_DisconnectCallback;
486 break;
487
488 case HAL_PCD_MSPINIT_CB_ID :
489 hpcd->MspInitCallback = HAL_PCD_MspInit;
490 break;
491
492 case HAL_PCD_MSPDEINIT_CB_ID :
493 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
494 break;
495
496 default :
497 /* Update the error code */
498 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
499
500 /* Return error status */
501 status = HAL_ERROR;
502 break;
503 }
504 }
505 else if (hpcd->State == HAL_PCD_STATE_RESET)
506 {
507 switch (CallbackID)
508 {
509 case HAL_PCD_MSPINIT_CB_ID :
510 hpcd->MspInitCallback = HAL_PCD_MspInit;
511 break;
512
513 case HAL_PCD_MSPDEINIT_CB_ID :
514 hpcd->MspDeInitCallback = HAL_PCD_MspDeInit;
515 break;
516
517 default :
518 /* Update the error code */
519 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
520
521 /* Return error status */
522 status = HAL_ERROR;
523 break;
524 }
525 }
526 else
527 {
528 /* Update the error code */
529 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
530
531 /* Return error status */
532 status = HAL_ERROR;
533 }
534
535 /* Release Lock */
536 __HAL_UNLOCK(hpcd);
537 return status;
538 }
539
540 /**
541 * @brief Register USB PCD Data OUT Stage Callback
542 * To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback
543 * @param hpcd PCD handle
544 * @param pCallback pointer to the USB PCD Data OUT Stage Callback function
545 * @retval HAL status
546 */
HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef * hpcd,pPCD_DataOutStageCallbackTypeDef pCallback)547 HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd,
548 pPCD_DataOutStageCallbackTypeDef pCallback)
549 {
550 HAL_StatusTypeDef status = HAL_OK;
551
552 if (pCallback == NULL)
553 {
554 /* Update the error code */
555 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
556
557 return HAL_ERROR;
558 }
559
560 /* Process locked */
561 __HAL_LOCK(hpcd);
562
563 if (hpcd->State == HAL_PCD_STATE_READY)
564 {
565 hpcd->DataOutStageCallback = pCallback;
566 }
567 else
568 {
569 /* Update the error code */
570 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
571
572 /* Return error status */
573 status = HAL_ERROR;
574 }
575
576 /* Release Lock */
577 __HAL_UNLOCK(hpcd);
578
579 return status;
580 }
581
582 /**
583 * @brief Unregister the USB PCD Data OUT Stage Callback
584 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataOutStageCallback() predefined callback
585 * @param hpcd PCD handle
586 * @retval HAL status
587 */
HAL_PCD_UnRegisterDataOutStageCallback(PCD_HandleTypeDef * hpcd)588 HAL_StatusTypeDef HAL_PCD_UnRegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd)
589 {
590 HAL_StatusTypeDef status = HAL_OK;
591
592 /* Process locked */
593 __HAL_LOCK(hpcd);
594
595 if (hpcd->State == HAL_PCD_STATE_READY)
596 {
597 hpcd->DataOutStageCallback = HAL_PCD_DataOutStageCallback; /* Legacy weak DataOutStageCallback */
598 }
599 else
600 {
601 /* Update the error code */
602 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
603
604 /* Return error status */
605 status = HAL_ERROR;
606 }
607
608 /* Release Lock */
609 __HAL_UNLOCK(hpcd);
610
611 return status;
612 }
613
614 /**
615 * @brief Register USB PCD Data IN Stage Callback
616 * To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback
617 * @param hpcd PCD handle
618 * @param pCallback pointer to the USB PCD Data IN Stage Callback function
619 * @retval HAL status
620 */
HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef * hpcd,pPCD_DataInStageCallbackTypeDef pCallback)621 HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd,
622 pPCD_DataInStageCallbackTypeDef pCallback)
623 {
624 HAL_StatusTypeDef status = HAL_OK;
625
626 if (pCallback == NULL)
627 {
628 /* Update the error code */
629 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
630
631 return HAL_ERROR;
632 }
633
634 /* Process locked */
635 __HAL_LOCK(hpcd);
636
637 if (hpcd->State == HAL_PCD_STATE_READY)
638 {
639 hpcd->DataInStageCallback = pCallback;
640 }
641 else
642 {
643 /* Update the error code */
644 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
645
646 /* Return error status */
647 status = HAL_ERROR;
648 }
649
650 /* Release Lock */
651 __HAL_UNLOCK(hpcd);
652
653 return status;
654 }
655
656 /**
657 * @brief Unregister the USB PCD Data IN Stage Callback
658 * USB PCD Data OUT Stage Callback is redirected to the weak HAL_PCD_DataInStageCallback() predefined callback
659 * @param hpcd PCD handle
660 * @retval HAL status
661 */
HAL_PCD_UnRegisterDataInStageCallback(PCD_HandleTypeDef * hpcd)662 HAL_StatusTypeDef HAL_PCD_UnRegisterDataInStageCallback(PCD_HandleTypeDef *hpcd)
663 {
664 HAL_StatusTypeDef status = HAL_OK;
665
666 /* Process locked */
667 __HAL_LOCK(hpcd);
668
669 if (hpcd->State == HAL_PCD_STATE_READY)
670 {
671 hpcd->DataInStageCallback = HAL_PCD_DataInStageCallback; /* Legacy weak DataInStageCallback */
672 }
673 else
674 {
675 /* Update the error code */
676 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
677
678 /* Return error status */
679 status = HAL_ERROR;
680 }
681
682 /* Release Lock */
683 __HAL_UNLOCK(hpcd);
684
685 return status;
686 }
687
688 /**
689 * @brief Register USB PCD Iso OUT incomplete Callback
690 * To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
691 * @param hpcd PCD handle
692 * @param pCallback pointer to the USB PCD Iso OUT incomplete Callback function
693 * @retval HAL status
694 */
HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef * hpcd,pPCD_IsoOutIncpltCallbackTypeDef pCallback)695 HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd,
696 pPCD_IsoOutIncpltCallbackTypeDef pCallback)
697 {
698 HAL_StatusTypeDef status = HAL_OK;
699
700 if (pCallback == NULL)
701 {
702 /* Update the error code */
703 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
704
705 return HAL_ERROR;
706 }
707
708 /* Process locked */
709 __HAL_LOCK(hpcd);
710
711 if (hpcd->State == HAL_PCD_STATE_READY)
712 {
713 hpcd->ISOOUTIncompleteCallback = pCallback;
714 }
715 else
716 {
717 /* Update the error code */
718 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
719
720 /* Return error status */
721 status = HAL_ERROR;
722 }
723
724 /* Release Lock */
725 __HAL_UNLOCK(hpcd);
726
727 return status;
728 }
729
730 /**
731 * @brief Unregister the USB PCD Iso OUT incomplete Callback
732 * USB PCD Iso OUT incomplete Callback is redirected
733 * to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
734 * @param hpcd PCD handle
735 * @retval HAL status
736 */
HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef * hpcd)737 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)
738 {
739 HAL_StatusTypeDef status = HAL_OK;
740
741 /* Process locked */
742 __HAL_LOCK(hpcd);
743
744 if (hpcd->State == HAL_PCD_STATE_READY)
745 {
746 hpcd->ISOOUTIncompleteCallback = HAL_PCD_ISOOUTIncompleteCallback; /* Legacy weak ISOOUTIncompleteCallback */
747 }
748 else
749 {
750 /* Update the error code */
751 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
752
753 /* Return error status */
754 status = HAL_ERROR;
755 }
756
757 /* Release Lock */
758 __HAL_UNLOCK(hpcd);
759
760 return status;
761 }
762
763 /**
764 * @brief Register USB PCD Iso IN incomplete Callback
765 * To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
766 * @param hpcd PCD handle
767 * @param pCallback pointer to the USB PCD Iso IN incomplete Callback function
768 * @retval HAL status
769 */
HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef * hpcd,pPCD_IsoInIncpltCallbackTypeDef pCallback)770 HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd,
771 pPCD_IsoInIncpltCallbackTypeDef pCallback)
772 {
773 HAL_StatusTypeDef status = HAL_OK;
774
775 if (pCallback == NULL)
776 {
777 /* Update the error code */
778 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
779
780 return HAL_ERROR;
781 }
782
783 /* Process locked */
784 __HAL_LOCK(hpcd);
785
786 if (hpcd->State == HAL_PCD_STATE_READY)
787 {
788 hpcd->ISOINIncompleteCallback = pCallback;
789 }
790 else
791 {
792 /* Update the error code */
793 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
794
795 /* Return error status */
796 status = HAL_ERROR;
797 }
798
799 /* Release Lock */
800 __HAL_UNLOCK(hpcd);
801
802 return status;
803 }
804
805 /**
806 * @brief Unregister the USB PCD Iso IN incomplete Callback
807 * USB PCD Iso IN incomplete Callback is redirected
808 * to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
809 * @param hpcd PCD handle
810 * @retval HAL status
811 */
HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef * hpcd)812 HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)
813 {
814 HAL_StatusTypeDef status = HAL_OK;
815
816 /* Process locked */
817 __HAL_LOCK(hpcd);
818
819 if (hpcd->State == HAL_PCD_STATE_READY)
820 {
821 hpcd->ISOINIncompleteCallback = HAL_PCD_ISOINIncompleteCallback; /* Legacy weak ISOINIncompleteCallback */
822 }
823 else
824 {
825 /* Update the error code */
826 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
827
828 /* Return error status */
829 status = HAL_ERROR;
830 }
831
832 /* Release Lock */
833 __HAL_UNLOCK(hpcd);
834
835 return status;
836 }
837
838 /**
839 * @brief Register USB PCD BCD Callback
840 * To be used instead of the weak HAL_PCDEx_BCD_Callback() predefined callback
841 * @param hpcd PCD handle
842 * @param pCallback pointer to the USB PCD BCD Callback function
843 * @retval HAL status
844 */
HAL_PCD_RegisterBcdCallback(PCD_HandleTypeDef * hpcd,pPCD_BcdCallbackTypeDef pCallback)845 HAL_StatusTypeDef HAL_PCD_RegisterBcdCallback(PCD_HandleTypeDef *hpcd, pPCD_BcdCallbackTypeDef pCallback)
846 {
847 HAL_StatusTypeDef status = HAL_OK;
848
849 if (pCallback == NULL)
850 {
851 /* Update the error code */
852 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
853
854 return HAL_ERROR;
855 }
856
857 /* Process locked */
858 __HAL_LOCK(hpcd);
859
860 if (hpcd->State == HAL_PCD_STATE_READY)
861 {
862 hpcd->BCDCallback = pCallback;
863 }
864 else
865 {
866 /* Update the error code */
867 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
868
869 /* Return error status */
870 status = HAL_ERROR;
871 }
872
873 /* Release Lock */
874 __HAL_UNLOCK(hpcd);
875
876 return status;
877 }
878
879 /**
880 * @brief Unregister the USB PCD BCD Callback
881 * USB BCD Callback is redirected to the weak HAL_PCDEx_BCD_Callback() predefined callback
882 * @param hpcd PCD handle
883 * @retval HAL status
884 */
HAL_PCD_UnRegisterBcdCallback(PCD_HandleTypeDef * hpcd)885 HAL_StatusTypeDef HAL_PCD_UnRegisterBcdCallback(PCD_HandleTypeDef *hpcd)
886 {
887 HAL_StatusTypeDef status = HAL_OK;
888
889 /* Process locked */
890 __HAL_LOCK(hpcd);
891
892 if (hpcd->State == HAL_PCD_STATE_READY)
893 {
894 hpcd->BCDCallback = HAL_PCDEx_BCD_Callback; /* Legacy weak HAL_PCDEx_BCD_Callback */
895 }
896 else
897 {
898 /* Update the error code */
899 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
900
901 /* Return error status */
902 status = HAL_ERROR;
903 }
904
905 /* Release Lock */
906 __HAL_UNLOCK(hpcd);
907
908 return status;
909 }
910
911 /**
912 * @brief Register USB PCD LPM Callback
913 * To be used instead of the weak HAL_PCDEx_LPM_Callback() predefined callback
914 * @param hpcd PCD handle
915 * @param pCallback pointer to the USB PCD LPM Callback function
916 * @retval HAL status
917 */
HAL_PCD_RegisterLpmCallback(PCD_HandleTypeDef * hpcd,pPCD_LpmCallbackTypeDef pCallback)918 HAL_StatusTypeDef HAL_PCD_RegisterLpmCallback(PCD_HandleTypeDef *hpcd, pPCD_LpmCallbackTypeDef pCallback)
919 {
920 HAL_StatusTypeDef status = HAL_OK;
921
922 if (pCallback == NULL)
923 {
924 /* Update the error code */
925 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
926
927 return HAL_ERROR;
928 }
929
930 /* Process locked */
931 __HAL_LOCK(hpcd);
932
933 if (hpcd->State == HAL_PCD_STATE_READY)
934 {
935 hpcd->LPMCallback = pCallback;
936 }
937 else
938 {
939 /* Update the error code */
940 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
941
942 /* Return error status */
943 status = HAL_ERROR;
944 }
945
946 /* Release Lock */
947 __HAL_UNLOCK(hpcd);
948
949 return status;
950 }
951
952 /**
953 * @brief Unregister the USB PCD LPM Callback
954 * USB LPM Callback is redirected to the weak HAL_PCDEx_LPM_Callback() predefined callback
955 * @param hpcd PCD handle
956 * @retval HAL status
957 */
HAL_PCD_UnRegisterLpmCallback(PCD_HandleTypeDef * hpcd)958 HAL_StatusTypeDef HAL_PCD_UnRegisterLpmCallback(PCD_HandleTypeDef *hpcd)
959 {
960 HAL_StatusTypeDef status = HAL_OK;
961
962 /* Process locked */
963 __HAL_LOCK(hpcd);
964
965 if (hpcd->State == HAL_PCD_STATE_READY)
966 {
967 hpcd->LPMCallback = HAL_PCDEx_LPM_Callback; /* Legacy weak HAL_PCDEx_LPM_Callback */
968 }
969 else
970 {
971 /* Update the error code */
972 hpcd->ErrorCode |= HAL_PCD_ERROR_INVALID_CALLBACK;
973
974 /* Return error status */
975 status = HAL_ERROR;
976 }
977
978 /* Release Lock */
979 __HAL_UNLOCK(hpcd);
980
981 return status;
982 }
983 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
984
985 /**
986 * @}
987 */
988
989 /** @defgroup PCD_Exported_Functions_Group2 Input and Output operation functions
990 * @brief Data transfers functions
991 *
992 @verbatim
993 ===============================================================================
994 ##### IO operation functions #####
995 ===============================================================================
996 [..]
997 This subsection provides a set of functions allowing to manage the PCD data
998 transfers.
999
1000 @endverbatim
1001 * @{
1002 */
1003
1004 /**
1005 * @brief Start the USB device
1006 * @param hpcd PCD handle
1007 * @retval HAL status
1008 */
HAL_PCD_Start(PCD_HandleTypeDef * hpcd)1009 HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
1010 {
1011 #if defined (USB_OTG_FS)
1012 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
1013 #endif /* defined (USB_OTG_FS) */
1014
1015 __HAL_LOCK(hpcd);
1016 #if defined (USB_OTG_FS)
1017 if (hpcd->Init.battery_charging_enable == 1U)
1018 {
1019 /* Enable USB Transceiver */
1020 USBx->GCCFG |= USB_OTG_GCCFG_PWRDWN;
1021 }
1022 #endif /* defined (USB_OTG_FS) */
1023 __HAL_PCD_ENABLE(hpcd);
1024 (void)USB_DevConnect(hpcd->Instance);
1025 __HAL_UNLOCK(hpcd);
1026
1027 return HAL_OK;
1028 }
1029
1030 /**
1031 * @brief Stop the USB device.
1032 * @param hpcd PCD handle
1033 * @retval HAL status
1034 */
HAL_PCD_Stop(PCD_HandleTypeDef * hpcd)1035 HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
1036 {
1037 #if defined (USB_OTG_FS)
1038 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
1039 #endif /* defined (USB_OTG_FS) */
1040
1041 __HAL_LOCK(hpcd);
1042 __HAL_PCD_DISABLE(hpcd);
1043 (void)USB_DevDisconnect(hpcd->Instance);
1044
1045 #if defined (USB_OTG_FS)
1046 (void)USB_FlushTxFifo(hpcd->Instance, 0x10U);
1047
1048 if (hpcd->Init.battery_charging_enable == 1U)
1049 {
1050 /* Disable USB Transceiver */
1051 USBx->GCCFG &= ~(USB_OTG_GCCFG_PWRDWN);
1052 }
1053 #endif /* defined (USB_OTG_FS) */
1054
1055 __HAL_UNLOCK(hpcd);
1056
1057 return HAL_OK;
1058 }
1059
1060 #if defined (USB_OTG_FS)
1061 /**
1062 * @brief Handles PCD interrupt request.
1063 * @param hpcd PCD handle
1064 * @retval HAL status
1065 */
HAL_PCD_IRQHandler(PCD_HandleTypeDef * hpcd)1066 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
1067 {
1068 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
1069 uint32_t USBx_BASE = (uint32_t)USBx;
1070 USB_OTG_EPTypeDef *ep;
1071 uint32_t i;
1072 uint32_t ep_intr;
1073 uint32_t epint;
1074 uint32_t epnum;
1075 uint32_t fifoemptymsk;
1076 uint32_t RegVal;
1077
1078 /* ensure that we are in device mode */
1079 if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)
1080 {
1081 /* avoid spurious interrupt */
1082 if (__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))
1083 {
1084 return;
1085 }
1086
1087 /* store current frame number */
1088 hpcd->FrameNumber = (USBx_DEVICE->DSTS & USB_OTG_DSTS_FNSOF_Msk) >> USB_OTG_DSTS_FNSOF_Pos;
1089
1090 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))
1091 {
1092 /* incorrect mode, acknowledge the interrupt */
1093 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);
1094 }
1095
1096 /* Handle RxQLevel Interrupt */
1097 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))
1098 {
1099 USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
1100
1101 RegVal = USBx->GRXSTSP;
1102
1103 ep = &hpcd->OUT_ep[RegVal & USB_OTG_GRXSTSP_EPNUM];
1104
1105 if (((RegVal & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_DATA_UPDT)
1106 {
1107 if ((RegVal & USB_OTG_GRXSTSP_BCNT) != 0U)
1108 {
1109 (void)USB_ReadPacket(USBx, ep->xfer_buff,
1110 (uint16_t)((RegVal & USB_OTG_GRXSTSP_BCNT) >> 4));
1111
1112 ep->xfer_buff += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
1113 ep->xfer_count += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
1114 }
1115 }
1116 else if (((RegVal & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_SETUP_UPDT)
1117 {
1118 (void)USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8U);
1119 ep->xfer_count += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
1120 }
1121 else
1122 {
1123 /* ... */
1124 }
1125
1126 USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
1127 }
1128
1129 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))
1130 {
1131 epnum = 0U;
1132
1133 /* Read in the device interrupt bits */
1134 ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
1135
1136 while (ep_intr != 0U)
1137 {
1138 if ((ep_intr & 0x1U) != 0U)
1139 {
1140 epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, (uint8_t)epnum);
1141
1142 if ((epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
1143 {
1144 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
1145 (void)PCD_EP_OutXfrComplete_int(hpcd, epnum);
1146 }
1147
1148 if ((epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)
1149 {
1150 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);
1151 /* Class B setup phase done for previous decoded setup */
1152 (void)PCD_EP_OutSetupPacket_int(hpcd, epnum);
1153 }
1154
1155 if ((epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)
1156 {
1157 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);
1158 }
1159
1160 /* Clear OUT Endpoint disable interrupt */
1161 if ((epint & USB_OTG_DOEPINT_EPDISD) == USB_OTG_DOEPINT_EPDISD)
1162 {
1163 if ((USBx->GINTSTS & USB_OTG_GINTSTS_BOUTNAKEFF) == USB_OTG_GINTSTS_BOUTNAKEFF)
1164 {
1165 USBx_DEVICE->DCTL |= USB_OTG_DCTL_CGONAK;
1166 }
1167
1168 ep = &hpcd->OUT_ep[epnum];
1169
1170 if (ep->is_iso_incomplete == 1U)
1171 {
1172 ep->is_iso_incomplete = 0U;
1173
1174 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1175 hpcd->ISOOUTIncompleteCallback(hpcd, (uint8_t)epnum);
1176 #else
1177 HAL_PCD_ISOOUTIncompleteCallback(hpcd, (uint8_t)epnum);
1178 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1179 }
1180
1181 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_EPDISD);
1182 }
1183
1184 /* Clear Status Phase Received interrupt */
1185 if ((epint & USB_OTG_DOEPINT_OTEPSPR) == USB_OTG_DOEPINT_OTEPSPR)
1186 {
1187 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPSPR);
1188 }
1189
1190 /* Clear OUT NAK interrupt */
1191 if ((epint & USB_OTG_DOEPINT_NAK) == USB_OTG_DOEPINT_NAK)
1192 {
1193 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_NAK);
1194 }
1195 }
1196 epnum++;
1197 ep_intr >>= 1U;
1198 }
1199 }
1200
1201 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))
1202 {
1203 /* Read in the device interrupt bits */
1204 ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);
1205
1206 epnum = 0U;
1207
1208 while (ep_intr != 0U)
1209 {
1210 if ((ep_intr & 0x1U) != 0U) /* In ITR */
1211 {
1212 epint = USB_ReadDevInEPInterrupt(hpcd->Instance, (uint8_t)epnum);
1213
1214 if ((epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)
1215 {
1216 fifoemptymsk = (uint32_t)(0x1UL << (epnum & EP_ADDR_MSK));
1217 USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;
1218
1219 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);
1220
1221 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1222 hpcd->DataInStageCallback(hpcd, (uint8_t)epnum);
1223 #else
1224 HAL_PCD_DataInStageCallback(hpcd, (uint8_t)epnum);
1225 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1226 }
1227 if ((epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)
1228 {
1229 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);
1230 }
1231 if ((epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)
1232 {
1233 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);
1234 }
1235 if ((epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)
1236 {
1237 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);
1238 }
1239 if ((epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
1240 {
1241 (void)USB_FlushTxFifo(USBx, epnum);
1242
1243 ep = &hpcd->IN_ep[epnum];
1244
1245 if (ep->is_iso_incomplete == 1U)
1246 {
1247 ep->is_iso_incomplete = 0U;
1248
1249 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1250 hpcd->ISOINIncompleteCallback(hpcd, (uint8_t)epnum);
1251 #else
1252 HAL_PCD_ISOINIncompleteCallback(hpcd, (uint8_t)epnum);
1253 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1254 }
1255
1256 CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);
1257 }
1258 if ((epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)
1259 {
1260 (void)PCD_WriteEmptyTxFifo(hpcd, epnum);
1261 }
1262 }
1263 epnum++;
1264 ep_intr >>= 1U;
1265 }
1266 }
1267
1268 /* Handle Resume Interrupt */
1269 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))
1270 {
1271 /* Clear the Remote Wake-up Signaling */
1272 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
1273
1274 if (hpcd->LPM_State == LPM_L1)
1275 {
1276 hpcd->LPM_State = LPM_L0;
1277
1278 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1279 hpcd->LPMCallback(hpcd, PCD_LPM_L0_ACTIVE);
1280 #else
1281 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
1282 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1283 }
1284 else
1285 {
1286 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1287 hpcd->ResumeCallback(hpcd);
1288 #else
1289 HAL_PCD_ResumeCallback(hpcd);
1290 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1291 }
1292
1293 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);
1294 }
1295
1296 /* Handle Suspend Interrupt */
1297 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))
1298 {
1299 if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
1300 {
1301 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1302 hpcd->SuspendCallback(hpcd);
1303 #else
1304 HAL_PCD_SuspendCallback(hpcd);
1305 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1306 }
1307 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);
1308 }
1309
1310 /* Handle LPM Interrupt */
1311 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT))
1312 {
1313 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT);
1314
1315 if (hpcd->LPM_State == LPM_L0)
1316 {
1317 hpcd->LPM_State = LPM_L1;
1318 hpcd->BESL = (hpcd->Instance->GLPMCFG & USB_OTG_GLPMCFG_BESL) >> 2U;
1319
1320 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1321 hpcd->LPMCallback(hpcd, PCD_LPM_L1_ACTIVE);
1322 #else
1323 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
1324 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1325 }
1326 else
1327 {
1328 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1329 hpcd->SuspendCallback(hpcd);
1330 #else
1331 HAL_PCD_SuspendCallback(hpcd);
1332 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1333 }
1334 }
1335
1336 /* Handle Reset Interrupt */
1337 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))
1338 {
1339 USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
1340 (void)USB_FlushTxFifo(hpcd->Instance, 0x10U);
1341
1342 for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
1343 {
1344 USBx_INEP(i)->DIEPINT = 0xFB7FU;
1345 USBx_INEP(i)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
1346 USBx_OUTEP(i)->DOEPINT = 0xFB7FU;
1347 USBx_OUTEP(i)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
1348 USBx_OUTEP(i)->DOEPCTL |= USB_OTG_DOEPCTL_SNAK;
1349 }
1350 USBx_DEVICE->DAINTMSK |= 0x10001U;
1351
1352 if (hpcd->Init.use_dedicated_ep1 != 0U)
1353 {
1354 USBx_DEVICE->DOUTEP1MSK |= USB_OTG_DOEPMSK_STUPM |
1355 USB_OTG_DOEPMSK_XFRCM |
1356 USB_OTG_DOEPMSK_EPDM;
1357
1358 USBx_DEVICE->DINEP1MSK |= USB_OTG_DIEPMSK_TOM |
1359 USB_OTG_DIEPMSK_XFRCM |
1360 USB_OTG_DIEPMSK_EPDM;
1361 }
1362 else
1363 {
1364 USBx_DEVICE->DOEPMSK |= USB_OTG_DOEPMSK_STUPM |
1365 USB_OTG_DOEPMSK_XFRCM |
1366 USB_OTG_DOEPMSK_EPDM |
1367 USB_OTG_DOEPMSK_OTEPSPRM |
1368 USB_OTG_DOEPMSK_NAKM;
1369
1370 USBx_DEVICE->DIEPMSK |= USB_OTG_DIEPMSK_TOM |
1371 USB_OTG_DIEPMSK_XFRCM |
1372 USB_OTG_DIEPMSK_EPDM;
1373 }
1374
1375 /* Set Default Address to 0 */
1376 USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;
1377
1378 /* setup EP0 to receive SETUP packets */
1379 (void)USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
1380
1381 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);
1382 }
1383
1384 /* Handle Enumeration done Interrupt */
1385 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))
1386 {
1387 (void)USB_ActivateSetup(hpcd->Instance);
1388 hpcd->Init.speed = USB_GetDevSpeed(hpcd->Instance);
1389
1390 /* Set USB Turnaround time */
1391 (void)USB_SetTurnaroundTime(hpcd->Instance,
1392 HAL_RCC_GetHCLKFreq(),
1393 (uint8_t)hpcd->Init.speed);
1394
1395 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1396 hpcd->ResetCallback(hpcd);
1397 #else
1398 HAL_PCD_ResetCallback(hpcd);
1399 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1400
1401 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);
1402 }
1403
1404 /* Handle SOF Interrupt */
1405 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))
1406 {
1407 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1408 hpcd->SOFCallback(hpcd);
1409 #else
1410 HAL_PCD_SOFCallback(hpcd);
1411 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1412
1413 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);
1414 }
1415
1416 /* Handle Global OUT NAK effective Interrupt */
1417 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_BOUTNAKEFF))
1418 {
1419 USBx->GINTMSK &= ~USB_OTG_GINTMSK_GONAKEFFM;
1420
1421 for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
1422 {
1423 if (hpcd->OUT_ep[epnum].is_iso_incomplete == 1U)
1424 {
1425 /* Abort current transaction and disable the EP */
1426 (void)HAL_PCD_EP_Abort(hpcd, (uint8_t)epnum);
1427 }
1428 }
1429 }
1430
1431 /* Handle Incomplete ISO IN Interrupt */
1432 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))
1433 {
1434 for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
1435 {
1436 RegVal = USBx_INEP(epnum)->DIEPCTL;
1437
1438 if ((hpcd->IN_ep[epnum].type == EP_TYPE_ISOC) &&
1439 ((RegVal & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA))
1440 {
1441 hpcd->IN_ep[epnum].is_iso_incomplete = 1U;
1442
1443 /* Abort current transaction and disable the EP */
1444 (void)HAL_PCD_EP_Abort(hpcd, (uint8_t)(epnum | 0x80U));
1445 }
1446 }
1447
1448 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);
1449 }
1450
1451 /* Handle Incomplete ISO OUT Interrupt */
1452 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
1453 {
1454 for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
1455 {
1456 RegVal = USBx_OUTEP(epnum)->DOEPCTL;
1457
1458 if ((hpcd->OUT_ep[epnum].type == EP_TYPE_ISOC) &&
1459 ((RegVal & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA) &&
1460 ((RegVal & (0x1U << 16)) == (hpcd->FrameNumber & 0x1U)))
1461 {
1462 hpcd->OUT_ep[epnum].is_iso_incomplete = 1U;
1463
1464 USBx->GINTMSK |= USB_OTG_GINTMSK_GONAKEFFM;
1465
1466 if ((USBx->GINTSTS & USB_OTG_GINTSTS_BOUTNAKEFF) == 0U)
1467 {
1468 USBx_DEVICE->DCTL |= USB_OTG_DCTL_SGONAK;
1469 break;
1470 }
1471 }
1472 }
1473
1474 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
1475 }
1476
1477 /* Handle Connection event Interrupt */
1478 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
1479 {
1480 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1481 hpcd->ConnectCallback(hpcd);
1482 #else
1483 HAL_PCD_ConnectCallback(hpcd);
1484 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1485
1486 __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
1487 }
1488
1489 /* Handle Disconnection event Interrupt */
1490 if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))
1491 {
1492 RegVal = hpcd->Instance->GOTGINT;
1493
1494 if ((RegVal & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)
1495 {
1496 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1497 hpcd->DisconnectCallback(hpcd);
1498 #else
1499 HAL_PCD_DisconnectCallback(hpcd);
1500 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1501 }
1502 hpcd->Instance->GOTGINT |= RegVal;
1503 }
1504 }
1505 }
1506 #endif /* defined (USB_OTG_FS) */
1507
1508 #if defined (USB)
1509 /**
1510 * @brief This function handles PCD interrupt request.
1511 * @param hpcd PCD handle
1512 * @retval HAL status
1513 */
HAL_PCD_IRQHandler(PCD_HandleTypeDef * hpcd)1514 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
1515 {
1516 uint32_t wIstr = USB_ReadInterrupts(hpcd->Instance);
1517
1518 if ((wIstr & USB_ISTR_CTR) == USB_ISTR_CTR)
1519 {
1520 /* servicing of the endpoint correct transfer interrupt */
1521 /* clear of the CTR flag into the sub */
1522 (void)PCD_EP_ISR_Handler(hpcd);
1523
1524 return;
1525 }
1526
1527 if ((wIstr & USB_ISTR_RESET) == USB_ISTR_RESET)
1528 {
1529 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
1530
1531 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1532 hpcd->ResetCallback(hpcd);
1533 #else
1534 HAL_PCD_ResetCallback(hpcd);
1535 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1536
1537 (void)HAL_PCD_SetAddress(hpcd, 0U);
1538
1539 return;
1540 }
1541
1542 if ((wIstr & USB_ISTR_PMAOVR) == USB_ISTR_PMAOVR)
1543 {
1544 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
1545
1546 return;
1547 }
1548
1549 if ((wIstr & USB_ISTR_ERR) == USB_ISTR_ERR)
1550 {
1551 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
1552
1553 return;
1554 }
1555
1556 if ((wIstr & USB_ISTR_WKUP) == USB_ISTR_WKUP)
1557 {
1558 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_LPMODE);
1559 hpcd->Instance->CNTR &= (uint16_t) ~(USB_CNTR_FSUSP);
1560
1561 if (hpcd->LPM_State == LPM_L1)
1562 {
1563 hpcd->LPM_State = LPM_L0;
1564 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1565 hpcd->LPMCallback(hpcd, PCD_LPM_L0_ACTIVE);
1566 #else
1567 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
1568 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1569 }
1570
1571 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1572 hpcd->ResumeCallback(hpcd);
1573 #else
1574 HAL_PCD_ResumeCallback(hpcd);
1575 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1576
1577 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
1578
1579 return;
1580 }
1581
1582 if ((wIstr & USB_ISTR_SUSP) == USB_ISTR_SUSP)
1583 {
1584 /* Force low-power mode in the macrocell */
1585 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_FSUSP;
1586
1587 /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
1588 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);
1589
1590 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_LPMODE;
1591
1592 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1593 hpcd->SuspendCallback(hpcd);
1594 #else
1595 HAL_PCD_SuspendCallback(hpcd);
1596 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1597
1598 return;
1599 }
1600
1601 /* Handle LPM Interrupt */
1602 if ((wIstr & USB_ISTR_L1REQ) == USB_ISTR_L1REQ)
1603 {
1604 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_L1REQ);
1605 if (hpcd->LPM_State == LPM_L0)
1606 {
1607 /* Force suspend and low-power mode before going to L1 state*/
1608 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_LPMODE;
1609 hpcd->Instance->CNTR |= (uint16_t)USB_CNTR_FSUSP;
1610
1611 hpcd->LPM_State = LPM_L1;
1612 hpcd->BESL = ((uint32_t)hpcd->Instance->LPMCSR & USB_LPMCSR_BESL) >> 2;
1613 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1614 hpcd->LPMCallback(hpcd, PCD_LPM_L1_ACTIVE);
1615 #else
1616 HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
1617 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1618 }
1619 else
1620 {
1621 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1622 hpcd->SuspendCallback(hpcd);
1623 #else
1624 HAL_PCD_SuspendCallback(hpcd);
1625 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1626 }
1627
1628 return;
1629 }
1630
1631 if ((wIstr & USB_ISTR_SOF) == USB_ISTR_SOF)
1632 {
1633 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
1634
1635 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1636 hpcd->SOFCallback(hpcd);
1637 #else
1638 HAL_PCD_SOFCallback(hpcd);
1639 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1640
1641 return;
1642 }
1643
1644 if ((wIstr & USB_ISTR_ESOF) == USB_ISTR_ESOF)
1645 {
1646 /* clear ESOF flag in ISTR */
1647 __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
1648
1649 return;
1650 }
1651 }
1652 #endif /* defined (USB) */
1653
1654 /**
1655 * @brief Data OUT stage callback.
1656 * @param hpcd PCD handle
1657 * @param epnum endpoint number
1658 * @retval None
1659 */
HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1660 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1661 {
1662 /* Prevent unused argument(s) compilation warning */
1663 UNUSED(hpcd);
1664 UNUSED(epnum);
1665
1666 /* NOTE : This function should not be modified, when the callback is needed,
1667 the HAL_PCD_DataOutStageCallback could be implemented in the user file
1668 */
1669 }
1670
1671 /**
1672 * @brief Data IN stage callback
1673 * @param hpcd PCD handle
1674 * @param epnum endpoint number
1675 * @retval None
1676 */
HAL_PCD_DataInStageCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1677 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1678 {
1679 /* Prevent unused argument(s) compilation warning */
1680 UNUSED(hpcd);
1681 UNUSED(epnum);
1682
1683 /* NOTE : This function should not be modified, when the callback is needed,
1684 the HAL_PCD_DataInStageCallback could be implemented in the user file
1685 */
1686 }
1687 /**
1688 * @brief Setup stage callback
1689 * @param hpcd PCD handle
1690 * @retval None
1691 */
HAL_PCD_SetupStageCallback(PCD_HandleTypeDef * hpcd)1692 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
1693 {
1694 /* Prevent unused argument(s) compilation warning */
1695 UNUSED(hpcd);
1696
1697 /* NOTE : This function should not be modified, when the callback is needed,
1698 the HAL_PCD_SetupStageCallback could be implemented in the user file
1699 */
1700 }
1701
1702 /**
1703 * @brief USB Start Of Frame callback.
1704 * @param hpcd PCD handle
1705 * @retval None
1706 */
HAL_PCD_SOFCallback(PCD_HandleTypeDef * hpcd)1707 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
1708 {
1709 /* Prevent unused argument(s) compilation warning */
1710 UNUSED(hpcd);
1711
1712 /* NOTE : This function should not be modified, when the callback is needed,
1713 the HAL_PCD_SOFCallback could be implemented in the user file
1714 */
1715 }
1716
1717 /**
1718 * @brief USB Reset callback.
1719 * @param hpcd PCD handle
1720 * @retval None
1721 */
HAL_PCD_ResetCallback(PCD_HandleTypeDef * hpcd)1722 __weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
1723 {
1724 /* Prevent unused argument(s) compilation warning */
1725 UNUSED(hpcd);
1726
1727 /* NOTE : This function should not be modified, when the callback is needed,
1728 the HAL_PCD_ResetCallback could be implemented in the user file
1729 */
1730 }
1731
1732 /**
1733 * @brief Suspend event callback.
1734 * @param hpcd PCD handle
1735 * @retval None
1736 */
HAL_PCD_SuspendCallback(PCD_HandleTypeDef * hpcd)1737 __weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
1738 {
1739 /* Prevent unused argument(s) compilation warning */
1740 UNUSED(hpcd);
1741
1742 /* NOTE : This function should not be modified, when the callback is needed,
1743 the HAL_PCD_SuspendCallback could be implemented in the user file
1744 */
1745 }
1746
1747 /**
1748 * @brief Resume event callback.
1749 * @param hpcd PCD handle
1750 * @retval None
1751 */
HAL_PCD_ResumeCallback(PCD_HandleTypeDef * hpcd)1752 __weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
1753 {
1754 /* Prevent unused argument(s) compilation warning */
1755 UNUSED(hpcd);
1756
1757 /* NOTE : This function should not be modified, when the callback is needed,
1758 the HAL_PCD_ResumeCallback could be implemented in the user file
1759 */
1760 }
1761
1762 /**
1763 * @brief Incomplete ISO OUT callback.
1764 * @param hpcd PCD handle
1765 * @param epnum endpoint number
1766 * @retval None
1767 */
HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1768 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1769 {
1770 /* Prevent unused argument(s) compilation warning */
1771 UNUSED(hpcd);
1772 UNUSED(epnum);
1773
1774 /* NOTE : This function should not be modified, when the callback is needed,
1775 the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
1776 */
1777 }
1778
1779 /**
1780 * @brief Incomplete ISO IN callback.
1781 * @param hpcd PCD handle
1782 * @param epnum endpoint number
1783 * @retval None
1784 */
HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef * hpcd,uint8_t epnum)1785 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
1786 {
1787 /* Prevent unused argument(s) compilation warning */
1788 UNUSED(hpcd);
1789 UNUSED(epnum);
1790
1791 /* NOTE : This function should not be modified, when the callback is needed,
1792 the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
1793 */
1794 }
1795
1796 /**
1797 * @brief Connection event callback.
1798 * @param hpcd PCD handle
1799 * @retval None
1800 */
HAL_PCD_ConnectCallback(PCD_HandleTypeDef * hpcd)1801 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
1802 {
1803 /* Prevent unused argument(s) compilation warning */
1804 UNUSED(hpcd);
1805
1806 /* NOTE : This function should not be modified, when the callback is needed,
1807 the HAL_PCD_ConnectCallback could be implemented in the user file
1808 */
1809 }
1810
1811 /**
1812 * @brief Disconnection event callback.
1813 * @param hpcd PCD handle
1814 * @retval None
1815 */
HAL_PCD_DisconnectCallback(PCD_HandleTypeDef * hpcd)1816 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
1817 {
1818 /* Prevent unused argument(s) compilation warning */
1819 UNUSED(hpcd);
1820
1821 /* NOTE : This function should not be modified, when the callback is needed,
1822 the HAL_PCD_DisconnectCallback could be implemented in the user file
1823 */
1824 }
1825
1826 /**
1827 * @}
1828 */
1829
1830 /** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
1831 * @brief management functions
1832 *
1833 @verbatim
1834 ===============================================================================
1835 ##### Peripheral Control functions #####
1836 ===============================================================================
1837 [..]
1838 This subsection provides a set of functions allowing to control the PCD data
1839 transfers.
1840
1841 @endverbatim
1842 * @{
1843 */
1844
1845 /**
1846 * @brief Connect the USB device
1847 * @param hpcd PCD handle
1848 * @retval HAL status
1849 */
HAL_PCD_DevConnect(PCD_HandleTypeDef * hpcd)1850 HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
1851 {
1852 #if defined (USB_OTG_FS)
1853 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
1854 #endif /* defined (USB_OTG_FS) */
1855
1856 __HAL_LOCK(hpcd);
1857
1858 #if defined (USB_OTG_FS)
1859 if (hpcd->Init.battery_charging_enable == 1U)
1860 {
1861 /* Enable USB Transceiver */
1862 USBx->GCCFG |= USB_OTG_GCCFG_PWRDWN;
1863 }
1864 #endif /* defined (USB_OTG_FS) */
1865
1866 (void)USB_DevConnect(hpcd->Instance);
1867 __HAL_UNLOCK(hpcd);
1868
1869 return HAL_OK;
1870 }
1871
1872 /**
1873 * @brief Disconnect the USB device.
1874 * @param hpcd PCD handle
1875 * @retval HAL status
1876 */
HAL_PCD_DevDisconnect(PCD_HandleTypeDef * hpcd)1877 HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
1878 {
1879 #if defined (USB_OTG_FS)
1880 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
1881 #endif /* defined (USB_OTG_FS) */
1882
1883 __HAL_LOCK(hpcd);
1884 (void)USB_DevDisconnect(hpcd->Instance);
1885
1886 #if defined (USB_OTG_FS)
1887 if (hpcd->Init.battery_charging_enable == 1U)
1888 {
1889 /* Disable USB Transceiver */
1890 USBx->GCCFG &= ~(USB_OTG_GCCFG_PWRDWN);
1891 }
1892 #endif /* defined (USB_OTG_FS) */
1893
1894 __HAL_UNLOCK(hpcd);
1895
1896 return HAL_OK;
1897 }
1898
1899 /**
1900 * @brief Set the USB Device address.
1901 * @param hpcd PCD handle
1902 * @param address new device address
1903 * @retval HAL status
1904 */
HAL_PCD_SetAddress(PCD_HandleTypeDef * hpcd,uint8_t address)1905 HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
1906 {
1907 __HAL_LOCK(hpcd);
1908 hpcd->USB_Address = address;
1909 (void)USB_SetDevAddress(hpcd->Instance, address);
1910 __HAL_UNLOCK(hpcd);
1911
1912 return HAL_OK;
1913 }
1914 /**
1915 * @brief Open and configure an endpoint.
1916 * @param hpcd PCD handle
1917 * @param ep_addr endpoint address
1918 * @param ep_mps endpoint max packet size
1919 * @param ep_type endpoint type
1920 * @retval HAL status
1921 */
HAL_PCD_EP_Open(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint16_t ep_mps,uint8_t ep_type)1922 HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
1923 uint16_t ep_mps, uint8_t ep_type)
1924 {
1925 HAL_StatusTypeDef ret = HAL_OK;
1926 PCD_EPTypeDef *ep;
1927
1928 if ((ep_addr & 0x80U) == 0x80U)
1929 {
1930 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1931 ep->is_in = 1U;
1932 }
1933 else
1934 {
1935 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1936 ep->is_in = 0U;
1937 }
1938
1939 ep->num = ep_addr & EP_ADDR_MSK;
1940 ep->maxpacket = (uint32_t)ep_mps & 0x7FFU;
1941 ep->type = ep_type;
1942
1943 #if defined (USB_OTG_FS)
1944 if (ep->is_in != 0U)
1945 {
1946 /* Assign a Tx FIFO */
1947 ep->tx_fifo_num = ep->num;
1948 }
1949 #endif /* defined (USB_OTG_FS) */
1950
1951 /* Set initial data PID. */
1952 if (ep_type == EP_TYPE_BULK)
1953 {
1954 ep->data_pid_start = 0U;
1955 }
1956
1957 __HAL_LOCK(hpcd);
1958 (void)USB_ActivateEndpoint(hpcd->Instance, ep);
1959 __HAL_UNLOCK(hpcd);
1960
1961 return ret;
1962 }
1963
1964 /**
1965 * @brief Deactivate an endpoint.
1966 * @param hpcd PCD handle
1967 * @param ep_addr endpoint address
1968 * @retval HAL status
1969 */
HAL_PCD_EP_Close(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)1970 HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
1971 {
1972 PCD_EPTypeDef *ep;
1973
1974 if ((ep_addr & 0x80U) == 0x80U)
1975 {
1976 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
1977 ep->is_in = 1U;
1978 }
1979 else
1980 {
1981 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
1982 ep->is_in = 0U;
1983 }
1984 ep->num = ep_addr & EP_ADDR_MSK;
1985
1986 __HAL_LOCK(hpcd);
1987 (void)USB_DeactivateEndpoint(hpcd->Instance, ep);
1988 __HAL_UNLOCK(hpcd);
1989 return HAL_OK;
1990 }
1991
1992
1993 /**
1994 * @brief Receive an amount of data.
1995 * @param hpcd PCD handle
1996 * @param ep_addr endpoint address
1997 * @param pBuf pointer to the reception buffer
1998 * @param len amount of data to be received
1999 * @retval HAL status
2000 */
HAL_PCD_EP_Receive(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint8_t * pBuf,uint32_t len)2001 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
2002 {
2003 PCD_EPTypeDef *ep;
2004
2005 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
2006
2007 /*setup and start the Xfer */
2008 ep->xfer_buff = pBuf;
2009 ep->xfer_len = len;
2010 ep->xfer_count = 0U;
2011 ep->is_in = 0U;
2012 ep->num = ep_addr & EP_ADDR_MSK;
2013
2014 (void)USB_EPStartXfer(hpcd->Instance, ep);
2015
2016 return HAL_OK;
2017 }
2018
2019 /**
2020 * @brief Get Received Data Size
2021 * @param hpcd PCD handle
2022 * @param ep_addr endpoint address
2023 * @retval Data Size
2024 */
HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef const * hpcd,uint8_t ep_addr)2025 uint32_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef const *hpcd, uint8_t ep_addr)
2026 {
2027 return hpcd->OUT_ep[ep_addr & EP_ADDR_MSK].xfer_count;
2028 }
2029 /**
2030 * @brief Send an amount of data
2031 * @param hpcd PCD handle
2032 * @param ep_addr endpoint address
2033 * @param pBuf pointer to the transmission buffer
2034 * @param len amount of data to be sent
2035 * @retval HAL status
2036 */
HAL_PCD_EP_Transmit(PCD_HandleTypeDef * hpcd,uint8_t ep_addr,uint8_t * pBuf,uint32_t len)2037 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
2038 {
2039 PCD_EPTypeDef *ep;
2040
2041 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
2042
2043 /*setup and start the Xfer */
2044 ep->xfer_buff = pBuf;
2045 ep->xfer_len = len;
2046 #if defined (USB)
2047 ep->xfer_fill_db = 1U;
2048 ep->xfer_len_db = len;
2049 #endif /* defined (USB) */
2050 ep->xfer_count = 0U;
2051 ep->is_in = 1U;
2052 ep->num = ep_addr & EP_ADDR_MSK;
2053
2054 (void)USB_EPStartXfer(hpcd->Instance, ep);
2055
2056 return HAL_OK;
2057 }
2058
2059 /**
2060 * @brief Set a STALL condition over an endpoint
2061 * @param hpcd PCD handle
2062 * @param ep_addr endpoint address
2063 * @retval HAL status
2064 */
HAL_PCD_EP_SetStall(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)2065 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
2066 {
2067 PCD_EPTypeDef *ep;
2068
2069 if (((uint32_t)ep_addr & EP_ADDR_MSK) > hpcd->Init.dev_endpoints)
2070 {
2071 return HAL_ERROR;
2072 }
2073
2074 if ((0x80U & ep_addr) == 0x80U)
2075 {
2076 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
2077 ep->is_in = 1U;
2078 }
2079 else
2080 {
2081 ep = &hpcd->OUT_ep[ep_addr];
2082 ep->is_in = 0U;
2083 }
2084
2085 ep->is_stall = 1U;
2086 ep->num = ep_addr & EP_ADDR_MSK;
2087
2088 __HAL_LOCK(hpcd);
2089
2090 (void)USB_EPSetStall(hpcd->Instance, ep);
2091
2092 if ((ep_addr & EP_ADDR_MSK) == 0U)
2093 {
2094 (void)USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
2095 }
2096
2097 __HAL_UNLOCK(hpcd);
2098
2099 return HAL_OK;
2100 }
2101
2102 /**
2103 * @brief Clear a STALL condition over in an endpoint
2104 * @param hpcd PCD handle
2105 * @param ep_addr endpoint address
2106 * @retval HAL status
2107 */
HAL_PCD_EP_ClrStall(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)2108 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
2109 {
2110 PCD_EPTypeDef *ep;
2111
2112 if (((uint32_t)ep_addr & 0x0FU) > hpcd->Init.dev_endpoints)
2113 {
2114 return HAL_ERROR;
2115 }
2116
2117 if ((0x80U & ep_addr) == 0x80U)
2118 {
2119 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
2120 ep->is_in = 1U;
2121 }
2122 else
2123 {
2124 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
2125 ep->is_in = 0U;
2126 }
2127
2128 ep->is_stall = 0U;
2129 ep->num = ep_addr & EP_ADDR_MSK;
2130
2131 __HAL_LOCK(hpcd);
2132 (void)USB_EPClearStall(hpcd->Instance, ep);
2133 __HAL_UNLOCK(hpcd);
2134
2135 return HAL_OK;
2136 }
2137
2138 /**
2139 * @brief Abort an USB EP transaction.
2140 * @param hpcd PCD handle
2141 * @param ep_addr endpoint address
2142 * @retval HAL status
2143 */
HAL_PCD_EP_Abort(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)2144 HAL_StatusTypeDef HAL_PCD_EP_Abort(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
2145 {
2146 HAL_StatusTypeDef ret;
2147 PCD_EPTypeDef *ep;
2148
2149 if ((0x80U & ep_addr) == 0x80U)
2150 {
2151 ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
2152 }
2153 else
2154 {
2155 ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
2156 }
2157
2158 /* Stop Xfer */
2159 ret = USB_EPStopXfer(hpcd->Instance, ep);
2160
2161 return ret;
2162 }
2163
2164 /**
2165 * @brief Flush an endpoint
2166 * @param hpcd PCD handle
2167 * @param ep_addr endpoint address
2168 * @retval HAL status
2169 */
HAL_PCD_EP_Flush(PCD_HandleTypeDef * hpcd,uint8_t ep_addr)2170 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
2171 {
2172 __HAL_LOCK(hpcd);
2173
2174 if ((ep_addr & 0x80U) == 0x80U)
2175 {
2176 (void)USB_FlushTxFifo(hpcd->Instance, (uint32_t)ep_addr & EP_ADDR_MSK);
2177 }
2178 else
2179 {
2180 (void)USB_FlushRxFifo(hpcd->Instance);
2181 }
2182
2183 __HAL_UNLOCK(hpcd);
2184
2185 return HAL_OK;
2186 }
2187
2188 /**
2189 * @brief Activate remote wakeup signalling
2190 * @param hpcd PCD handle
2191 * @retval HAL status
2192 */
HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef * hpcd)2193 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
2194 {
2195 return (USB_ActivateRemoteWakeup(hpcd->Instance));
2196 }
2197
2198 /**
2199 * @brief De-activate remote wakeup signalling.
2200 * @param hpcd PCD handle
2201 * @retval HAL status
2202 */
HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef * hpcd)2203 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
2204 {
2205 return (USB_DeActivateRemoteWakeup(hpcd->Instance));
2206 }
2207
2208 /**
2209 * @}
2210 */
2211
2212 /** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
2213 * @brief Peripheral State functions
2214 *
2215 @verbatim
2216 ===============================================================================
2217 ##### Peripheral State functions #####
2218 ===============================================================================
2219 [..]
2220 This subsection permits to get in run-time the status of the peripheral
2221 and the data flow.
2222
2223 @endverbatim
2224 * @{
2225 */
2226
2227 /**
2228 * @brief Return the PCD handle state.
2229 * @param hpcd PCD handle
2230 * @retval HAL state
2231 */
HAL_PCD_GetState(PCD_HandleTypeDef const * hpcd)2232 PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef const *hpcd)
2233 {
2234 return hpcd->State;
2235 }
2236
2237 /**
2238 * @}
2239 */
2240
2241 /**
2242 * @}
2243 */
2244
2245 /* Private functions ---------------------------------------------------------*/
2246 /** @addtogroup PCD_Private_Functions
2247 * @{
2248 */
2249 #if defined (USB_OTG_FS)
2250 /**
2251 * @brief Check FIFO for the next packet to be loaded.
2252 * @param hpcd PCD handle
2253 * @param epnum endpoint number
2254 * @retval HAL status
2255 */
PCD_WriteEmptyTxFifo(PCD_HandleTypeDef * hpcd,uint32_t epnum)2256 static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum)
2257 {
2258 USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
2259 uint32_t USBx_BASE = (uint32_t)USBx;
2260 USB_OTG_EPTypeDef *ep;
2261 uint32_t len;
2262 uint32_t len32b;
2263 uint32_t fifoemptymsk;
2264
2265 ep = &hpcd->IN_ep[epnum];
2266
2267 if (ep->xfer_count > ep->xfer_len)
2268 {
2269 return HAL_ERROR;
2270 }
2271
2272 len = ep->xfer_len - ep->xfer_count;
2273
2274 if (len > ep->maxpacket)
2275 {
2276 len = ep->maxpacket;
2277 }
2278
2279 len32b = (len + 3U) / 4U;
2280
2281 while (((USBx_INEP(epnum)->DTXFSTS & USB_OTG_DTXFSTS_INEPTFSAV) >= len32b) &&
2282 (ep->xfer_count < ep->xfer_len) && (ep->xfer_len != 0U))
2283 {
2284 /* Write the FIFO */
2285 len = ep->xfer_len - ep->xfer_count;
2286
2287 if (len > ep->maxpacket)
2288 {
2289 len = ep->maxpacket;
2290 }
2291 len32b = (len + 3U) / 4U;
2292
2293 (void)USB_WritePacket(USBx, ep->xfer_buff, (uint8_t)epnum, (uint16_t)len);
2294
2295 ep->xfer_buff += len;
2296 ep->xfer_count += len;
2297 }
2298
2299 if (ep->xfer_len <= ep->xfer_count)
2300 {
2301 fifoemptymsk = (uint32_t)(0x1UL << (epnum & EP_ADDR_MSK));
2302 USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;
2303 }
2304
2305 return HAL_OK;
2306 }
2307
2308
2309 /**
2310 * @brief process EP OUT transfer complete interrupt.
2311 * @param hpcd PCD handle
2312 * @param epnum endpoint number
2313 * @retval HAL status
2314 */
PCD_EP_OutXfrComplete_int(PCD_HandleTypeDef * hpcd,uint32_t epnum)2315 static HAL_StatusTypeDef PCD_EP_OutXfrComplete_int(PCD_HandleTypeDef *hpcd, uint32_t epnum)
2316 {
2317 const USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
2318 uint32_t USBx_BASE = (uint32_t)USBx;
2319 uint32_t gSNPSiD = *(__IO const uint32_t *)(&USBx->CID + 0x1U);
2320 uint32_t DoepintReg = USBx_OUTEP(epnum)->DOEPINT;
2321
2322 if (gSNPSiD == USB_OTG_CORE_ID_310A)
2323 {
2324 /* StupPktRcvd = 1 this is a setup packet */
2325 if ((DoepintReg & USB_OTG_DOEPINT_STPKTRX) == USB_OTG_DOEPINT_STPKTRX)
2326 {
2327 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STPKTRX);
2328 }
2329 else
2330 {
2331 if ((DoepintReg & USB_OTG_DOEPINT_OTEPSPR) == USB_OTG_DOEPINT_OTEPSPR)
2332 {
2333 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPSPR);
2334 }
2335
2336 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2337 hpcd->DataOutStageCallback(hpcd, (uint8_t)epnum);
2338 #else
2339 HAL_PCD_DataOutStageCallback(hpcd, (uint8_t)epnum);
2340 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2341 }
2342 }
2343 else
2344 {
2345 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2346 hpcd->DataOutStageCallback(hpcd, (uint8_t)epnum);
2347 #else
2348 HAL_PCD_DataOutStageCallback(hpcd, (uint8_t)epnum);
2349 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2350 }
2351
2352 return HAL_OK;
2353 }
2354
2355
2356 /**
2357 * @brief process EP OUT setup packet received interrupt.
2358 * @param hpcd PCD handle
2359 * @param epnum endpoint number
2360 * @retval HAL status
2361 */
PCD_EP_OutSetupPacket_int(PCD_HandleTypeDef * hpcd,uint32_t epnum)2362 static HAL_StatusTypeDef PCD_EP_OutSetupPacket_int(PCD_HandleTypeDef *hpcd, uint32_t epnum)
2363 {
2364 const USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
2365 uint32_t USBx_BASE = (uint32_t)USBx;
2366 uint32_t gSNPSiD = *(__IO const uint32_t *)(&USBx->CID + 0x1U);
2367 uint32_t DoepintReg = USBx_OUTEP(epnum)->DOEPINT;
2368
2369 if ((gSNPSiD > USB_OTG_CORE_ID_300A) &&
2370 ((DoepintReg & USB_OTG_DOEPINT_STPKTRX) == USB_OTG_DOEPINT_STPKTRX))
2371 {
2372 CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STPKTRX);
2373 }
2374
2375 /* Inform the upper layer that a setup packet is available */
2376 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2377 hpcd->SetupStageCallback(hpcd);
2378 #else
2379 HAL_PCD_SetupStageCallback(hpcd);
2380 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2381
2382 return HAL_OK;
2383 }
2384 #endif /* defined (USB_OTG_FS) */
2385
2386 #if defined (USB)
2387 /**
2388 * @brief This function handles PCD Endpoint interrupt request.
2389 * @param hpcd PCD handle
2390 * @retval HAL status
2391 */
PCD_EP_ISR_Handler(PCD_HandleTypeDef * hpcd)2392 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
2393 {
2394 PCD_EPTypeDef *ep;
2395 uint16_t count;
2396 uint16_t wIstr;
2397 uint16_t wEPVal;
2398 uint16_t TxPctSize;
2399 uint8_t epindex;
2400
2401 #if (USE_USB_DOUBLE_BUFFER != 1U)
2402 count = 0U;
2403 #endif /* USE_USB_DOUBLE_BUFFER */
2404
2405 /* stay in loop while pending interrupts */
2406 while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)
2407 {
2408 wIstr = hpcd->Instance->ISTR;
2409
2410 /* extract highest priority endpoint number */
2411 epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
2412
2413 if (epindex == 0U)
2414 {
2415 /* Decode and service control endpoint interrupt */
2416
2417 /* DIR bit = origin of the interrupt */
2418 if ((wIstr & USB_ISTR_DIR) == 0U)
2419 {
2420 /* DIR = 0 */
2421
2422 /* DIR = 0 => IN int */
2423 /* DIR = 0 implies that (EP_CTR_TX = 1) always */
2424 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, PCD_ENDP0);
2425 ep = &hpcd->IN_ep[0];
2426
2427 ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
2428 ep->xfer_buff += ep->xfer_count;
2429
2430 /* TX COMPLETE */
2431 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2432 hpcd->DataInStageCallback(hpcd, 0U);
2433 #else
2434 HAL_PCD_DataInStageCallback(hpcd, 0U);
2435 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2436
2437 if ((hpcd->USB_Address > 0U) && (ep->xfer_len == 0U))
2438 {
2439 hpcd->Instance->DADDR = ((uint16_t)hpcd->USB_Address | USB_DADDR_EF);
2440 hpcd->USB_Address = 0U;
2441 }
2442 }
2443 else
2444 {
2445 /* DIR = 1 */
2446
2447 /* DIR = 1 & CTR_RX => SETUP or OUT int */
2448 /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
2449 ep = &hpcd->OUT_ep[0];
2450 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
2451
2452 if ((wEPVal & USB_EP_SETUP) != 0U)
2453 {
2454 /* Get SETUP Packet */
2455 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
2456
2457 USB_ReadPMA(hpcd->Instance, (uint8_t *)hpcd->Setup,
2458 ep->pmaadress, (uint16_t)ep->xfer_count);
2459
2460 /* SETUP bit kept frozen while CTR_RX = 1 */
2461 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
2462
2463 /* Process SETUP Packet*/
2464 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2465 hpcd->SetupStageCallback(hpcd);
2466 #else
2467 HAL_PCD_SetupStageCallback(hpcd);
2468 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2469 }
2470 else if ((wEPVal & USB_EP_CTR_RX) != 0U)
2471 {
2472 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
2473
2474 /* Get Control Data OUT Packet */
2475 ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
2476
2477 if ((ep->xfer_count != 0U) && (ep->xfer_buff != 0U))
2478 {
2479 USB_ReadPMA(hpcd->Instance, ep->xfer_buff,
2480 ep->pmaadress, (uint16_t)ep->xfer_count);
2481
2482 ep->xfer_buff += ep->xfer_count;
2483
2484 /* Process Control Data OUT Packet */
2485 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2486 hpcd->DataOutStageCallback(hpcd, 0U);
2487 #else
2488 HAL_PCD_DataOutStageCallback(hpcd, 0U);
2489 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2490 }
2491
2492 wEPVal = (uint16_t)PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
2493
2494 if (((wEPVal & USB_EP_SETUP) == 0U) && ((wEPVal & USB_EP_RX_STRX) != USB_EP_RX_VALID))
2495 {
2496 PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
2497 }
2498 }
2499 }
2500 }
2501 else
2502 {
2503 /* Decode and service non control endpoints interrupt */
2504 /* process related endpoint register */
2505 wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, epindex);
2506
2507 if ((wEPVal & USB_EP_CTR_RX) != 0U)
2508 {
2509 /* clear int flag */
2510 PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
2511 ep = &hpcd->OUT_ep[epindex];
2512
2513 /* OUT Single Buffering */
2514 if (ep->doublebuffer == 0U)
2515 {
2516 count = (uint16_t)PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
2517
2518 if (count != 0U)
2519 {
2520 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
2521 }
2522 }
2523 #if (USE_USB_DOUBLE_BUFFER == 1U)
2524 else
2525 {
2526 /* manage double buffer bulk out */
2527 if (ep->type == EP_TYPE_BULK)
2528 {
2529 count = HAL_PCD_EP_DB_Receive(hpcd, ep, wEPVal);
2530 }
2531 else /* manage double buffer iso out */
2532 {
2533 /* free EP OUT Buffer */
2534 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
2535
2536 if ((PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX) != 0U)
2537 {
2538 /* read from endpoint BUF0Addr buffer */
2539 count = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
2540
2541 if (count != 0U)
2542 {
2543 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
2544 }
2545 }
2546 else
2547 {
2548 /* read from endpoint BUF1Addr buffer */
2549 count = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
2550
2551 if (count != 0U)
2552 {
2553 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
2554 }
2555 }
2556 }
2557 }
2558 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
2559
2560 /* multi-packet on the NON control OUT endpoint */
2561 ep->xfer_count += count;
2562 ep->xfer_buff += count;
2563
2564 if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
2565 {
2566 /* RX COMPLETE */
2567 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2568 hpcd->DataOutStageCallback(hpcd, ep->num);
2569 #else
2570 HAL_PCD_DataOutStageCallback(hpcd, ep->num);
2571 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2572 }
2573 else
2574 {
2575 (void)USB_EPStartXfer(hpcd->Instance, ep);
2576 }
2577 }
2578
2579 if ((wEPVal & USB_EP_CTR_TX) != 0U)
2580 {
2581 ep = &hpcd->IN_ep[epindex];
2582
2583 /* clear int flag */
2584 PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
2585
2586 if (ep->type == EP_TYPE_ISOC)
2587 {
2588 ep->xfer_len = 0U;
2589
2590 #if (USE_USB_DOUBLE_BUFFER == 1U)
2591 if (ep->doublebuffer != 0U)
2592 {
2593 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
2594 {
2595 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2596 }
2597 else
2598 {
2599 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2600 }
2601 }
2602 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
2603
2604 /* TX COMPLETE */
2605 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2606 hpcd->DataInStageCallback(hpcd, ep->num);
2607 #else
2608 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2609 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2610 }
2611 else
2612 {
2613 /* Manage Single Buffer Transaction */
2614 if ((wEPVal & USB_EP_KIND) == 0U)
2615 {
2616 /* Multi-packet on the NON control IN endpoint */
2617 TxPctSize = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
2618
2619 if (ep->xfer_len > TxPctSize)
2620 {
2621 ep->xfer_len -= TxPctSize;
2622 }
2623 else
2624 {
2625 ep->xfer_len = 0U;
2626 }
2627
2628 /* Zero Length Packet? */
2629 if (ep->xfer_len == 0U)
2630 {
2631 /* TX COMPLETE */
2632 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2633 hpcd->DataInStageCallback(hpcd, ep->num);
2634 #else
2635 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2636 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2637 }
2638 else
2639 {
2640 /* Transfer is not yet Done */
2641 ep->xfer_buff += TxPctSize;
2642 ep->xfer_count += TxPctSize;
2643 (void)USB_EPStartXfer(hpcd->Instance, ep);
2644 }
2645 }
2646 #if (USE_USB_DOUBLE_BUFFER == 1U)
2647 /* Double Buffer bulk IN (bulk transfer Len > Ep_Mps) */
2648 else
2649 {
2650 (void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
2651 }
2652 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
2653 }
2654 }
2655 }
2656 }
2657
2658 return HAL_OK;
2659 }
2660
2661
2662 #if (USE_USB_DOUBLE_BUFFER == 1U)
2663 /**
2664 * @brief Manage double buffer bulk out transaction from ISR
2665 * @param hpcd PCD handle
2666 * @param ep current endpoint handle
2667 * @param wEPVal Last snapshot of EPRx register value taken in ISR
2668 * @retval HAL status
2669 */
HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef * hpcd,PCD_EPTypeDef * ep,uint16_t wEPVal)2670 static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd,
2671 PCD_EPTypeDef *ep, uint16_t wEPVal)
2672 {
2673 uint16_t count;
2674
2675 /* Manage Buffer0 OUT */
2676 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
2677 {
2678 /* Get count of received Data on buffer0 */
2679 count = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
2680
2681 if (ep->xfer_len >= count)
2682 {
2683 ep->xfer_len -= count;
2684 }
2685 else
2686 {
2687 ep->xfer_len = 0U;
2688 }
2689
2690 if (ep->xfer_len == 0U)
2691 {
2692 /* Set NAK to OUT endpoint since double buffer is enabled */
2693 PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_NAK);
2694 }
2695
2696 /* Check if Buffer1 is in blocked state which requires to toggle */
2697 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
2698 {
2699 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
2700 }
2701
2702 if (count != 0U)
2703 {
2704 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
2705 }
2706 }
2707 /* Manage Buffer 1 DTOG_RX=0 */
2708 else
2709 {
2710 /* Get count of received data */
2711 count = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
2712
2713 if (ep->xfer_len >= count)
2714 {
2715 ep->xfer_len -= count;
2716 }
2717 else
2718 {
2719 ep->xfer_len = 0U;
2720 }
2721
2722 if (ep->xfer_len == 0U)
2723 {
2724 /* Set NAK on the current endpoint */
2725 PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_NAK);
2726 }
2727
2728 /* Need to FreeUser Buffer */
2729 if ((wEPVal & USB_EP_DTOG_TX) == 0U)
2730 {
2731 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
2732 }
2733
2734 if (count != 0U)
2735 {
2736 USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
2737 }
2738 }
2739
2740 return count;
2741 }
2742
2743
2744 /**
2745 * @brief Manage double buffer bulk IN transaction from ISR
2746 * @param hpcd PCD handle
2747 * @param ep current endpoint handle
2748 * @param wEPVal Last snapshot of EPRx register value taken in ISR
2749 * @retval HAL status
2750 */
HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef * hpcd,PCD_EPTypeDef * ep,uint16_t wEPVal)2751 static HAL_StatusTypeDef HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef *hpcd,
2752 PCD_EPTypeDef *ep, uint16_t wEPVal)
2753 {
2754 uint32_t len;
2755 uint16_t TxPctSize;
2756
2757 /* Data Buffer0 ACK received */
2758 if ((wEPVal & USB_EP_DTOG_TX) != 0U)
2759 {
2760 /* multi-packet on the NON control IN endpoint */
2761 TxPctSize = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
2762
2763 if (ep->xfer_len > TxPctSize)
2764 {
2765 ep->xfer_len -= TxPctSize;
2766 }
2767 else
2768 {
2769 ep->xfer_len = 0U;
2770 }
2771
2772 /* Transfer is completed */
2773 if (ep->xfer_len == 0U)
2774 {
2775 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2776 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2777
2778 if (ep->type == EP_TYPE_BULK)
2779 {
2780 /* Set Bulk endpoint in NAK state */
2781 PCD_SET_EP_TX_STATUS(hpcd->Instance, ep->num, USB_EP_TX_NAK);
2782 }
2783
2784 /* TX COMPLETE */
2785 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2786 hpcd->DataInStageCallback(hpcd, ep->num);
2787 #else
2788 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2789 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2790
2791 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
2792 {
2793 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2794 }
2795
2796 return HAL_OK;
2797 }
2798 else /* Transfer is not yet Done */
2799 {
2800 /* Need to Free USB Buffer */
2801 if ((wEPVal & USB_EP_DTOG_RX) != 0U)
2802 {
2803 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2804 }
2805
2806 /* Still there is data to Fill in the next Buffer */
2807 if (ep->xfer_fill_db == 1U)
2808 {
2809 ep->xfer_buff += TxPctSize;
2810 ep->xfer_count += TxPctSize;
2811
2812 /* Calculate the len of the new buffer to fill */
2813 if (ep->xfer_len_db >= ep->maxpacket)
2814 {
2815 len = ep->maxpacket;
2816 ep->xfer_len_db -= len;
2817 }
2818 else if (ep->xfer_len_db == 0U)
2819 {
2820 len = TxPctSize;
2821 ep->xfer_fill_db = 0U;
2822 }
2823 else
2824 {
2825 ep->xfer_fill_db = 0U;
2826 len = ep->xfer_len_db;
2827 ep->xfer_len_db = 0U;
2828 }
2829
2830 /* Write remaining Data to Buffer */
2831 /* Set the Double buffer counter for pma buffer0 */
2832 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, len);
2833
2834 /* Copy user buffer to USB PMA */
2835 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, (uint16_t)len);
2836 }
2837 }
2838 }
2839 else /* Data Buffer1 ACK received */
2840 {
2841 /* multi-packet on the NON control IN endpoint */
2842 TxPctSize = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
2843
2844 if (ep->xfer_len >= TxPctSize)
2845 {
2846 ep->xfer_len -= TxPctSize;
2847 }
2848 else
2849 {
2850 ep->xfer_len = 0U;
2851 }
2852
2853 /* Transfer is completed */
2854 if (ep->xfer_len == 0U)
2855 {
2856 PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2857 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
2858
2859 if (ep->type == EP_TYPE_BULK)
2860 {
2861 /* Set Bulk endpoint in NAK state */
2862 PCD_SET_EP_TX_STATUS(hpcd->Instance, ep->num, USB_EP_TX_NAK);
2863 }
2864
2865 /* TX COMPLETE */
2866 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
2867 hpcd->DataInStageCallback(hpcd, ep->num);
2868 #else
2869 HAL_PCD_DataInStageCallback(hpcd, ep->num);
2870 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
2871
2872 /* need to Free USB Buff */
2873 if ((wEPVal & USB_EP_DTOG_RX) == 0U)
2874 {
2875 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2876 }
2877
2878 return HAL_OK;
2879 }
2880 else /* Transfer is not yet Done */
2881 {
2882 /* Need to Free USB Buffer */
2883 if ((wEPVal & USB_EP_DTOG_RX) == 0U)
2884 {
2885 PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
2886 }
2887
2888 /* Still there is data to Fill in the next Buffer */
2889 if (ep->xfer_fill_db == 1U)
2890 {
2891 ep->xfer_buff += TxPctSize;
2892 ep->xfer_count += TxPctSize;
2893
2894 /* Calculate the len of the new buffer to fill */
2895 if (ep->xfer_len_db >= ep->maxpacket)
2896 {
2897 len = ep->maxpacket;
2898 ep->xfer_len_db -= len;
2899 }
2900 else if (ep->xfer_len_db == 0U)
2901 {
2902 len = TxPctSize;
2903 ep->xfer_fill_db = 0U;
2904 }
2905 else
2906 {
2907 len = ep->xfer_len_db;
2908 ep->xfer_len_db = 0U;
2909 ep->xfer_fill_db = 0;
2910 }
2911
2912 /* Set the Double buffer counter for pma buffer1 */
2913 PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, len);
2914
2915 /* Copy the user buffer to USB PMA */
2916 USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, (uint16_t)len);
2917 }
2918 }
2919 }
2920
2921 /* Enable endpoint IN */
2922 PCD_SET_EP_TX_STATUS(hpcd->Instance, ep->num, USB_EP_TX_VALID);
2923
2924 return HAL_OK;
2925 }
2926 #endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
2927 #endif /* defined (USB) */
2928
2929 /**
2930 * @}
2931 */
2932 #endif /* defined (USB) || defined (USB_OTG_FS) */
2933 #endif /* HAL_PCD_MODULE_ENABLED */
2934 /**
2935 * @}
2936 */
2937
2938 /**
2939 * @}
2940 */
2941
