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