M480 BSP V3.05.005
The Board Support Package for M480 Series
hsusbd.c
Go to the documentation of this file.
1/**************************************************************************/
9#include <stdio.h>
10#include "NuMicro.h"
11
24/*--------------------------------------------------------------------------*/
26/* Global variables for Control Pipe */
27S_HSUSBD_CMD_T gUsbCmd;
28S_HSUSBD_INFO_T *g_hsusbd_sInfo;
29
30HSUSBD_VENDOR_REQ g_hsusbd_pfnVendorRequest = NULL;
31HSUSBD_CLASS_REQ g_hsusbd_pfnClassRequest = NULL;
32HSUSBD_SET_INTERFACE_REQ g_hsusbd_pfnSetInterface = NULL;
33uint32_t g_u32HsEpStallLock = 0ul; /* Bit map flag to lock specified EP when SET_FEATURE */
34
35static uint8_t *g_hsusbd_CtrlInPointer = 0;
36static uint32_t g_hsusbd_CtrlMaxPktSize = 64ul;
37static uint8_t g_hsusbd_UsbConfig = 0ul;
38static uint8_t g_hsusbd_UsbAltInterface = 0ul;
39static uint8_t g_hsusbd_EnableTestMode = 0ul;
40static uint8_t g_hsusbd_TestSelector = 0ul;
41
42uint8_t volatile g_hsusbd_RemoteWakeupEn = 0ul;
44#ifdef __ICCARM__
45#pragma data_alignment=4
46static uint8_t g_hsusbd_buf[12];
47#else
48static uint8_t g_hsusbd_buf[12] __attribute__((aligned(4)));
49#endif
50
51uint8_t volatile g_hsusbd_Configured = 0ul;
52uint8_t g_hsusbd_CtrlZero = 0ul;
53uint8_t g_hsusbd_UsbAddr = 0ul;
54uint8_t g_hsusbd_ShortPacket = 0ul;
55uint32_t volatile g_hsusbd_DmaDone = 0ul;
56uint32_t g_hsusbd_CtrlInSize = 0ul;
70void HSUSBD_Open(S_HSUSBD_INFO_T *param, HSUSBD_CLASS_REQ pfnClassReq, HSUSBD_SET_INTERFACE_REQ pfnSetInterface)
71{
72 g_hsusbd_sInfo = param;
73 g_hsusbd_pfnClassRequest = pfnClassReq;
74 g_hsusbd_pfnSetInterface = pfnSetInterface;
75
76 /* get EP0 maximum packet size */
77 g_hsusbd_CtrlMaxPktSize = g_hsusbd_sInfo->gu8DevDesc[7];
78
79 /* Initial USB engine */
81
82 /* wait PHY clock ready */
83 while (1)
84 {
85 HSUSBD->EP[EPA].EPMPS = 0x20ul;
86 if (HSUSBD->EP[EPA].EPMPS == 0x20ul)
87 {
88 HSUSBD->EP[EPA].EPMPS = 0x0ul;
89 break;
90 }
91 }
92 HSUSBD->OPER &= ~HSUSBD_OPER_HISPDEN_Msk; /* full-speed */
93}
94
104void HSUSBD_Start(void)
105{
106 HSUSBD->OPER = HSUSBD_OPER_HISPDEN_Msk; /* high-speed */
108}
109
120{
121 /* Setup packet process */
122 gUsbCmd.bmRequestType = (uint8_t)(HSUSBD->SETUP1_0 & 0xfful);
123 gUsbCmd.bRequest = (uint8_t)((HSUSBD->SETUP1_0 >> 8) & 0xfful);
124 gUsbCmd.wValue = (uint16_t)HSUSBD->SETUP3_2;
125 gUsbCmd.wIndex = (uint16_t)HSUSBD->SETUP5_4;
126 gUsbCmd.wLength = (uint16_t)HSUSBD->SETUP7_6;
127
128 /* USB device request in setup packet: offset 0, D[6..5]: 0=Standard, 1=Class, 2=Vendor, 3=Reserved */
129 switch (gUsbCmd.bmRequestType & 0x60ul)
130 {
131 case REQ_STANDARD:
132 {
134 break;
135 }
136 case REQ_CLASS:
137 {
138 if (g_hsusbd_pfnClassRequest != NULL)
139 {
140 g_hsusbd_pfnClassRequest();
141 }
142 break;
143 }
144 case REQ_VENDOR:
145 {
146 if (g_hsusbd_pfnVendorRequest != NULL)
147 {
148 g_hsusbd_pfnVendorRequest();
149 }
150 break;
151 }
152 default:
153 {
154 /* Setup error, stall the device */
156 break;
157 }
158 }
159}
160
171{
172 uint32_t u32Len;
173 int val = 0;
174
175 u32Len = gUsbCmd.wLength;
176 g_hsusbd_CtrlZero = (uint8_t)0ul;
177
178 switch ((gUsbCmd.wValue & 0xff00ul) >> 8)
179 {
180 /* Get Device Descriptor */
181 case DESC_DEVICE:
182 {
183 u32Len = Minimum(u32Len, LEN_DEVICE);
184 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8DevDesc, u32Len);
185 break;
186 }
187 /* Get Configuration Descriptor */
188 case DESC_CONFIG:
189 {
190 uint32_t u32TotalLen;
191 if ((HSUSBD->OPER & 0x04ul) == 0x04ul)
192 {
193 u32TotalLen = g_hsusbd_sInfo->gu8ConfigDesc[3];
194 u32TotalLen = g_hsusbd_sInfo->gu8ConfigDesc[2] + (u32TotalLen << 8);
195
196 if (u32Len > u32TotalLen)
197 {
198 u32Len = u32TotalLen;
199 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
200 {
201 g_hsusbd_CtrlZero = (uint8_t)1ul;
202 }
203 }
204 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8ConfigDesc, u32Len);
205 }
206 else
207 {
208 u32TotalLen = g_hsusbd_sInfo->gu8FullConfigDesc[3];
209 u32TotalLen = g_hsusbd_sInfo->gu8FullConfigDesc[2] + (u32TotalLen << 8);
210
211 if (u32Len > u32TotalLen)
212 {
213 u32Len = u32TotalLen;
214 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
215 {
216 g_hsusbd_CtrlZero = (uint8_t)1ul;
217 }
218 }
219 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8FullConfigDesc, u32Len);
220 }
221
222 break;
223 }
224 /* Get Qualifier Descriptor */
225 case DESC_QUALIFIER:
226 {
227 u32Len = Minimum(u32Len, LEN_QUALIFIER);
228 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8QualDesc, u32Len);
229 break;
230 }
231 /* Get Other Speed Descriptor - Full speed */
232 case DESC_OTHERSPEED:
233 {
234 uint32_t u32TotalLen;
235 if ((HSUSBD->OPER & 0x04ul) == 0x04ul)
236 {
237 u32TotalLen = g_hsusbd_sInfo->gu8HSOtherConfigDesc[3];
238 u32TotalLen = g_hsusbd_sInfo->gu8HSOtherConfigDesc[2] + (u32TotalLen << 8);
239
240 if (u32Len > u32TotalLen)
241 {
242 u32Len = u32TotalLen;
243 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
244 {
245 g_hsusbd_CtrlZero = (uint8_t)1ul;
246 }
247 }
248 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8HSOtherConfigDesc, u32Len);
249 }
250 else
251 {
252 u32TotalLen = g_hsusbd_sInfo->gu8FSOtherConfigDesc[3];
253 u32TotalLen = g_hsusbd_sInfo->gu8FSOtherConfigDesc[2] + (u32TotalLen << 8);
254
255 if (u32Len > u32TotalLen)
256 {
257 u32Len = u32TotalLen;
258 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
259 {
260 g_hsusbd_CtrlZero = (uint8_t)1ul;
261 }
262 }
263 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8FSOtherConfigDesc, u32Len);
264 }
265
266 break;
267 }
268 /* Get HID Descriptor */
269 case DESC_HID:
270 {
271 uint32_t u32ConfigDescOffset; /* u32ConfigDescOffset is configuration descriptor offset (HID descriptor start index) */
272 u32Len = Minimum(u32Len, LEN_HID);
273 u32ConfigDescOffset = g_hsusbd_sInfo->gu32ConfigHidDescIdx[gUsbCmd.wIndex & 0xfful];
274 HSUSBD_PrepareCtrlIn((uint8_t *)&g_hsusbd_sInfo->gu8ConfigDesc[u32ConfigDescOffset], u32Len);
275 break;
276 }
277 /* Get Report Descriptor */
278 case DESC_HID_RPT:
279 {
280 if (u32Len > g_hsusbd_sInfo->gu32HidReportSize[gUsbCmd.wIndex & 0xfful])
281 {
282 u32Len = g_hsusbd_sInfo->gu32HidReportSize[gUsbCmd.wIndex & 0xfful];
283 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
284 {
285 g_hsusbd_CtrlZero = (uint8_t)1ul;
286 }
287 }
288 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8HidReportDesc[gUsbCmd.wIndex & 0xfful], u32Len);
289 break;
290 }
291 /* Get String Descriptor */
292 case DESC_STRING:
293 {
294 if((gUsbCmd.wValue & 0xfful) < 8ul)
295 {
296 if (u32Len > g_hsusbd_sInfo->gu8StringDesc[gUsbCmd.wValue & 0xfful][0])
297 {
298 u32Len = g_hsusbd_sInfo->gu8StringDesc[gUsbCmd.wValue & 0xfful][0];
299 if ((u32Len % g_hsusbd_CtrlMaxPktSize) == 0ul)
300 {
301 g_hsusbd_CtrlZero = (uint8_t)1ul;
302 }
303 }
304 HSUSBD_PrepareCtrlIn((uint8_t *)g_hsusbd_sInfo->gu8StringDesc[gUsbCmd.wValue & 0xfful], u32Len);
305 }
306 else
307 {
309 val = 1;
310 }
311 break;
312 }
313 default:
314 /* Not support. Reply STALL. */
316 val = 1;
317 break;
318 }
319 return val;
320}
321
322
333{
334 /* clear global variables for new request */
335 g_hsusbd_CtrlInPointer = 0;
336 g_hsusbd_CtrlInSize = 0ul;
337
338 if ((gUsbCmd.bmRequestType & 0x80ul) == 0x80ul) /* request data transfer direction */
339 {
340 /* Device to host */
341 switch (gUsbCmd.bRequest)
342 {
343 case GET_CONFIGURATION:
344 {
345 /* Return current configuration setting */
346 HSUSBD_PrepareCtrlIn((uint8_t *)&g_hsusbd_UsbConfig, 1ul);
347
350 break;
351 }
352 case GET_DESCRIPTOR:
353 {
355 {
358 }
359 break;
360 }
361 case GET_INTERFACE:
362 {
363 /* Return current interface setting */
364 HSUSBD_PrepareCtrlIn((uint8_t *)&g_hsusbd_UsbAltInterface, 1ul);
365
368 break;
369 }
370 case GET_STATUS:
371 {
372 /* Device */
373 if (gUsbCmd.bmRequestType == 0x80ul)
374 {
375 uint8_t u8Tmp;
376
377 u8Tmp = (uint8_t)0ul;
378 if ((g_hsusbd_sInfo->gu8ConfigDesc[7] & 0x40ul) == 0x40ul) {
379 u8Tmp |= (uint8_t)1ul; /* Self-Powered/Bus-Powered.*/
380 }
381 if ((g_hsusbd_sInfo->gu8ConfigDesc[7] & 0x20ul) == 0x20ul) {
382 u8Tmp |= (uint8_t)(g_hsusbd_RemoteWakeupEn << 1ul); /* Remote wake up */
383 }
384 g_hsusbd_buf[0] = u8Tmp;
385 }
386 /* Interface */
387 else if (gUsbCmd.bmRequestType == 0x81ul)
388 {
389 g_hsusbd_buf[0] = (uint8_t)0ul;
390 }
391 /* Endpoint */
392 else if (gUsbCmd.bmRequestType == 0x82ul)
393 {
394 uint8_t ep = (uint8_t)(gUsbCmd.wIndex & 0xFul);
395 g_hsusbd_buf[0] = (uint8_t)HSUSBD_GetStall((uint32_t)ep)? (uint8_t)1 : (uint8_t)0;
396 }
397 g_hsusbd_buf[1] = (uint8_t)0ul;
398 HSUSBD_PrepareCtrlIn(g_hsusbd_buf, 2ul);
401 break;
402 }
403 default:
404 {
405 /* Setup error, stall the device */
407 break;
408 }
409 }
410 }
411 else
412 {
413 /* Host to device */
414 switch (gUsbCmd.bRequest)
415 {
416 case CLEAR_FEATURE:
417 {
418 if ((gUsbCmd.wValue & 0xfful) == FEATURE_ENDPOINT_HALT)
419 {
420 uint32_t epNum, i;
421
422 /* EP number stall is not allow to be clear in MSC class "Error Recovery Test".
423 a flag: g_u32HsEpStallLock is added to support it */
424 epNum = (uint32_t)(gUsbCmd.wIndex & 0xFul);
425 for (i=0ul; i<HSUSBD_MAX_EP; i++)
426 {
427 if ((((HSUSBD->EP[i].EPCFG & 0xf0ul) >> 4) == epNum) && ((g_u32HsEpStallLock & (1ul << i)) == 0ul))
428 {
429 HSUSBD->EP[i].EPRSPCTL = (HSUSBD->EP[i].EPRSPCTL & 0xeful) | HSUSBD_EP_RSPCTL_TOGGLE;
430 }
431 }
432 }
433 else if ((gUsbCmd.wValue & 0xfful) == FEATURE_DEVICE_REMOTE_WAKEUP)
434 {
435 g_hsusbd_RemoteWakeupEn = (uint8_t)0;
436 }
437 /* Status stage */
441 break;
442 }
443 case SET_ADDRESS:
444 {
445 g_hsusbd_UsbAddr = (uint8_t)gUsbCmd.wValue;
446 /* Status Stage */
450 break;
451 }
452 case SET_CONFIGURATION:
453 {
454 g_hsusbd_UsbConfig = (uint8_t)gUsbCmd.wValue;
455 g_hsusbd_Configured = (uint8_t)1ul;
456 /* Status stage */
460 break;
461 }
462 case SET_FEATURE:
463 {
464 if ((gUsbCmd.wValue & 0x3ul) == 2ul) /* TEST_MODE */
465 {
466 g_hsusbd_EnableTestMode = (uint8_t)1ul;
467 g_hsusbd_TestSelector = (uint8_t)(gUsbCmd.wIndex >> 8);
468 }
469 if ((gUsbCmd.wValue & 0x3ul) == 3ul) /* HNP ebable */
470 {
472 }
473 if ((gUsbCmd.wValue & FEATURE_DEVICE_REMOTE_WAKEUP) == FEATURE_DEVICE_REMOTE_WAKEUP)
474 {
475 g_hsusbd_RemoteWakeupEn = (uint8_t)1ul;
476 }
477
478 /* Status stage */
482 break;
483 }
484 case SET_INTERFACE:
485 {
486 g_hsusbd_UsbAltInterface = (uint8_t)gUsbCmd.wValue;
487 if (g_hsusbd_pfnSetInterface != NULL)
488 {
489 g_hsusbd_pfnSetInterface((uint32_t)g_hsusbd_UsbAltInterface);
490 }
491 /* Status stage */
495 break;
496 }
497 default:
498 {
499 /* Setup error, stall the device */
501 break;
502 }
503 }
504 }
505}
506
517#define TEST_J 0x01ul
518#define TEST_K 0x02ul
519#define TEST_SE0_NAK 0x03ul
520#define TEST_PACKET 0x04ul
521#define TEST_FORCE_ENABLE 0x05ul
525{
526 switch (gUsbCmd.bRequest)
527 {
528 case SET_ADDRESS:
529 {
530 HSUSBD_SET_ADDR(g_hsusbd_UsbAddr);
531 break;
532 }
533 case SET_CONFIGURATION:
534 {
535 if (g_hsusbd_UsbConfig == 0ul)
536 {
537 uint32_t volatile i;
538 /* Reset PID DATA0 */
539 for (i=0ul; i<HSUSBD_MAX_EP; i++)
540 {
541 if ((HSUSBD->EP[i].EPCFG & 0x1ul) == 0x1ul)
542 {
543 HSUSBD->EP[i].EPRSPCTL = HSUSBD_EP_RSPCTL_TOGGLE;
544 }
545 }
546 }
547 break;
548 }
549 case SET_FEATURE:
550 {
551 if (gUsbCmd.wValue == FEATURE_ENDPOINT_HALT)
552 {
553 uint32_t idx;
554 idx = (uint32_t)(gUsbCmd.wIndex & 0xFul);
555 HSUSBD_SetStall(idx);
556 }
557 else if (g_hsusbd_EnableTestMode)
558 {
559 g_hsusbd_EnableTestMode = (uint8_t)0ul;
560 if (g_hsusbd_TestSelector == TEST_J)
561 {
562 HSUSBD->TEST = TEST_J;
563 }
564 else if (g_hsusbd_TestSelector == TEST_K)
565 {
566 HSUSBD->TEST = TEST_K;
567 }
568 else if (g_hsusbd_TestSelector == TEST_SE0_NAK)
569 {
570 HSUSBD->TEST = TEST_SE0_NAK;
571 }
572 else if (g_hsusbd_TestSelector == TEST_PACKET)
573 {
574 HSUSBD->TEST = TEST_PACKET;
575 }
576 else if (g_hsusbd_TestSelector == TEST_FORCE_ENABLE)
577 {
578 HSUSBD->TEST = TEST_FORCE_ENABLE;
579 }
580 }
581 if ((gUsbCmd.wValue & FEATURE_DEVICE_REMOTE_WAKEUP) == FEATURE_DEVICE_REMOTE_WAKEUP)
582 {
583 g_hsusbd_RemoteWakeupEn = (uint8_t)1ul;
584 }
585 break;
586 }
587 case CLEAR_FEATURE:
588 {
589 if(gUsbCmd.wValue == FEATURE_ENDPOINT_HALT)
590 {
591 uint32_t idx;
592 idx = (uint32_t)(gUsbCmd.wIndex & 0xFul);
594 }
595 else if(gUsbCmd.wValue == FEATURE_DEVICE_REMOTE_WAKEUP)
596 {
597 g_hsusbd_RemoteWakeupEn = (uint8_t)0;
598 }
599 break;
600 }
601 default:
602 break;
603 }
604}
605
606
617void HSUSBD_PrepareCtrlIn(uint8_t pu8Buf[], uint32_t u32Size)
618{
619 g_hsusbd_CtrlInPointer = pu8Buf;
620 g_hsusbd_CtrlInSize = u32Size;
621}
622
623
624
635{
636 uint32_t volatile i, cnt;
637 uint8_t u8Value;
638 if(g_hsusbd_CtrlInSize >= g_hsusbd_CtrlMaxPktSize)
639 {
640 /* Data size > MXPLD */
641 cnt = g_hsusbd_CtrlMaxPktSize >> 2;
642 for (i=0ul; i<cnt; i++)
643 {
644 HSUSBD->CEPDAT = *(uint32_t *)g_hsusbd_CtrlInPointer;
645 g_hsusbd_CtrlInPointer = (uint8_t *)(g_hsusbd_CtrlInPointer + 4ul);
646 }
647 HSUSBD_START_CEP_IN(g_hsusbd_CtrlMaxPktSize);
648 g_hsusbd_CtrlInSize -= g_hsusbd_CtrlMaxPktSize;
649 }
650 else
651 {
652 /* Data size <= MXPLD */
653 cnt = g_hsusbd_CtrlInSize;
654 for (i=0ul; i<cnt; i++)
655 {
656 u8Value = *(uint8_t *)(g_hsusbd_CtrlInPointer+i);
657 outpb(&HSUSBD->CEPDAT, u8Value);
658 }
659
660 HSUSBD_START_CEP_IN(g_hsusbd_CtrlInSize);
661 g_hsusbd_CtrlInPointer = 0;
662 g_hsusbd_CtrlInSize = 0ul;
663 }
664}
665
676void HSUSBD_CtrlOut(uint8_t pu8Buf[], uint32_t u32Size)
677{
678 uint32_t volatile i;
679 while(1)
680 {
682 {
683 for (i=0ul; i<u32Size; i++)
684 {
685 pu8Buf[i] = inpb(&HSUSBD->CEPDAT);
686 }
688 break;
689 }
690 }
691}
692
703{
704 /* Reset all variables for protocol */
705 g_hsusbd_UsbAddr = (uint8_t)0ul;
706 g_hsusbd_DmaDone = 0ul;
707 g_hsusbd_ShortPacket = (uint8_t)0ul;
708 g_hsusbd_Configured = (uint8_t)0ul;
709
710 /* Reset USB device address */
711 HSUSBD_SET_ADDR(0ul);
712}
713
724{
725 g_hsusbd_pfnVendorRequest = pfnVendorReq;
726}
727
728 /* end of group HSUSBD_EXPORTED_FUNCTIONS */
730 /* end of group HSUSBD_Driver */
732 /* end of group Standard_Driver */
734
735/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
void *__dso_handle __attribute__((weak))
Definition: _syscalls.c:35
NuMicro peripheral access layer header file.
#define HSUSBD_EP_RSPCTL_TOGGLE
Definition: hsusbd.h:63
#define HSUSBD_CEPCTL_NAKCLR
Definition: hsusbd.h:52
uint8_t * gu8FSOtherConfigDesc
Definition: hsusbd.h:107
uint8_t bRequest
Definition: hsusbd.h:89
#define HSUSBD_CLR_SE0()
Definition: hsusbd.h:138
uint16_t wIndex
Definition: hsusbd.h:91
uint8_t bmRequestType
Definition: hsusbd.h:88
void(* HSUSBD_CLASS_REQ)(void)
Definition: hsusbd.h:354
void HSUSBD_PrepareCtrlIn(uint8_t pu8Buf[], uint32_t u32Size)
Prepare Control IN transaction.
Definition: hsusbd.c:617
#define HSUSBD_CLR_CEP_INT_FLAG(flag)
Definition: hsusbd.h:146
#define HSUSBD_ENABLE_CEP_INT(intr)
Definition: hsusbd.h:145
void HSUSBD_ProcessSetupPacket(void)
Process Setup Packet.
Definition: hsusbd.c:119
uint16_t wValue
Definition: hsusbd.h:90
#define HSUSBD_SET_ADDR(addr)
Definition: hsusbd.h:139
void HSUSBD_Start(void)
HSUSBD Start.
Definition: hsusbd.c:104
__STATIC_INLINE void HSUSBD_ClearStall(uint32_t u32EpNum)
Clear USB endpoint stall state.
Definition: hsusbd.h:301
__STATIC_INLINE uint32_t HSUSBD_GetStall(uint32_t u32EpNum)
Get USB endpoint stall state.
Definition: hsusbd.h:335
uint8_t ** gu8StringDesc
Definition: hsusbd.h:103
uint32_t * gu32ConfigHidDescIdx
Definition: hsusbd.h:110
uint8_t * gu8ConfigDesc
Definition: hsusbd.h:102
void HSUSBD_Open(S_HSUSBD_INFO_T *param, HSUSBD_CLASS_REQ pfnClassReq, HSUSBD_SET_INTERFACE_REQ pfnSetInterface)
HSUSBD Initial.
Definition: hsusbd.c:70
int HSUSBD_GetDescriptor(void)
Get Descriptor request.
Definition: hsusbd.c:170
void HSUSBD_StandardRequest(void)
Process USB standard request.
Definition: hsusbd.c:332
uint8_t * gu8FullConfigDesc
Definition: hsusbd.h:105
uint8_t * gu8DevDesc
Definition: hsusbd.h:101
__STATIC_INLINE void HSUSBD_SetStall(uint32_t u32EpNum)
Set USB endpoint stall state.
Definition: hsusbd.h:262
void(* HSUSBD_SET_INTERFACE_REQ)(uint32_t u32AltInterface)
Definition: hsusbd.h:355
uint16_t wLength
Definition: hsusbd.h:92
void HSUSBD_CtrlOut(uint8_t pu8Buf[], uint32_t u32Size)
Start Control OUT transaction.
Definition: hsusbd.c:676
uint8_t ** gu8HidReportDesc
Definition: hsusbd.h:108
void HSUSBD_SwReset(void)
Clear all software flags.
Definition: hsusbd.c:702
uint8_t * gu8HSOtherConfigDesc
Definition: hsusbd.h:106
#define HSUSBD_SET_CEP_STATE(flag)
Definition: hsusbd.h:147
void HSUSBD_SetVendorRequest(HSUSBD_VENDOR_REQ pfnVendorReq)
HSUSBD Set Vendor Request.
Definition: hsusbd.c:723
uint32_t * gu32HidReportSize
Definition: hsusbd.h:109
#define HSUSBD_START_CEP_IN(size)
Definition: hsusbd.h:148
void(* HSUSBD_VENDOR_REQ)(void)
Definition: hsusbd.h:353
#define HSUSBD_ENABLE_PHY()
Definition: hsusbd.h:135
uint8_t * gu8QualDesc
Definition: hsusbd.h:104
void HSUSBD_CtrlIn(void)
Start Control IN transfer.
Definition: hsusbd.c:634
void HSUSBD_UpdateDeviceState(void)
Update Device State.
Definition: hsusbd.c:524
#define inpb(port)
Get a 8-bit unsigned value from specified I/O port.
Definition: M480.h:542
#define outpb(port, value)
Set a 8-bit unsigned value to specified I/O port.
Definition: M480.h:535
#define NULL
NULL pointer.
Definition: M480.h:605
#define HSOTG
Definition: M480.h:410
#define HSUSBD
Definition: M480.h:409
#define HSUSBD_CEPINTEN_INTKIEN_Msk
Definition: hsusbd_reg.h:2175
#define HSUSBD_CEPCTL_STALLEN_Msk
Definition: hsusbd_reg.h:2157
#define HSOTG_CTL_HNPREQEN_Msk
Definition: hsotg_reg.h:543
#define HSUSBD_OPER_HISPDEN_Msk
Definition: hsusbd_reg.h:2133
#define HSUSBD_CEPINTSTS_RXPKIF_Msk
Definition: hsusbd_reg.h:2223
#define HSOTG_CTL_BUSREQ_Msk
Definition: hsotg_reg.h:540
#define HSUSBD_CEPINTSTS_INTKIF_Msk
Definition: hsusbd_reg.h:2214
#define HSUSBD_CEPINTEN_STSDONEIEN_Msk
Definition: hsusbd_reg.h:2196
#define HSUSBD_CEPINTSTS_STSDONEIF_Msk
Definition: hsusbd_reg.h:2235