1 /**
2 **************************************************************************
3 * @file usbd_int.c
4 * @brief usb interrupt request
5 **************************************************************************
6 * Copyright notice & Disclaimer
7 *
8 * The software Board Support Package (BSP) that is made available to
9 * download from Artery official website is the copyrighted work of Artery.
10 * Artery authorizes customers to use, copy, and distribute the BSP
11 * software and its related documentation for the purpose of design and
12 * development in conjunction with Artery microcontrollers. Use of the
13 * software is governed by this copyright notice and the following disclaimer.
14 *
15 * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
16 * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
17 * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
18 * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
19 * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
21 *
22 **************************************************************************
23 */
24 #include "usbd_int.h"
25
26 /** @defgroup USBD_drivers_interrupt
27 * @brief usb device interrupt
28 * @{
29 */
30
31 /** @defgroup USBD_int_private_functions
32 * @{
33 */
34
35 #ifdef USE_OTG_DEVICE_MODE
36 #ifndef USB_OTG_DOEPINT_STSPHRCVD_FLAG
37 #define USB_OTG_DOEPINT_STSPHRCVD_FLAG ((uint32_t)0x00000020) /*!< status phase received for control write */
38 #endif
39
40 #ifndef USB_OTG_DOEPINT_STUPPKTRCVD_FLAG
41 #define USB_OTG_DOEPINT_STUPPKTRCVD_FLAG ((uint32_t)0x00008000) /*!< setup packet recived */
42 #endif
43
44 /**
45 * @brief usb device interrput request handler.
46 * @param otgdev: to the structure of otg_core_type
47 * @retval none
48 */
usbd_irq_handler(otg_core_type * otgdev)49 void usbd_irq_handler(otg_core_type *otgdev)
50 {
51 otg_global_type *usbx = otgdev->usb_reg;
52 usbd_core_type *udev = &otgdev->dev;
53 uint32_t intsts = usb_global_get_all_interrupt(usbx);
54
55 /* check current device mode */
56 if(usbx->gintsts_bit.curmode == 0)
57 {
58 /* mode mismatch interrupt */
59 if(intsts & USB_OTG_MODEMIS_FLAG)
60 {
61 usb_global_clear_interrupt(usbx, USB_OTG_MODEMIS_FLAG);
62 }
63
64 /* in endpoint interrupt */
65 if(intsts & USB_OTG_IEPT_FLAG)
66 {
67 usbd_inept_handler(udev);
68 }
69
70 /* out endpoint interrupt */
71 if(intsts & USB_OTG_OEPT_FLAG)
72 {
73 usbd_outept_handler(udev);
74 }
75
76 /* usb reset interrupt */
77 if(intsts & USB_OTG_USBRST_FLAG)
78 {
79 usbd_reset_handler(udev);
80 usbd_connectCallback(udev);
81 usb_global_clear_interrupt(usbx, USB_OTG_USBRST_FLAG);
82 }
83
84 /* sof interrupt */
85 if(intsts & USB_OTG_SOF_FLAG)
86 {
87 usbd_sof_handler(udev);
88 usbd_sof_callback(udev);
89 usb_global_clear_interrupt(usbx, USB_OTG_SOF_FLAG);
90 }
91
92 /* enumeration done interrupt */
93 if(intsts & USB_OTG_ENUMDONE_FLAG)
94 {
95 usbd_enumdone_handler(udev);
96 usb_global_clear_interrupt(usbx, USB_OTG_ENUMDONE_FLAG);
97 }
98
99 /* rx non-empty interrupt, indicates that there is at least one
100 data packet pending to be read in rx fifo */
101 if(intsts & USB_OTG_RXFLVL_FLAG)
102 {
103 usbd_rxflvl_handler(udev);
104 }
105
106 /* incomplete isochronous in transfer interrupt */
107 if(intsts & USB_OTG_INCOMISOIN_FLAG)
108 {
109 usbd_incomisioin_handler(udev);
110 usb_global_clear_interrupt(usbx, USB_OTG_INCOMISOIN_FLAG);
111 }
112 #ifndef USB_VBUS_IGNORE
113 /* disconnect detected interrupt */
114 if(intsts & USB_OTG_OTGINT_FLAG)
115 {
116 uint32_t tmp = udev->usb_reg->gotgint;
117 if(udev->usb_reg->gotgint_bit.sesenddet)
118 usbd_disconnectCallback(udev);
119 udev->usb_reg->gotgint = tmp;
120 usb_global_clear_interrupt(usbx, USB_OTG_OTGINT_FLAG);
121 }
122 #endif
123 /* incomplete isochronous out transfer interrupt */
124 if(intsts & USB_OTG_INCOMPIP_INCOMPISOOUT_FLAG)
125 {
126 usbd_incomisoout_handler(udev);
127 usb_global_clear_interrupt(usbx, USB_OTG_INCOMPIP_INCOMPISOOUT_FLAG);
128 }
129
130 /* resume/remote wakeup interrupt */
131 if(intsts & USB_OTG_WKUP_FLAG)
132 {
133 usbd_wakeup_handler(udev);
134 usb_global_clear_interrupt(usbx, USB_OTG_WKUP_FLAG);
135 }
136
137 /* usb suspend interrupt */
138 if(intsts & USB_OTG_USBSUSP_FLAG)
139 {
140 usbd_suspend_handler(udev);
141 usb_global_clear_interrupt(usbx, USB_OTG_USBSUSP_FLAG);
142 }
143 }
144 }
145
146 /**
147 * @brief usb write tx fifo.
148 * @param udev: to the structure of usbd_core_type
149 * @param ept_num: endpoint number
150 * @retval none
151 */
usb_write_empty_txfifo(usbd_core_type * udev,uint32_t ept_num)152 void usb_write_empty_txfifo(usbd_core_type *udev, uint32_t ept_num)
153 {
154 otg_global_type *usbx = udev->usb_reg;
155 usb_ept_info *ept_info = &udev->ept_in[ept_num];
156 uint32_t length = ept_info->total_len - ept_info->trans_len;
157 uint32_t wlen = 0;
158
159 if(length > ept_info->maxpacket)
160 {
161 length = ept_info->maxpacket;
162 }
163 wlen = (length + 3) / 4;
164
165 while((USB_INEPT(usbx, ept_num)->dtxfsts & USB_OTG_DTXFSTS_INEPTFSAV) > wlen &&
166 (ept_info->trans_len < ept_info->total_len) && (ept_info->total_len != 0))
167 {
168 length = ept_info->total_len - ept_info->trans_len;
169 if(length > ept_info->maxpacket)
170 {
171 length = ept_info->maxpacket;
172 }
173 wlen = (length + 3) / 4;
174 usb_write_packet(usbx, ept_info->trans_buf, ept_num, length);
175
176 ept_info->trans_buf += length;
177 ept_info->trans_len += length;
178
179 }
180 if(length <= 0)
181 {
182 OTG_DEVICE(usbx)->diepempmsk &= ~(0x1 << ept_num);
183 }
184 }
185
186
187 /**
188 * @brief usb in endpoint handler
189 * @param udev: to the structure of usbd_core_type
190 * @retval none
191 */
usbd_inept_handler(usbd_core_type * udev)192 void usbd_inept_handler(usbd_core_type *udev)
193 {
194 otg_global_type *usbx = udev->usb_reg;
195 uint32_t ept_num = 0, ept_int;
196 uint32_t intsts;
197 #ifdef OTG_USE_DMA
198 usb_ept_info *ept_info;
199 #endif
200 /*get all endpoint interrut */
201 intsts = usb_get_all_in_interrupt(usbx);
202 while(intsts)
203 {
204 if(intsts & 0x1)
205 {
206 /* get endpoint interrupt flag */
207 ept_int = usb_ept_in_interrupt(usbx, ept_num);
208
209 /* transfer completed interrupt */
210 if(ept_int & USB_OTG_DIEPINT_XFERC_FLAG)
211 {
212 OTG_DEVICE(usbx)->diepempmsk &= ~(1 << ept_num);
213 usb_ept_in_clear(usbx, ept_num , USB_OTG_DIEPINT_XFERC_FLAG);
214 #ifdef OTG_USE_DMA
215 if(udev->dma_en == TRUE)
216 {
217 ept_info = &udev->ept_in[ept_num];
218 ept_info->trans_buf += ept_info->maxpacket;
219
220 if((ept_num == 0) && (udev->ept_in[ept_num].total_len == 0))
221 {
222 usb_ept0_start(udev->usb_reg);
223 usbd_ept0_out_dma_set(udev);
224 }
225 }
226 #endif
227 usbd_data_in_stage_callback(udev, ept_num);
228 }
229
230 /* timeout condition interrupt */
231 if(ept_int & USB_OTG_DIEPINT_TIMEOUT_FLAG)
232 {
233 usb_ept_in_clear(usbx, ept_num , USB_OTG_DIEPINT_TIMEOUT_FLAG);
234 }
235
236 /* in token received when tx fifo is empty */
237 if(ept_int & USB_OTG_DIEPINT_INTKNTXFEMP_FLAG)
238 {
239 usb_ept_in_clear(usbx, ept_num , USB_OTG_DIEPINT_INTKNTXFEMP_FLAG);
240 }
241
242 /* in endpoint nak effective */
243 if(ept_int & USB_OTG_DIEPINT_INEPTNAK_FLAG)
244 {
245 usb_ept_in_clear(usbx, ept_num , USB_OTG_DIEPINT_INEPTNAK_FLAG);
246 }
247
248 /* endpoint disable interrupt */
249 if(ept_int & USB_OTG_DIEPINT_EPTDISD_FLAG)
250 {
251 usb_ept_in_clear(usbx, ept_num , USB_OTG_DIEPINT_EPTDISD_FLAG);
252 }
253
254 /* transmit fifo empty interrupt */
255 if(ept_int & USB_OTG_DIEPINT_TXFEMP_FLAG)
256 {
257 usb_write_empty_txfifo(udev, ept_num);
258 }
259 }
260 ept_num ++;
261 intsts >>= 1;
262 }
263 }
264
265 /**
266 * @brief usb out endpoint handler
267 * @param udev: to the structure of usbd_core_type
268 * @retval none
269 */
usbd_outept_handler(usbd_core_type * udev)270 void usbd_outept_handler(usbd_core_type *udev)
271 {
272 otg_global_type *usbx = udev->usb_reg;
273 uint32_t ept_num = 0, ept_int;
274 uint32_t intsts, epsts;
275 #ifdef OTG_USE_DMA
276 usb_ept_info *ept_info;
277 #endif
278 /* get all out endpoint interrupt */
279 intsts = usb_get_all_out_interrupt(usbx);
280
281 while(intsts)
282 {
283 if(intsts & 0x1)
284 {
285 /* get out endpoint interrupt */
286 ept_int = usb_ept_out_interrupt(usbx, ept_num);
287 #ifdef OTG_USE_DMA
288 ept_info = &udev->ept_out[ept_num];
289 #endif
290 /* transfer completed interrupt */
291 if(ept_int & USB_OTG_DOEPINT_XFERC_FLAG)
292 {
293 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_XFERC_FLAG);
294 epsts = USB_OUTEPT(usbx, ept_num)->doepint;
295 #ifdef OTG_USE_DMA
296 if (udev->dma_en == TRUE)
297 {
298 if((epsts & USB_OTG_DOEPINT_SETUP_FLAG) == USB_OTG_DOEPINT_SETUP_FLAG)
299 {
300 if((epsts & USB_OTG_DOEPINT_STUPPKTRCVD_FLAG) == USB_OTG_DOEPINT_STUPPKTRCVD_FLAG)
301 {
302 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_STUPPKTRCVD_FLAG);
303 }
304 }
305 else if((epsts & USB_OTG_DOEPINT_STSPHRCVD_FLAG) == USB_OTG_DOEPINT_STSPHRCVD_FLAG)
306 {
307 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_STSPHRCVD_FLAG);
308 }
309 else if((epsts & (USB_OTG_DOEPINT_SETUP_FLAG | USB_OTG_DOEPINT_STSPHRCVD_FLAG)) == 0)
310 {
311 if((epsts & USB_OTG_DOEPINT_STUPPKTRCVD_FLAG) == USB_OTG_DOEPINT_STUPPKTRCVD_FLAG)
312 {
313 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_STUPPKTRCVD_FLAG);
314 }
315 else
316 {
317 if(ept_info->total_len > ept_info->maxpacket)
318 {
319 ept_info->trans_len = ept_info->total_len - USB_OUTEPT(usbx, ept_num)->doeptsiz_bit.xfersize;
320 }
321 else
322 {
323 ept_info->trans_len = ept_info->maxpacket - USB_OUTEPT(usbx, ept_num)->doeptsiz_bit.xfersize;
324 }
325 ept_info->trans_buf += ept_info->trans_len;
326 if((ept_num == 0) && (udev->ept_out[ept_num].total_len == 0))
327 {
328 usb_ept0_start(udev->usb_reg);
329 usbd_ept0_out_dma_set(udev);
330 }
331 usbd_data_out_stage_callback(udev, ept_num);
332 }
333
334 }
335 }
336 else
337 #endif
338 {
339 if((ept_num == 0) && (udev->ept_out[ept_num].total_len == 0))
340 {
341 usb_ept0_start(udev->usb_reg);
342 }
343
344 usbd_data_out_stage_callback(udev, ept_num);
345 }
346 }
347
348 /* setup phase done interrupt */
349 if(ept_int & USB_OTG_DOEPINT_SETUP_FLAG)
350 {
351 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_SETUP_FLAG);
352 epsts = USB_OUTEPT(usbx, ept_num)->doepint;
353 if((epsts & USB_OTG_DOEPINT_STUPPKTRCVD_FLAG) == USB_OTG_DOEPINT_STUPPKTRCVD_FLAG)
354 {
355 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_STUPPKTRCVD_FLAG);
356 }
357 usbd_setup_phase_done_callback(udev);
358
359 if(udev->device_addr != 0)
360 {
361 OTG_DEVICE(udev->usb_reg)->dcfg_bit.devaddr = udev->device_addr;
362 udev->device_addr = 0;
363 }
364 #ifdef OTG_USE_DMA
365 if(udev->dma_en == TRUE)
366 {
367 usb_ept0_start(udev->usb_reg);
368 usbd_ept0_out_dma_set(udev);
369 }
370 #endif
371 }
372
373 /* endpoint disable interrupt */
374 if(ept_int & USB_OTG_DOEPINT_OUTTEPD_FLAG)
375 {
376 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_OUTTEPD_FLAG);
377 }
378 if(ept_int & USB_OTG_DOEPINT_STSPHRCVD_FLAG)
379 {
380 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_STSPHRCVD_FLAG);
381 }
382 if(ept_int & USB_OTG_DOEPINT_EPTDISD_FLAG)
383 {
384 usb_ept_out_clear(usbx, ept_num , USB_OTG_DOEPINT_EPTDISD_FLAG);
385 }
386
387 }
388 ept_num ++;
389 intsts >>= 1;
390 }
391 }
392
393 /**
394 * @brief usb enumeration done handler
395 * @param udev: to the structure of usbd_core_type
396 * @retval none
397 */
usbd_enumdone_handler(usbd_core_type * udev)398 void usbd_enumdone_handler(usbd_core_type *udev)
399 {
400 otg_global_type *usbx = udev->usb_reg;
401
402 if(OTG_DEVICE(usbx)->dsts_bit.enumspd == 0)
403 {
404 udev->speed = USB_HIGH_SPEED;
405 usbx->gusbcfg_bit.usbtrdtim = USB_TRDTIM_8;
406 }
407 else
408 {
409 udev->speed = USB_FULL_SPEED;
410 usbx->gusbcfg_bit.usbtrdtim = USB_TRDTIM_16;
411 }
412
413 /* close endpoint 0 */
414 usbd_ept_close(udev, 0x00);
415
416 /* close endpoint 0 */
417 usbd_ept_close(udev, 0x80);
418
419 /* open endpoint 0 out */
420 usbd_ept_open(udev, 0x00, EPT_CONTROL_TYPE, 0x40);
421
422 /* open endpoint 0 in */
423 usbd_ept_open(udev, 0x80, EPT_CONTROL_TYPE, 0x40);
424
425 usb_ept0_setup(usbx);
426
427 /* usb connect state set to default */
428 udev->conn_state = USB_CONN_STATE_DEFAULT;
429
430 /* clear callback */
431 usbd_reset_callback(udev);
432 }
433
434 /**
435 * @brief usb rx non-empty handler
436 * @param udev: to the structure of usbd_core_type
437 * @retval none
438 */
usbd_rxflvl_handler(usbd_core_type * udev)439 void usbd_rxflvl_handler(usbd_core_type *udev)
440 {
441 otg_global_type *usbx = udev->usb_reg;
442 uint32_t stsp;
443 uint32_t count;
444 uint32_t pktsts;
445 usb_ept_info *ept_info;
446
447 /* disable rxflvl interrupt */
448 usb_global_interrupt_enable(usbx, USB_OTG_RXFLVL_INT, FALSE);
449
450 /* get rx status */
451 stsp = usbx->grxstsp;
452
453 /*get the byte count of receive */
454 count = (stsp & USB_OTG_GRXSTSP_BCNT) >> 4;
455
456 /* get packet status */
457 pktsts = (stsp &USB_OTG_GRXSTSP_PKTSTS) >> 17;
458
459 /* get endpoint infomation struct */
460 ept_info = &udev->ept_out[stsp & USB_OTG_GRXSTSP_EPTNUM];
461
462 /* received out data packet */
463 if(pktsts == USB_OUT_STS_DATA)
464 {
465 if(count != 0)
466 {
467 /* read packet to buffer */
468 usb_read_packet(usbx, ept_info->trans_buf, (stsp & USB_OTG_GRXSTSP_EPTNUM), count);
469 ept_info->trans_buf += count;
470 ept_info->trans_len += count;
471
472 }
473 }
474 /* setup data received */
475 else if ( pktsts == USB_SETUP_STS_DATA)
476 {
477 /* read packet to buffer */
478 usb_read_packet(usbx, (uint8_t *)udev->setup_buffer, (stsp & USB_OTG_GRXSTSP_EPTNUM), count);
479 ept_info->trans_len += count;
480 }
481
482 /* enable rxflvl interrupt */
483 usb_global_interrupt_enable(usbx, USB_OTG_RXFLVL_INT, TRUE);
484
485 }
486
487 /**
488 * @brief usb disconnect handler
489 * @param udev: to the structure of usbd_core_type
490 * @retval none
491 */
usbd_discon_handler(usbd_core_type * udev)492 void usbd_discon_handler(usbd_core_type *udev)
493 {
494 /* disconnect callback handler */
495 if(udev->class_handler->event_handler != 0)
496 udev->class_handler->event_handler(udev, USBD_DISCONNECT_EVNET);
497 }
498
499
500 /**
501 * @brief usb incomplete out handler
502 * @param udev: to the structure of usbd_core_type
503 * @retval none
504 */
usbd_incomisoout_handler(usbd_core_type * udev)505 void usbd_incomisoout_handler(usbd_core_type *udev)
506 {
507 if(udev->class_handler->event_handler != 0)
508 udev->class_handler->event_handler(udev, USBD_OUTISOINCOM_EVENT);
509 }
510
511 /**
512 * @brief usb incomplete in handler
513 * @param udev: to the structure of usbd_core_type
514 * @retval none
515 */
usbd_incomisioin_handler(usbd_core_type * udev)516 void usbd_incomisioin_handler(usbd_core_type *udev)
517 {
518 if(udev->class_handler->event_handler != 0)
519 udev->class_handler->event_handler(udev, USBD_INISOINCOM_EVENT);
520 }
521
522 /**
523 * @brief usb device reset interrupt request handler.
524 * @param udev: to the structure of usbd_core_type
525 * @retval none
526 */
usbd_reset_handler(usbd_core_type * udev)527 void usbd_reset_handler(usbd_core_type *udev)
528 {
529 otg_global_type *usbx = udev->usb_reg;
530 otg_device_type *dev = OTG_DEVICE(usbx);
531 uint32_t i_index = 0;
532
533 /* disable remote wakeup singal */
534 dev->dctl_bit.rwkupsig = FALSE;
535
536 /* endpoint fifo alloc */
537 usbd_fifo_alloc(udev);
538
539 /* flush all tx fifo */
540 usb_flush_tx_fifo(usbx, 0x10);
541
542 /* clear in and out endpoint interrupt flag */
543 for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
544 {
545 USB_INEPT(usbx, i_index)->diepint = 0xFF;
546 USB_OUTEPT(usbx, i_index)->doepint = 0xFF;
547 }
548
549 /* clear endpoint flag */
550 dev->daint = 0xFFFFFFFF;
551
552 /*clear endpoint interrupt mask */
553 dev->daintmsk = 0x10001;
554
555 /* enable out endpoint xfer, eptdis, setup interrupt mask */
556 dev->doepmsk_bit.xfercmsk = TRUE;
557 dev->doepmsk_bit.eptdismsk = TRUE;
558 dev->doepmsk_bit.setupmsk = TRUE;
559
560 /* enable in endpoint xfer, eptdis, timeout interrupt mask */
561 dev->diepmsk_bit.xfercmsk = TRUE;
562 dev->diepmsk_bit.eptdismsk = TRUE;
563 dev->diepmsk_bit.timeoutmsk = TRUE;
564
565 #ifdef USB_SUPPORT_EPT1_INTERRUPT
566 dev->diepeachmsk1_bit.xfercmsk = TRUE;
567 dev->diepeachmsk1_bit.eptdismsk = TRUE;
568 dev->diepeachmsk1_bit.timeoutmsk = TRUE;
569
570 dev->doepeachmsk1_bit.xfercmsk = TRUE;
571 dev->doepeachmsk1_bit.eptdismsk = TRUE;
572 #endif
573 /* set device address to 0 */
574 usb_set_address(usbx, 0);
575
576 /* enable endpoint 0 */
577 usb_ept0_start(usbx);
578 #ifdef OTG_USE_DMA
579 if(udev->dma_en == TRUE)
580 {
581 usbd_ept0_out_dma_set(udev);
582 }
583 #endif
584
585 /* usb connect state set to default */
586 udev->conn_state = USB_CONN_STATE_DEFAULT;
587
588 /* user define reset event */
589 if(udev->class_handler->event_handler)
590 udev->class_handler->event_handler(udev, USBD_RESET_EVENT);
591 }
592
593 /**
594 * @brief usb device sof interrupt request handler.
595 * @param udev: to the structure of usbd_core_type
596 * @retval none
597 */
usbd_sof_handler(usbd_core_type * udev)598 void usbd_sof_handler(usbd_core_type *udev)
599 {
600 /* user sof handler in class define */
601 if(udev->class_handler->sof_handler)
602 udev->class_handler->sof_handler(udev);
603 }
604
605 /**
606 * @brief usb device suspend interrupt request handler.
607 * @param udev: to the structure of usbd_core_type
608 * @retval none
609 */
usbd_suspend_handler(usbd_core_type * udev)610 void usbd_suspend_handler(usbd_core_type *udev)
611 {
612 otg_global_type *usbx = udev->usb_reg;
613
614 if(OTG_DEVICE(usbx)->dsts_bit.suspsts)
615 {
616 /* save connect state */
617 udev->old_conn_state = udev->conn_state;
618
619 /* set current state to suspend */
620 udev->conn_state = USB_CONN_STATE_SUSPENDED;
621
622 /* enter suspend mode */
623 usbd_enter_suspend(udev);
624
625 /* user suspend handler */
626 if(udev->class_handler->event_handler != 0)
627 udev->class_handler->event_handler(udev, USBD_SUSPEND_EVENT);
628 }
629 }
630
631 /**
632 * @brief usb device wakup interrupt request handler.
633 * @param udev: to the structure of usbd_core_type
634 * @retval none
635 */
usbd_wakeup_handler(usbd_core_type * udev)636 void usbd_wakeup_handler(usbd_core_type *udev)
637 {
638 otg_global_type *usbx = udev->usb_reg;
639
640 /* clear remote wakeup bit */
641 OTG_DEVICE(usbx)->dctl_bit.rwkupsig = FALSE;
642
643 /* exit suspend mode */
644 usb_open_phy_clk(udev->usb_reg);
645
646 /* restore connect state */
647 udev->conn_state = udev->old_conn_state;
648
649 /* user suspend handler */
650 if(udev->class_handler->event_handler != 0)
651 udev->class_handler->event_handler(udev, USBD_WAKEUP_EVENT);
652 }
653
usbd_reset_callback(usbd_core_type * udev)654 rt_weak void usbd_reset_callback(usbd_core_type *udev)
655 {
656 }
657
usbd_setup_phase_done_callback(usbd_core_type * udev)658 rt_weak void usbd_setup_phase_done_callback(usbd_core_type *udev)
659 {
660 }
661
usbd_data_in_stage_callback(usbd_core_type * udev,uint32_t ept_num)662 rt_weak void usbd_data_in_stage_callback(usbd_core_type *udev, uint32_t ept_num)
663 {
664 }
665
usbd_sof_callback(usbd_core_type * udev)666 rt_weak void usbd_sof_callback(usbd_core_type *udev)
667 {
668 }
669
usbd_data_out_stage_callback(usbd_core_type * udev,uint32_t ept_num)670 rt_weak void usbd_data_out_stage_callback(usbd_core_type *udev, uint32_t ept_num)
671 {
672 }
673
usbd_connectCallback(usbd_core_type * udev)674 rt_weak void usbd_connectCallback(usbd_core_type *udev)
675 {
676 }
677
usbd_disconnectCallback(usbd_core_type * udev)678 rt_weak void usbd_disconnectCallback(usbd_core_type *udev)
679 {
680 }
681
682 #endif
683
684 /**
685 * @}
686 */
687
688 /**
689 * @}
690 */
691