1 /*----------------------------------------------------------------------------
\r
2 * U S B - K e r n e l
\r
3 *----------------------------------------------------------------------------
\r
5 * Purpose: USB Core Module
\r
7 *----------------------------------------------------------------------------
\r
8 * This software is supplied "AS IS" without any warranties, express,
\r
9 * implied or statutory, including but not limited to the implied
\r
10 * warranties of fitness for purpose, satisfactory quality and
\r
11 * noninfringement. Keil extends you a royalty-free right to reproduce
\r
12 * and distribute executable files created using this software for use
\r
13 * on NXP Semiconductors LPC family microcontroller devices only. Nothing
\r
14 * else gives you the right to use this software.
\r
16 * Copyright (c) 2009 Keil - An ARM Company. All rights reserved.
\r
17 *----------------------------------------------------------------------------
\r
19 * V1.20 Added vendor specific requests
\r
20 * Changed string descriptor handling
\r
21 * Reworked Endpoint0
\r
22 * V1.00 Initial Version
\r
23 *----------------------------------------------------------------------------*/
\r
24 #include "lpc_types.h"
\r
29 #include "usbcore.h"
\r
30 #include "usbdesc.h"
\r
31 #include "usbuser.h"
\r
37 #include "adcuser.h"
\r
42 #include "hiduser.h"
\r
47 #include "mscuser.h"
\r
53 #include "cdcuser.h"
\r
62 #if defined ( __CC_ARM )
\r
63 #pragma diag_suppress 111,1441
\r
66 #if defined ( __GNUC__ )
\r
67 #define __packed __attribute__((__packed__))
\r
70 uint16_t USB_DeviceStatus;
\r
71 uint8_t USB_DeviceAddress;
\r
72 uint8_t USB_Configuration;
\r
73 uint32_t USB_EndPointMask;
\r
74 uint32_t USB_EndPointHalt;
\r
75 uint32_t USB_EndPointStall; /* EP must stay stalled */
\r
76 uint8_t USB_NumInterfaces;
\r
77 uint8_t USB_AltSetting[USB_IF_NUM];
\r
79 uint8_t EP0Buf[USB_MAX_PACKET0];
\r
82 USB_EP_DATA EP0Data;
\r
84 USB_SETUP_PACKET SetupPacket;
\r
90 * Return Value: None
\r
93 void USB_ResetCore (void) {
\r
95 USB_DeviceStatus = USB_POWER;
\r
96 USB_DeviceAddress = 0;
\r
97 USB_Configuration = 0;
\r
98 USB_EndPointMask = 0x00010001;
\r
99 USB_EndPointHalt = 0x00000000;
\r
100 USB_EndPointStall = 0x00000000;
\r
105 * USB Request - Setup Stage
\r
106 * Parameters: None (global SetupPacket)
\r
107 * Return Value: None
\r
110 void USB_SetupStage (void) {
\r
111 USB_ReadEP(0x00, (uint8_t *)&SetupPacket);
\r
116 * USB Request - Data In Stage
\r
117 * Parameters: None (global EP0Data)
\r
118 * Return Value: None
\r
121 void USB_DataInStage (void) {
\r
124 if (EP0Data.Count > USB_MAX_PACKET0) {
\r
125 cnt = USB_MAX_PACKET0;
\r
127 cnt = EP0Data.Count;
\r
129 cnt = USB_WriteEP(0x80, EP0Data.pData, cnt);
\r
130 EP0Data.pData += cnt;
\r
131 EP0Data.Count -= cnt;
\r
136 * USB Request - Data Out Stage
\r
137 * Parameters: None (global EP0Data)
\r
138 * Return Value: None
\r
141 void USB_DataOutStage (void) {
\r
144 cnt = USB_ReadEP(0x00, EP0Data.pData);
\r
145 EP0Data.pData += cnt;
\r
146 EP0Data.Count -= cnt;
\r
151 * USB Request - Status In Stage
\r
153 * Return Value: None
\r
156 void USB_StatusInStage (void) {
\r
157 USB_WriteEP(0x80, NULL, 0);
\r
162 * USB Request - Status Out Stage
\r
164 * Return Value: None
\r
167 void USB_StatusOutStage (void) {
\r
168 USB_ReadEP(0x00, EP0Buf);
\r
173 * Get Status USB Request
\r
174 * Parameters: None (global SetupPacket)
\r
175 * Return Value: TRUE - Success, FALSE - Error
\r
178 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
179 inline uint32_t USB_ReqGetStatus (void) {
\r
181 __inline uint32_t USB_ReqGetStatus (void) {
\r
185 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
186 case REQUEST_TO_DEVICE:
\r
187 EP0Data.pData = (uint8_t *)&USB_DeviceStatus;
\r
189 case REQUEST_TO_INTERFACE:
\r
190 if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
\r
191 *((__packed uint16_t *)EP0Buf) = 0;
\r
192 *((uint16_t *)EP0Buf) = 0;
\r
193 EP0Data.pData = EP0Buf;
\r
198 case REQUEST_TO_ENDPOINT:
\r
199 n = SetupPacket.wIndex.WB.L & 0x8F;
\r
200 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
\r
201 if (((USB_Configuration != 0) || ((n & 0x0F) == 0)) && (USB_EndPointMask & m)) {
\r
202 *((__packed uint16_t *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
\r
203 *((uint16_t *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
\r
204 EP0Data.pData = EP0Buf;
\r
217 * Set/Clear Feature USB Request
\r
218 * Parameters: sc: 0 - Clear, 1 - Set
\r
219 * (global SetupPacket)
\r
220 * Return Value: TRUE - Success, FALSE - Error
\r
223 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
224 inline uint32_t USB_ReqSetClrFeature (uint32_t sc) {
\r
226 __inline uint32_t USB_ReqSetClrFeature (uint32_t sc) {
\r
230 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
231 case REQUEST_TO_DEVICE:
\r
232 if (SetupPacket.wValue.W == USB_FEATURE_REMOTE_WAKEUP) {
\r
234 USB_WakeUpCfg(TRUE);
\r
235 USB_DeviceStatus |= USB_GETSTATUS_REMOTE_WAKEUP;
\r
237 USB_WakeUpCfg(FALSE);
\r
238 USB_DeviceStatus &= ~USB_GETSTATUS_REMOTE_WAKEUP;
\r
244 case REQUEST_TO_INTERFACE:
\r
246 case REQUEST_TO_ENDPOINT:
\r
247 n = SetupPacket.wIndex.WB.L & 0x8F;
\r
248 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
\r
249 if ((USB_Configuration != 0) && ((n & 0x0F) != 0) && (USB_EndPointMask & m)) {
\r
250 if (SetupPacket.wValue.W == USB_FEATURE_ENDPOINT_STALL) {
\r
253 USB_EndPointHalt |= m;
\r
255 if ((USB_EndPointStall & m) != 0) {
\r
260 if ((n == MSC_EP_IN) && ((USB_EndPointHalt & m) != 0)) {
\r
261 /* Compliance Test: rewrite CSW after unstall */
\r
262 if (CSW.dSignature == MSC_CSW_Signature) {
\r
263 USB_WriteEP(MSC_EP_IN, (uint8_t *)&CSW, sizeof(CSW));
\r
267 USB_EndPointHalt &= ~m;
\r
284 * Set Address USB Request
\r
285 * Parameters: None (global SetupPacket)
\r
286 * Return Value: TRUE - Success, FALSE - Error
\r
289 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
290 inline uint32_t USB_ReqSetAddress (void) {
\r
292 __inline uint32_t USB_ReqSetAddress (void) {
\r
294 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
295 case REQUEST_TO_DEVICE:
\r
296 USB_DeviceAddress = 0x80 | SetupPacket.wValue.WB.L;
\r
306 * Get Descriptor USB Request
\r
307 * Parameters: None (global SetupPacket)
\r
308 * Return Value: TRUE - Success, FALSE - Error
\r
311 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
312 inline uint32_t USB_ReqGetDescriptor (void) {
\r
314 __inline uint32_t USB_ReqGetDescriptor (void) {
\r
319 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
320 case REQUEST_TO_DEVICE:
\r
321 switch (SetupPacket.wValue.WB.H) {
\r
322 case USB_DEVICE_DESCRIPTOR_TYPE:
\r
323 EP0Data.pData = (uint8_t *)USB_DeviceDescriptor;
\r
324 len = USB_DEVICE_DESC_SIZE;
\r
326 case USB_CONFIGURATION_DESCRIPTOR_TYPE:
\r
327 pD = (uint8_t *)USB_ConfigDescriptor;
\r
328 for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
\r
329 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength != 0) {
\r
330 pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
333 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength == 0) {
\r
336 EP0Data.pData = pD;
\r
337 len = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
339 case USB_STRING_DESCRIPTOR_TYPE:
\r
340 pD = (uint8_t *)USB_StringDescriptor;
\r
341 for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
\r
342 if (((USB_STRING_DESCRIPTOR *)pD)->bLength != 0) {
\r
343 pD += ((USB_STRING_DESCRIPTOR *)pD)->bLength;
\r
346 if (((USB_STRING_DESCRIPTOR *)pD)->bLength == 0) {
\r
349 EP0Data.pData = pD;
\r
350 len = ((USB_STRING_DESCRIPTOR *)EP0Data.pData)->bLength;
\r
356 case REQUEST_TO_INTERFACE:
\r
357 switch (SetupPacket.wValue.WB.H) {
\r
359 case HID_HID_DESCRIPTOR_TYPE:
\r
360 if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
\r
361 return (FALSE); /* Only Single HID Interface is supported */
\r
363 EP0Data.pData = (uint8_t *)USB_ConfigDescriptor + HID_DESC_OFFSET;
\r
364 len = HID_DESC_SIZE;
\r
366 case HID_REPORT_DESCRIPTOR_TYPE:
\r
367 if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
\r
368 return (FALSE); /* Only Single HID Interface is supported */
\r
370 EP0Data.pData = (uint8_t *)HID_ReportDescriptor;
\r
371 len = HID_ReportDescSize;
\r
373 case HID_PHYSICAL_DESCRIPTOR_TYPE:
\r
374 return (FALSE); /* HID Physical Descriptor is not supported */
\r
384 if (EP0Data.Count > len) {
\r
385 EP0Data.Count = len;
\r
393 * Get Configuration USB Request
\r
394 * Parameters: None (global SetupPacket)
\r
395 * Return Value: TRUE - Success, FALSE - Error
\r
398 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
399 inline uint32_t USB_ReqGetConfiguration (void) {
\r
401 __inline uint32_t USB_ReqGetConfiguration (void) {
\r
403 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
404 case REQUEST_TO_DEVICE:
\r
405 EP0Data.pData = &USB_Configuration;
\r
415 * Set Configuration USB Request
\r
416 * Parameters: None (global SetupPacket)
\r
417 * Return Value: TRUE - Success, FALSE - Error
\r
420 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
421 inline uint32_t USB_ReqSetConfiguration (void) {
\r
423 __inline uint32_t USB_ReqSetConfiguration (void) {
\r
425 USB_COMMON_DESCRIPTOR *pD;
\r
430 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
431 case REQUEST_TO_DEVICE:
\r
433 if (SetupPacket.wValue.WB.L) {
\r
434 pD = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
\r
435 while (pD->bLength) {
\r
436 switch (pD->bDescriptorType) {
\r
437 case USB_CONFIGURATION_DESCRIPTOR_TYPE:
\r
438 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue == SetupPacket.wValue.WB.L) {
\r
439 USB_Configuration = SetupPacket.wValue.WB.L;
\r
440 USB_NumInterfaces = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->bNumInterfaces;
\r
441 for (n = 0; n < USB_IF_NUM; n++) {
\r
442 USB_AltSetting[n] = 0;
\r
444 for (n = 1; n < 16; n++) {
\r
445 if (USB_EndPointMask & (1 << n)) {
\r
448 if (USB_EndPointMask & ((1 << 16) << n)) {
\r
449 USB_DisableEP(n | 0x80);
\r
452 USB_EndPointMask = 0x00010001;
\r
453 USB_EndPointHalt = 0x00000000;
\r
454 USB_EndPointStall= 0x00000000;
\r
455 USB_Configure(TRUE);
\r
456 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bmAttributes & USB_CONFIG_POWERED_MASK) {
\r
457 USB_DeviceStatus |= USB_GETSTATUS_SELF_POWERED;
\r
459 USB_DeviceStatus &= ~USB_GETSTATUS_SELF_POWERED;
\r
462 // (uint8_t *)pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
463 tmp = (uint32_t)pD;
\r
464 tmp += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
465 pD = (USB_COMMON_DESCRIPTOR *)tmp;
\r
469 case USB_INTERFACE_DESCRIPTOR_TYPE:
\r
470 alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
\r
472 case USB_ENDPOINT_DESCRIPTOR_TYPE:
\r
474 n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
\r
475 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
\r
476 USB_EndPointMask |= m;
\r
477 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
\r
483 // (uint8_t *)pD += pD->bLength;
\r
484 tmp = (uint32_t)pD;
\r
485 tmp += pD->bLength;
\r
486 pD = (USB_COMMON_DESCRIPTOR *)tmp;
\r
490 USB_Configuration = 0;
\r
491 for (n = 1; n < 16; n++) {
\r
492 if (USB_EndPointMask & (1 << n)) {
\r
495 if (USB_EndPointMask & ((1 << 16) << n)) {
\r
496 USB_DisableEP(n | 0x80);
\r
499 USB_EndPointMask = 0x00010001;
\r
500 USB_EndPointHalt = 0x00000000;
\r
501 USB_EndPointStall = 0x00000000;
\r
502 USB_Configure(FALSE);
\r
505 if (USB_Configuration != SetupPacket.wValue.WB.L) {
\r
517 * Get Interface USB Request
\r
518 * Parameters: None (global SetupPacket)
\r
519 * Return Value: TRUE - Success, FALSE - Error
\r
522 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
523 inline uint32_t USB_ReqGetInterface (void) {
\r
525 __inline uint32_t USB_ReqGetInterface (void) {
\r
527 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
528 case REQUEST_TO_INTERFACE:
\r
529 if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
\r
530 EP0Data.pData = USB_AltSetting + SetupPacket.wIndex.WB.L;
\r
543 * Set Interface USB Request
\r
544 * Parameters: None (global SetupPacket)
\r
545 * Return Value: TRUE - Success, FALSE - Error
\r
547 #if defined ( __IAR_SYSTEMS_ICC__ )
\r
548 inline uint32_t USB_ReqSetInterface (void) {
\r
550 __inline uint32_t USB_ReqSetInterface (void) {
\r
552 USB_COMMON_DESCRIPTOR *pD;
\r
553 uint32_t ifn = 0, alt = 0, old = 0, msk = 0;
\r
558 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
559 case REQUEST_TO_INTERFACE:
\r
560 if (USB_Configuration == 0) return (FALSE);
\r
562 pD = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
\r
563 while (pD->bLength) {
\r
564 switch (pD->bDescriptorType) {
\r
565 case USB_CONFIGURATION_DESCRIPTOR_TYPE:
\r
566 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue != USB_Configuration) {
\r
567 // (uint8_t *)pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
568 tmp = (uint32_t)pD;
\r
569 tmp += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
\r
570 pD = (USB_COMMON_DESCRIPTOR *)tmp;
\r
575 case USB_INTERFACE_DESCRIPTOR_TYPE:
\r
576 ifn = ((USB_INTERFACE_DESCRIPTOR *)pD)->bInterfaceNumber;
\r
577 alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
\r
579 if ((ifn == SetupPacket.wIndex.WB.L) && (alt == SetupPacket.wValue.WB.L)) {
\r
581 old = USB_AltSetting[ifn];
\r
582 USB_AltSetting[ifn] = (uint8_t)alt;
\r
585 case USB_ENDPOINT_DESCRIPTOR_TYPE:
\r
586 if (ifn == SetupPacket.wIndex.WB.L) {
\r
587 n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
\r
588 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
\r
589 if (alt == SetupPacket.wValue.WB.L) {
\r
590 USB_EndPointMask |= m;
\r
591 USB_EndPointHalt &= ~m;
\r
592 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
\r
597 else if ((alt == old) && ((msk & m) == 0)) {
\r
598 USB_EndPointMask &= ~m;
\r
599 USB_EndPointHalt &= ~m;
\r
605 // (uint8_t *)pD += pD->bLength;
\r
606 tmp = (uint32_t)pD;
\r
607 tmp += pD->bLength;
\r
608 pD = (USB_COMMON_DESCRIPTOR *)tmp;
\r
620 * USB Endpoint 0 Event Callback
\r
621 * Parameters: event
\r
622 * Return Value: none
\r
625 void USB_EndPoint0 (uint32_t event) {
\r
628 case USB_EVT_SETUP:
\r
630 USB_DirCtrlEP(SetupPacket.bmRequestType.BM.Dir);
\r
631 EP0Data.Count = SetupPacket.wLength; /* Number of bytes to transfer */
\r
632 switch (SetupPacket.bmRequestType.BM.Type) {
\r
634 case REQUEST_STANDARD:
\r
635 switch (SetupPacket.bRequest) {
\r
636 case USB_REQUEST_GET_STATUS:
\r
637 if (!USB_ReqGetStatus()) {
\r
643 case USB_REQUEST_CLEAR_FEATURE:
\r
644 if (!USB_ReqSetClrFeature(0)) {
\r
647 USB_StatusInStage();
\r
648 #if USB_FEATURE_EVENT
\r
649 USB_Feature_Event();
\r
653 case USB_REQUEST_SET_FEATURE:
\r
654 if (!USB_ReqSetClrFeature(1)) {
\r
657 USB_StatusInStage();
\r
658 #if USB_FEATURE_EVENT
\r
659 USB_Feature_Event();
\r
663 case USB_REQUEST_SET_ADDRESS:
\r
664 if (!USB_ReqSetAddress()) {
\r
667 USB_StatusInStage();
\r
670 case USB_REQUEST_GET_DESCRIPTOR:
\r
671 if (!USB_ReqGetDescriptor()) {
\r
677 case USB_REQUEST_SET_DESCRIPTOR:
\r
678 /*stall_o:*/ USB_SetStallEP(0x00); /* not supported */
\r
682 case USB_REQUEST_GET_CONFIGURATION:
\r
683 if (!USB_ReqGetConfiguration()) {
\r
689 case USB_REQUEST_SET_CONFIGURATION:
\r
690 if (!USB_ReqSetConfiguration()) {
\r
693 USB_StatusInStage();
\r
694 #if USB_CONFIGURE_EVENT
\r
695 USB_Configure_Event();
\r
699 case USB_REQUEST_GET_INTERFACE:
\r
700 if (!USB_ReqGetInterface()) {
\r
706 case USB_REQUEST_SET_INTERFACE:
\r
707 if (!USB_ReqSetInterface()) {
\r
710 USB_StatusInStage();
\r
711 #if USB_INTERFACE_EVENT
\r
712 USB_Interface_Event();
\r
719 break; /* end case REQUEST_STANDARD */
\r
722 case REQUEST_CLASS:
\r
723 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
725 case REQUEST_TO_DEVICE:
\r
726 goto stall_i; /* not supported */
\r
728 case REQUEST_TO_INTERFACE:
\r
730 if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) { /* IF number correct? */
\r
731 switch (SetupPacket.bRequest) {
\r
732 case HID_REQUEST_GET_REPORT:
\r
733 if (HID_GetReport()) {
\r
734 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
735 USB_DataInStage(); /* send requested data */
\r
736 goto setup_class_ok;
\r
739 case HID_REQUEST_SET_REPORT:
\r
740 EP0Data.pData = EP0Buf; /* data to be received */
\r
741 goto setup_class_ok;
\r
742 case HID_REQUEST_GET_IDLE:
\r
743 if (HID_GetIdle()) {
\r
744 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
745 USB_DataInStage(); /* send requested data */
\r
746 goto setup_class_ok;
\r
749 case HID_REQUEST_SET_IDLE:
\r
750 if (HID_SetIdle()) {
\r
751 USB_StatusInStage(); /* send Acknowledge */
\r
752 goto setup_class_ok;
\r
755 case HID_REQUEST_GET_PROTOCOL:
\r
756 if (HID_GetProtocol()) {
\r
757 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
758 USB_DataInStage(); /* send requested data */
\r
759 goto setup_class_ok;
\r
762 case HID_REQUEST_SET_PROTOCOL:
\r
763 if (HID_SetProtocol()) {
\r
764 USB_StatusInStage(); /* send Acknowledge */
\r
765 goto setup_class_ok;
\r
770 #endif /* USB_HID */
\r
772 if (SetupPacket.wIndex.WB.L == USB_MSC_IF_NUM) { /* IF number correct? */
\r
773 switch (SetupPacket.bRequest) {
\r
774 case MSC_REQUEST_RESET:
\r
775 if ((SetupPacket.wValue.W == 0) && /* RESET with invalid parameters -> STALL */
\r
776 (SetupPacket.wLength == 0)) {
\r
778 USB_StatusInStage();
\r
779 goto setup_class_ok;
\r
783 case MSC_REQUEST_GET_MAX_LUN:
\r
784 if ((SetupPacket.wValue.W == 0) && /* GET_MAX_LUN with invalid parameters -> STALL */
\r
785 (SetupPacket.wLength == 1)) {
\r
786 if (MSC_GetMaxLUN()) {
\r
787 EP0Data.pData = EP0Buf;
\r
789 goto setup_class_ok;
\r
795 #endif /* USB_MSC */
\r
797 if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM) || /* IF number correct? */
\r
798 (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
\r
799 (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
\r
800 switch (SetupPacket.bRequest) {
\r
801 case AUDIO_REQUEST_GET_CUR:
\r
802 case AUDIO_REQUEST_GET_MIN:
\r
803 case AUDIO_REQUEST_GET_MAX:
\r
804 case AUDIO_REQUEST_GET_RES:
\r
805 if (ADC_IF_GetRequest()) {
\r
806 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
807 USB_DataInStage(); /* send requested data */
\r
808 goto setup_class_ok;
\r
811 case AUDIO_REQUEST_SET_CUR:
\r
812 // case AUDIO_REQUEST_SET_MIN:
\r
813 // case AUDIO_REQUEST_SET_MAX:
\r
814 // case AUDIO_REQUEST_SET_RES:
\r
815 EP0Data.pData = EP0Buf; /* data to be received */
\r
816 goto setup_class_ok;
\r
819 #endif /* USB_AUDIO */
\r
821 if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM) || /* IF number correct? */
\r
822 (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
\r
823 switch (SetupPacket.bRequest) {
\r
824 case CDC_SEND_ENCAPSULATED_COMMAND:
\r
825 EP0Data.pData = EP0Buf; /* data to be received, see USB_EVT_OUT */
\r
826 goto setup_class_ok;
\r
827 case CDC_GET_ENCAPSULATED_RESPONSE:
\r
828 if (CDC_GetEncapsulatedResponse()) {
\r
829 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
830 USB_DataInStage(); /* send requested data */
\r
831 goto setup_class_ok;
\r
834 case CDC_SET_COMM_FEATURE:
\r
835 EP0Data.pData = EP0Buf; /* data to be received, see USB_EVT_OUT */
\r
836 goto setup_class_ok;
\r
837 case CDC_GET_COMM_FEATURE:
\r
838 if (CDC_GetCommFeature(SetupPacket.wValue.W)) {
\r
839 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
840 USB_DataInStage(); /* send requested data */
\r
841 goto setup_class_ok;
\r
844 case CDC_CLEAR_COMM_FEATURE:
\r
845 if (CDC_ClearCommFeature(SetupPacket.wValue.W)) {
\r
846 USB_StatusInStage(); /* send Acknowledge */
\r
847 goto setup_class_ok;
\r
850 case CDC_SET_LINE_CODING:
\r
851 EP0Data.pData = EP0Buf; /* data to be received, see USB_EVT_OUT */
\r
852 goto setup_class_ok;
\r
853 case CDC_GET_LINE_CODING:
\r
854 if (CDC_GetLineCoding()) {
\r
855 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
856 USB_DataInStage(); /* send requested data */
\r
857 goto setup_class_ok;
\r
860 case CDC_SET_CONTROL_LINE_STATE:
\r
861 if (CDC_SetControlLineState(SetupPacket.wValue.W)) {
\r
862 USB_StatusInStage(); /* send Acknowledge */
\r
863 goto setup_class_ok;
\r
866 case CDC_SEND_BREAK:
\r
867 if (CDC_SendBreak(SetupPacket.wValue.W)) {
\r
868 USB_StatusInStage(); /* send Acknowledge */
\r
869 goto setup_class_ok;
\r
874 #endif /* USB_CDC */
\r
875 goto stall_i; /* not supported */
\r
876 /* end case REQUEST_TO_INTERFACE */
\r
878 case REQUEST_TO_ENDPOINT:
\r
880 switch (SetupPacket.bRequest) {
\r
881 case AUDIO_REQUEST_GET_CUR:
\r
882 case AUDIO_REQUEST_GET_MIN:
\r
883 case AUDIO_REQUEST_GET_MAX:
\r
884 case AUDIO_REQUEST_GET_RES:
\r
885 if (ADC_EP_GetRequest()) {
\r
886 EP0Data.pData = EP0Buf; /* point to data to be sent */
\r
887 USB_DataInStage(); /* send requested data */
\r
888 goto setup_class_ok;
\r
891 case AUDIO_REQUEST_SET_CUR:
\r
892 // case AUDIO_REQUEST_SET_MIN:
\r
893 // case AUDIO_REQUEST_SET_MAX:
\r
894 // case AUDIO_REQUEST_SET_RES:
\r
895 EP0Data.pData = EP0Buf; /* data to be received */
\r
896 goto setup_class_ok;
\r
898 #endif /* USB_AUDIO */
\r
900 /* end case REQUEST_TO_ENDPOINT */
\r
905 setup_class_ok: /* request finished successfully */
\r
906 break; /* end case REQUEST_CLASS */
\r
907 #endif /* USB_CLASS */
\r
910 case REQUEST_VENDOR:
\r
911 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
913 case REQUEST_TO_DEVICE:
\r
914 if (!USB_ReqVendorDev(TRUE)) {
\r
915 goto stall_i; /* not supported */
\r
919 case REQUEST_TO_INTERFACE:
\r
920 if (!USB_ReqVendorIF(TRUE)) {
\r
921 goto stall_i; /* not supported */
\r
925 case REQUEST_TO_ENDPOINT:
\r
926 if (!USB_ReqVendorEP(TRUE)) {
\r
927 goto stall_i; /* not supported */
\r
935 if (SetupPacket.wLength) {
\r
936 if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
\r
940 USB_StatusInStage();
\r
943 break; /* end case REQUEST_VENDOR */
\r
944 #endif /* USB_VENDOR */
\r
947 stall_i: USB_SetStallEP(0x80);
\r
951 break; /* end case USB_EVT_SETUP */
\r
954 if (SetupPacket.bmRequestType.BM.Dir == REQUEST_HOST_TO_DEVICE) {
\r
955 if (EP0Data.Count) { /* still data to receive ? */
\r
956 USB_DataOutStage(); /* receive data */
\r
957 if (EP0Data.Count == 0) { /* data complete ? */
\r
958 switch (SetupPacket.bmRequestType.BM.Type) {
\r
960 case REQUEST_STANDARD:
\r
961 goto stall_i; /* not supported */
\r
964 case REQUEST_CLASS:
\r
965 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
966 case REQUEST_TO_DEVICE:
\r
967 goto stall_i; /* not supported */
\r
969 case REQUEST_TO_INTERFACE:
\r
971 if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) { /* IF number correct? */
\r
972 switch (SetupPacket.bRequest) {
\r
973 case HID_REQUEST_SET_REPORT:
\r
974 if (HID_SetReport()) {
\r
975 USB_StatusInStage(); /* send Acknowledge */
\r
981 #endif /* USB_HID */
\r
983 if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM) || /* IF number correct? */
\r
984 (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
\r
985 (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
\r
986 switch (SetupPacket.bRequest) {
\r
987 case AUDIO_REQUEST_SET_CUR:
\r
988 // case AUDIO_REQUEST_SET_MIN:
\r
989 // case AUDIO_REQUEST_SET_MAX:
\r
990 // case AUDIO_REQUEST_SET_RES:
\r
991 if (ADC_IF_SetRequest()) {
\r
992 USB_StatusInStage(); /* send Acknowledge */
\r
998 #endif /* USB_AUDIO */
\r
1000 if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM) || /* IF number correct? */
\r
1001 (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
\r
1002 switch (SetupPacket.bRequest) {
\r
1003 case CDC_SEND_ENCAPSULATED_COMMAND:
\r
1004 if (CDC_SendEncapsulatedCommand()) {
\r
1005 USB_StatusInStage(); /* send Acknowledge */
\r
1006 goto out_class_ok;
\r
1009 case CDC_SET_COMM_FEATURE:
\r
1010 if (CDC_SetCommFeature(SetupPacket.wValue.W)) {
\r
1011 USB_StatusInStage(); /* send Acknowledge */
\r
1012 goto out_class_ok;
\r
1015 case CDC_SET_LINE_CODING:
\r
1016 if (CDC_SetLineCoding()) {
\r
1017 USB_StatusInStage(); /* send Acknowledge */
\r
1018 goto out_class_ok;
\r
1023 #endif /* USB_CDC */
\r
1025 /* end case REQUEST_TO_INTERFACE */
\r
1027 case REQUEST_TO_ENDPOINT:
\r
1029 switch (SetupPacket.bRequest) {
\r
1030 case AUDIO_REQUEST_SET_CUR:
\r
1031 // case AUDIO_REQUEST_SET_MIN:
\r
1032 // case AUDIO_REQUEST_SET_MAX:
\r
1033 // case AUDIO_REQUEST_SET_RES:
\r
1034 if (ADC_EP_SetRequest()) {
\r
1035 USB_StatusInStage(); /* send Acknowledge */
\r
1036 goto out_class_ok;
\r
1040 #endif /* USB_AUDIO */
\r
1042 /* end case REQUEST_TO_ENDPOINT */
\r
1047 out_class_ok: /* request finished successfully */
\r
1048 break; /* end case REQUEST_CLASS */
\r
1049 #endif /* USB_CLASS */
\r
1052 case REQUEST_VENDOR:
\r
1053 switch (SetupPacket.bmRequestType.BM.Recipient) {
\r
1055 case REQUEST_TO_DEVICE:
\r
1056 if (!USB_ReqVendorDev(FALSE)) {
\r
1057 goto stall_i; /* not supported */
\r
1061 case REQUEST_TO_INTERFACE:
\r
1062 if (!USB_ReqVendorIF(FALSE)) {
\r
1063 goto stall_i; /* not supported */
\r
1067 case REQUEST_TO_ENDPOINT:
\r
1068 if (!USB_ReqVendorEP(FALSE)) {
\r
1069 goto stall_i; /* not supported */
\r
1077 USB_StatusInStage();
\r
1079 break; /* end case REQUEST_VENDOR */
\r
1080 #endif /* USB_VENDOR */
\r
1088 USB_StatusOutStage(); /* receive Acknowledge */
\r
1090 break; /* end case USB_EVT_OUT */
\r
1093 if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
\r
1094 USB_DataInStage(); /* send data */
\r
1096 if (USB_DeviceAddress & 0x80) {
\r
1097 USB_DeviceAddress &= 0x7F;
\r
1098 USB_SetAddress(USB_DeviceAddress);
\r
1101 break; /* end case USB_EVT_IN */
\r
1103 case USB_EVT_OUT_STALL:
\r
1104 USB_ClrStallEP(0x00);
\r
1107 case USB_EVT_IN_STALL:
\r
1108 USB_ClrStallEP(0x80);
\r