core/usbcdc/usbcore.c

   1 /*----------------------------------------------------------------------------
   2  *      U S B  -  K e r n e l
   3  *----------------------------------------------------------------------------
   4  * Name:    usbcore.c
   5  * Purpose: USB Core Module
   6  * Version: V1.20
   7  *----------------------------------------------------------------------------
   8  *      This software is supplied "AS IS" without any warranties, express,
   9  *      implied or statutory, including but not limited to the implied
  10  *      warranties of fitness for purpose, satisfactory quality and
  11  *      noninfringement. Keil extends you a royalty-free right to reproduce
  12  *      and distribute executable files created using this software for use
  13  *      on NXP Semiconductors LPC microcontroller devices only. Nothing else
  14  *      gives you the right to use this software.
  15  *
  16  * Copyright (c) 2009 Keil - An ARM Company. All rights reserved.
  17  *----------------------------------------------------------------------------
  18  * History:
  19  *          V1.20 Added vendor specific requests
  20  *                Changed string descriptor handling
  21  *                Reworked Endpoint0
  22  *          V1.00 Initial Version
  23  *----------------------------------------------------------------------------*/
  24 #include "projectconfig.h"
  25
  26 #include "usb.h"
  27 #include "usbcfg.h"
  28 #include "usbhw.h"
  29 #include "usbcore.h"
  30 #include "usbdesc.h"
  31 #include "usbuser.h"
  32
  33 #if (USB_CLASS)
  34
  35 #if (USB_AUDIO)
  36 #include "audio.h"
  37 #include "adcuser.h"
  38 #endif
  39
  40 #if (USB_HID)
  41 #include "hid.h"
  42 #include "hiduser.h"
  43 #endif
  44
  45 #if (USB_MSC)
  46 #include "msc.h"
  47 #include "mscuser.h"
  48 extern MSC_CSW CSW;
  49 #endif
  50
  51 #if (USB_CDC)
  52 #include "cdc.h"
  53 #include "cdcuser.h"
  54 #endif
  55
  56 #endif
  57
  58 #if (USB_VENDOR)
  59 #include "vendor.h"
  60 #endif
  61
  62 uint16_t  USB_DeviceStatus;
  63 uint8_t  USB_DeviceAddress;
  64 volatile uint8_t  USB_Configuration;
  65 uint32_t USB_EndPointMask;
  66 uint32_t USB_EndPointHalt;
  67 uint32_t USB_EndPointStall;                         /* EP must stay stalled */
  68 uint8_t  USB_NumInterfaces;
  69 uint8_t  USB_AltSetting[USB_IF_NUM];
  70
  71 uint8_t  EP0Buf[USB_MAX_PACKET0];
  72
  73
  74 USB_EP_DATA EP0Data;
  75
  76 USB_SETUP_PACKET SetupPacket;
  77
  78
  79 /*
  80  *  Reset USB Core
  81  *    Parameters:      None
  82  *    Return Value:    None
  83  */
  84
  85 void USB_ResetCore (void) {
  86
  87   USB_DeviceStatus  = USB_POWER;
  88   USB_DeviceAddress = 0;
  89   USB_Configuration = 0;
  90   USB_EndPointMask  = 0x00010001;
  91   USB_EndPointHalt  = 0x00000000;
  92   USB_EndPointStall = 0x00000000;
  93 }
  94
  95
  96 /*
  97  *  USB Request - Setup Stage
  98  *    Parameters:      None (global SetupPacket)
  99  *    Return Value:    None
 100  */
 101
 102 void USB_SetupStage (void) {
 103   USB_ReadEP(0x00, (uint8_t *)&SetupPacket);
 104 }
 105
 106
 107 /*
 108  *  USB Request - Data In Stage
 109  *    Parameters:      None (global EP0Data)
 110  *    Return Value:    None
 111  */
 112
 113 void USB_DataInStage (void) {
 114   uint32_t cnt;
 115
 116   if (EP0Data.Count > USB_MAX_PACKET0) {
 117     cnt = USB_MAX_PACKET0;
 118   } else {
 119     cnt = EP0Data.Count;
 120   }
 121   cnt = USB_WriteEP(0x80, EP0Data.pData, cnt);
 122   EP0Data.pData += cnt;
 123   EP0Data.Count -= cnt;
 124 }
 125
 126
 127 /*
 128  *  USB Request - Data Out Stage
 129  *    Parameters:      None (global EP0Data)
 130  *    Return Value:    None
 131  */
 132
 133 void USB_DataOutStage (void) {
 134   uint32_t cnt;
 135
 136   cnt = USB_ReadEP(0x00, EP0Data.pData);
 137   EP0Data.pData += cnt;
 138   EP0Data.Count -= cnt;
 139 }
 140
 141
 142 /*
 143  *  USB Request - Status In Stage
 144  *    Parameters:      None
 145  *    Return Value:    None
 146  */
 147
 148 void USB_StatusInStage (void) {
 149   USB_WriteEP(0x80, NULL, 0);
 150 }
 151
 152
 153 /*
 154  *  USB Request - Status Out Stage
 155  *    Parameters:      None
 156  *    Return Value:    None
 157  */
 158
 159 void USB_StatusOutStage (void) {
 160   USB_ReadEP(0x00, EP0Buf);
 161 }
 162
 163
 164 /*
 165  *  Get Status USB Request
 166  *    Parameters:      None (global SetupPacket)
 167  *    Return Value:    TRUE - Success, FALSE - Error
 168  */
 169
 170 static inline uint32_t USB_ReqGetStatus (void) {
 171   uint32_t n, m;
 172
 173   switch (SetupPacket.bmRequestType.BM.Recipient) {
 174     case REQUEST_TO_DEVICE:
 175       EP0Data.pData = (uint8_t *)&USB_DeviceStatus;
 176       break;
 177     case REQUEST_TO_INTERFACE:
 178       if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
 179         *((uint16_t __attribute__((packed)) *)EP0Buf) = 0;
 180         EP0Data.pData = EP0Buf;
 181       } else {
 182         return (FALSE);
 183       }
 184       break;
 185     case REQUEST_TO_ENDPOINT:
 186       n = SetupPacket.wIndex.WB.L & 0x8F;
 187       m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
 188       if (((USB_Configuration != 0) || ((n & 0x0F) == 0)) && (USB_EndPointMask & m)) {
 189         *((uint16_t __attribute__((packed)) *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
 190         EP0Data.pData = EP0Buf;
 191       } else {
 192         return (FALSE);
 193       }
 194       break;
 195     default:
 196       return (FALSE);
 197   }
 198   return (TRUE);
 199 }
 200
 201
 202 /*
 203  *  Set/Clear Feature USB Request
 204  *    Parameters:      sc:    0 - Clear, 1 - Set
 205  *                            (global SetupPacket)
 206  *    Return Value:    TRUE - Success, FALSE - Error
 207  */
 208
 209 static inline uint32_t USB_ReqSetClrFeature (uint32_t sc) {
 210   uint32_t n, m;
 211
 212   switch (SetupPacket.bmRequestType.BM.Recipient) {
 213     case REQUEST_TO_DEVICE:
 214       if (SetupPacket.wValue.W == USB_FEATURE_REMOTE_WAKEUP) {
 215         if (sc) {
 216           USB_WakeUpCfg(TRUE);
 217           USB_DeviceStatus |=  USB_GETSTATUS_REMOTE_WAKEUP;
 218         } else {
 219           USB_WakeUpCfg(FALSE);
 220           USB_DeviceStatus &= ~USB_GETSTATUS_REMOTE_WAKEUP;
 221         }
 222       } else {
 223         return (FALSE);
 224       }
 225       break;
 226     case REQUEST_TO_INTERFACE:
 227       return (FALSE);
 228     case REQUEST_TO_ENDPOINT:
 229       n = SetupPacket.wIndex.WB.L & 0x8F;
 230       m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
 231       if ((USB_Configuration != 0) && ((n & 0x0F) != 0) && (USB_EndPointMask & m)) {
 232         if (SetupPacket.wValue.W == USB_FEATURE_ENDPOINT_STALL) {
 233           if (sc) {
 234             USB_SetStallEP(n);
 235             USB_EndPointHalt |=  m;
 236           } else {
 237             if ((USB_EndPointStall & m) != 0) {
 238               return (TRUE);
 239             }
 240             USB_ClrStallEP(n);
 241 #if (USB_MSC)
 242             if ((n == MSC_EP_IN) && ((USB_EndPointHalt & m) != 0)) {
 243               /* Compliance Test: rewrite CSW after unstall */
 244               if (CSW.dSignature == MSC_CSW_Signature) {
 245                 USB_WriteEP(MSC_EP_IN, (uint8_t *)&CSW, sizeof(CSW));
 246               }
 247             }
 248 #endif
 249             USB_EndPointHalt &= ~m;
 250           }
 251         } else {
 252           return (FALSE);
 253         }
 254       } else {
 255         return (FALSE);
 256       }
 257       break;
 258     default:
 259       return (FALSE);
 260   }
 261   return (TRUE);
 262 }
 263
 264
 265 /*
 266  *  Set Address USB Request
 267  *    Parameters:      None (global SetupPacket)
 268  *    Return Value:    TRUE - Success, FALSE - Error
 269  */
 270
 271 static inline uint32_t USB_ReqSetAddress (void) {
 272
 273   switch (SetupPacket.bmRequestType.BM.Recipient) {
 274     case REQUEST_TO_DEVICE:
 275       USB_DeviceAddress = 0x80 | SetupPacket.wValue.WB.L;
 276       break;
 277     default:
 278       return (FALSE);
 279   }
 280   return (TRUE);
 281 }
 282
 283
 284 /*
 285  *  Get Descriptor USB Request
 286  *    Parameters:      None (global SetupPacket)
 287  *    Return Value:    TRUE - Success, FALSE - Error
 288  */
 289
 290 static inline uint32_t USB_ReqGetDescriptor (void) {
 291   uint8_t  *pD;
 292   uint32_t len, n;
 293
 294   switch (SetupPacket.bmRequestType.BM.Recipient) {
 295     case REQUEST_TO_DEVICE:
 296       switch (SetupPacket.wValue.WB.H) {
 297         case USB_DEVICE_DESCRIPTOR_TYPE:
 298           EP0Data.pData = (uint8_t *)USB_DeviceDescriptor;
 299           len = USB_DEVICE_DESC_SIZE;
 300           break;
 301         case USB_CONFIGURATION_DESCRIPTOR_TYPE:
 302           pD = (uint8_t *)USB_ConfigDescriptor;
 303           for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
 304             if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength != 0) {
 305               pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
 306             }
 307           }
 308           if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength == 0) {
 309             return (FALSE);
 310           }
 311           EP0Data.pData = pD;
 312           len = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
 313           break;
 314         case USB_STRING_DESCRIPTOR_TYPE:
 315           pD = (uint8_t *)USB_StringDescriptor;
 316           for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
 317             if (((USB_STRING_DESCRIPTOR *)pD)->bLength != 0) {
 318               pD += ((USB_STRING_DESCRIPTOR *)pD)->bLength;
 319             }
 320           }
 321           if (((USB_STRING_DESCRIPTOR *)pD)->bLength == 0) {
 322             return (FALSE);
 323           }
 324           EP0Data.pData = pD;
 325           len = ((USB_STRING_DESCRIPTOR *)EP0Data.pData)->bLength;
 326           break;
 327         default:
 328           return (FALSE);
 329       }
 330       break;
 331     case REQUEST_TO_INTERFACE:
 332       switch (SetupPacket.wValue.WB.H) {
 333 #if USB_HID
 334         case HID_HID_DESCRIPTOR_TYPE:
 335           if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
 336             return (FALSE);    /* Only Single HID Interface is supported */
 337           }
 338           EP0Data.pData = (uint8_t *)USB_ConfigDescriptor + HID_DESC_OFFSET;
 339           len = HID_DESC_SIZE;
 340           break;
 341         case HID_REPORT_DESCRIPTOR_TYPE:
 342           if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
 343             return (FALSE);    /* Only Single HID Interface is supported */
 344           }
 345           EP0Data.pData = (uint8_t *)HID_ReportDescriptor;
 346           len = HID_ReportDescSize;
 347           break;
 348         case HID_PHYSICAL_DESCRIPTOR_TYPE:
 349           return (FALSE);      /* HID Physical Descriptor is not supported */
 350 #endif
 351         default:
 352           return (FALSE);
 353       }
 354       break;
 355     default:
 356       return (FALSE);
 357   }
 358
 359   if (EP0Data.Count > len) {
 360     EP0Data.Count = len;
 361   }
 362
 363   return (TRUE);
 364 }
 365
 366
 367 /*
 368  *  Get Configuration USB Request
 369  *    Parameters:      None (global SetupPacket)
 370  *    Return Value:    TRUE - Success, FALSE - Error
 371  */
 372
 373 static inline uint32_t USB_ReqGetConfiguration (void) {
 374
 375   switch (SetupPacket.bmRequestType.BM.Recipient) {
 376     case REQUEST_TO_DEVICE:
 377       // Added cast to avoid warnings due to USB_Configuration being volatile (KTownsend)
 378       EP0Data.pData = (uint8_t *)&USB_Configuration;
 379       //EP0Data.pData = &USB_Configuration;
 380       break;
 381     default:
 382       return (FALSE);
 383   }
 384   return (TRUE);
 385 }
 386
 387 /*
 388  *  Set Configuration USB Request
 389  *    Parameters:      None (global SetupPacket)
 390  *    Return Value:    TRUE - Success, FALSE - Error
 391  */
 392
 393 static inline uint32_t USB_ReqSetConfiguration (void) {
 394   USB_COMMON_DESCRIPTOR *pD;
 395   uint32_t alt = 0;
 396   uint32_t n, m;
 397
 398   switch (SetupPacket.bmRequestType.BM.Recipient) {
 399     case REQUEST_TO_DEVICE:
 400
 401       if (SetupPacket.wValue.WB.L) {
 402         pD = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
 403         while (pD->bLength) {
 404           switch (pD->bDescriptorType) {
 405             case USB_CONFIGURATION_DESCRIPTOR_TYPE:
 406               if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue == SetupPacket.wValue.WB.L) {
 407                 USB_Configuration = SetupPacket.wValue.WB.L;
 408                 USB_NumInterfaces = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->bNumInterfaces;
 409                 for (n = 0; n < USB_IF_NUM; n++) {
 410                   USB_AltSetting[n] = 0;
 411                 }
 412                 for (n = 1; n < 16; n++) {
 413                   if (USB_EndPointMask & (1 << n)) {
 414                     USB_DisableEP(n);
 415                   }
 416                   if (USB_EndPointMask & ((1 << 16) << n)) {
 417                     USB_DisableEP(n | 0x80);
 418                   }
 419                 }
 420                 USB_EndPointMask = 0x00010001;
 421                 USB_EndPointHalt = 0x00000000;
 422                 USB_EndPointStall= 0x00000000;
 423                 USB_Configure(TRUE);
 424                 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bmAttributes & USB_CONFIG_POWERED_MASK) {
 425                   USB_DeviceStatus |=  USB_GETSTATUS_SELF_POWERED;
 426                 } else {
 427                   USB_DeviceStatus &= ~USB_GETSTATUS_SELF_POWERED;
 428                 }
 429               } else {
 430                   UsbAddPtr((void **)&pD, ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength);
 431                 continue;
 432               }
 433               break;
 434             case USB_INTERFACE_DESCRIPTOR_TYPE:
 435               alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
 436               break;
 437             case USB_ENDPOINT_DESCRIPTOR_TYPE:
 438               if (alt == 0) {
 439                 n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
 440                 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
 441                 USB_EndPointMask |= m;
 442                 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
 443                 USB_EnableEP(n);
 444                 USB_ResetEP(n);
 445               }
 446               break;
 447           }
 448           UsbAddPtr((void **)&pD, pD->bLength);
 449         }
 450       }
 451       else {
 452         USB_Configuration = 0;
 453         for (n = 1; n < 16; n++) {
 454           if (USB_EndPointMask & (1 << n)) {
 455             USB_DisableEP(n);
 456           }
 457           if (USB_EndPointMask & ((1 << 16) << n)) {
 458             USB_DisableEP(n | 0x80);
 459           }
 460         }
 461         USB_EndPointMask  = 0x00010001;
 462         USB_EndPointHalt  = 0x00000000;
 463         USB_EndPointStall = 0x00000000;
 464         USB_Configure(FALSE);
 465       }
 466
 467       if (USB_Configuration != SetupPacket.wValue.WB.L) {
 468         return (FALSE);
 469       }
 470       break;
 471     default:
 472       return (FALSE);
 473   }
 474   return (TRUE);
 475 }
 476
 477
 478 /*
 479  *  Get Interface USB Request
 480  *    Parameters:      None (global SetupPacket)
 481  *    Return Value:    TRUE - Success, FALSE - Error
 482  */
 483
 484 static inline uint32_t USB_ReqGetInterface (void) {
 485
 486   switch (SetupPacket.bmRequestType.BM.Recipient) {
 487     case REQUEST_TO_INTERFACE:
 488       if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
 489         EP0Data.pData = USB_AltSetting + SetupPacket.wIndex.WB.L;
 490       } else {
 491         return (FALSE);
 492       }
 493       break;
 494     default:
 495       return (FALSE);
 496   }
 497   return (TRUE);
 498 }
 499
 500
 501 /*
 502  *  Set Interface USB Request
 503  *    Parameters:      None (global SetupPacket)
 504  *    Return Value:    TRUE - Success, FALSE - Error
 505  */
 506
 507 static inline uint32_t USB_ReqSetInterface (void) {
 508   USB_COMMON_DESCRIPTOR *pD;
 509   uint32_t ifn = 0, alt = 0, old = 0, msk = 0;
 510   uint32_t n, m;
 511   uint32_t set;
 512
 513   switch (SetupPacket.bmRequestType.BM.Recipient) {
 514     case REQUEST_TO_INTERFACE:
 515       if (USB_Configuration == 0) return (FALSE);
 516       set = FALSE;
 517       pD  = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
 518       while (pD->bLength) {
 519         switch (pD->bDescriptorType) {
 520           case USB_CONFIGURATION_DESCRIPTOR_TYPE:
 521             if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue != USB_Configuration) {
 522               UsbAddPtr((void **)&pD, ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength);
 523               continue;
 524             }
 525             break;
 526           case USB_INTERFACE_DESCRIPTOR_TYPE:
 527             ifn = ((USB_INTERFACE_DESCRIPTOR *)pD)->bInterfaceNumber;
 528             alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
 529             msk = 0;
 530             if ((ifn == SetupPacket.wIndex.WB.L) && (alt == SetupPacket.wValue.WB.L)) {
 531               set = TRUE;
 532               old = USB_AltSetting[ifn];
 533               USB_AltSetting[ifn] = (uint8_t)alt;
 534             }
 535             break;
 536           case USB_ENDPOINT_DESCRIPTOR_TYPE:
 537             if (ifn == SetupPacket.wIndex.WB.L) {
 538               n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
 539               m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
 540               if (alt == SetupPacket.wValue.WB.L) {
 541                 USB_EndPointMask |=  m;
 542                 USB_EndPointHalt &= ~m;
 543                 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
 544                 USB_EnableEP(n);
 545                 USB_ResetEP(n);
 546                 msk |= m;
 547               }
 548               else if ((alt == old) && ((msk & m) == 0)) {
 549                 USB_EndPointMask &= ~m;
 550                 USB_EndPointHalt &= ~m;
 551                 USB_DisableEP(n);
 552               }
 553             }
 554            break;
 555         }
 556         UsbAddPtr((void **)&pD, pD->bLength);
 557       }
 558       break;
 559     default:
 560       return (FALSE);
 561   }
 562
 563   return (set);
 564 }
 565
 566
 567 /*
 568  *  USB Endpoint 0 Event Callback
 569  *    Parameters:      event
 570  *    Return Value:    none
 571  */
 572
 573 void USB_EndPoint0 (uint32_t event) {
 574
 575   switch (event) {
 576     case USB_EVT_SETUP:
 577       USB_SetupStage();
 578       USB_DirCtrlEP(SetupPacket.bmRequestType.BM.Dir);
 579       EP0Data.Count = SetupPacket.wLength;     /* Number of bytes to transfer */
 580       switch (SetupPacket.bmRequestType.BM.Type) {
 581
 582         case REQUEST_STANDARD:
 583           switch (SetupPacket.bRequest) {
 584             case USB_REQUEST_GET_STATUS:
 585               if (!USB_ReqGetStatus()) {
 586                 goto stall_i;
 587               }
 588               USB_DataInStage();
 589               break;
 590
 591             case USB_REQUEST_CLEAR_FEATURE:
 592               if (!USB_ReqSetClrFeature(0)) {
 593                 goto stall_i;
 594               }
 595               USB_StatusInStage();
 596 #if USB_FEATURE_EVENT
 597               USB_Feature_Event();
 598 #endif
 599               break;
 600
 601             case USB_REQUEST_SET_FEATURE:
 602               if (!USB_ReqSetClrFeature(1)) {
 603                 goto stall_i;
 604               }
 605               USB_StatusInStage();
 606 #if USB_FEATURE_EVENT
 607               USB_Feature_Event();
 608 #endif
 609               break;
 610
 611             case USB_REQUEST_SET_ADDRESS:
 612               if (!USB_ReqSetAddress()) {
 613                 goto stall_i;
 614               }
 615               USB_StatusInStage();
 616               break;
 617
 618             case USB_REQUEST_GET_DESCRIPTOR:
 619               if (!USB_ReqGetDescriptor()) {
 620                 goto stall_i;
 621               }
 622               USB_DataInStage();
 623               break;
 624
 625             case USB_REQUEST_SET_DESCRIPTOR:
 626 /*stall_o:*/  USB_SetStallEP(0x00);            /* not supported */
 627               EP0Data.Count = 0;
 628               break;
 629
 630             case USB_REQUEST_GET_CONFIGURATION:
 631               if (!USB_ReqGetConfiguration()) {
 632                 goto stall_i;
 633               }
 634               USB_DataInStage();
 635               break;
 636
 637             case USB_REQUEST_SET_CONFIGURATION:
 638               if (!USB_ReqSetConfiguration()) {
 639                 goto stall_i;
 640               }
 641               USB_StatusInStage();
 642 #if USB_CONFIGURE_EVENT
 643               USB_Configure_Event();
 644 #endif
 645               break;
 646
 647             case USB_REQUEST_GET_INTERFACE:
 648               if (!USB_ReqGetInterface()) {
 649                 goto stall_i;
 650               }
 651               USB_DataInStage();
 652               break;
 653
 654             case USB_REQUEST_SET_INTERFACE:
 655               if (!USB_ReqSetInterface()) {
 656                 goto stall_i;
 657               }
 658               USB_StatusInStage();
 659 #if USB_INTERFACE_EVENT
 660               USB_Interface_Event();
 661 #endif
 662               break;
 663
 664             default:
 665               goto stall_i;
 666           }
 667           break;  /* end case REQUEST_STANDARD */
 668
 669 #if USB_CLASS
 670         case REQUEST_CLASS:
 671           switch (SetupPacket.bmRequestType.BM.Recipient) {
 672
 673             case REQUEST_TO_DEVICE:
 674               goto stall_i;                                              /* not supported */
 675
 676             case REQUEST_TO_INTERFACE:
 677 #if USB_HID
 678               if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) {           /* IF number correct? */
 679                 switch (SetupPacket.bRequest) {
 680                   case HID_REQUEST_GET_REPORT:
 681                     if (HID_GetReport()) {
 682                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 683                       USB_DataInStage();                                 /* send requested data */
 684                       goto setup_class_ok;
 685                     }
 686                     break;
 687                   case HID_REQUEST_SET_REPORT:
 688                     EP0Data.pData = EP0Buf;                              /* data to be received */
 689                     goto setup_class_ok;
 690                   case HID_REQUEST_GET_IDLE:
 691                     if (HID_GetIdle()) {
 692                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 693                       USB_DataInStage();                                 /* send requested data */
 694                       goto setup_class_ok;
 695                     }
 696                     break;
 697                   case HID_REQUEST_SET_IDLE:
 698                     if (HID_SetIdle()) {
 699                       USB_StatusInStage();                               /* send Acknowledge */
 700                       goto setup_class_ok;
 701                     }
 702                     break;
 703                   case HID_REQUEST_GET_PROTOCOL:
 704                     if (HID_GetProtocol()) {
 705                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 706                       USB_DataInStage();                                 /* send requested data */
 707                       goto setup_class_ok;
 708                     }
 709                     break;
 710                   case HID_REQUEST_SET_PROTOCOL:
 711                     if (HID_SetProtocol()) {
 712                       USB_StatusInStage();                               /* send Acknowledge */
 713                       goto setup_class_ok;
 714                     }
 715                     break;
 716                 }
 717               }
 718 #endif  /* USB_HID */
 719 #if USB_MSC
 720               if (SetupPacket.wIndex.WB.L == USB_MSC_IF_NUM) {           /* IF number correct? */
 721                 switch (SetupPacket.bRequest) {
 722                   case MSC_REQUEST_RESET:
 723                     if ((SetupPacket.wValue.W == 0) &&                   /* RESET with invalid parameters -> STALL */
 724                         (SetupPacket.wLength  == 0)) {
 725                       if (MSC_Reset()) {
 726                         USB_StatusInStage();
 727                         goto setup_class_ok;
 728                       }
 729                     }
 730                     break;
 731                   case MSC_REQUEST_GET_MAX_LUN:
 732                     if ((SetupPacket.wValue.W == 0) &&                   /* GET_MAX_LUN with invalid parameters -> STALL */
 733                         (SetupPacket.wLength  == 1)) {
 734                       if (MSC_GetMaxLUN()) {
 735                         EP0Data.pData = EP0Buf;
 736                         USB_DataInStage();
 737                         goto setup_class_ok;
 738                       }
 739                     }
 740                     break;
 741                 }
 742               }
 743 #endif  /* USB_MSC */
 744 #if USB_AUDIO
 745               if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM)  ||       /* IF number correct? */
 746                   (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
 747                   (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
 748                 switch (SetupPacket.bRequest) {
 749                   case AUDIO_REQUEST_GET_CUR:
 750                   case AUDIO_REQUEST_GET_MIN:
 751                   case AUDIO_REQUEST_GET_MAX:
 752                   case AUDIO_REQUEST_GET_RES:
 753                     if (ADC_IF_GetRequest()) {
 754                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 755                       USB_DataInStage();                                 /* send requested data */
 756                       goto setup_class_ok;
 757                     }
 758                     break;
 759                   case AUDIO_REQUEST_SET_CUR:
 760 //                case AUDIO_REQUEST_SET_MIN:
 761 //                case AUDIO_REQUEST_SET_MAX:
 762 //                case AUDIO_REQUEST_SET_RES:
 763                     EP0Data.pData = EP0Buf;                              /* data to be received */
 764                     goto setup_class_ok;
 765                 }
 766               }
 767 #endif  /* USB_AUDIO */
 768 #if USB_CDC
 769               if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM)  ||       /* IF number correct? */
 770                   (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
 771                 switch (SetupPacket.bRequest) {
 772                   case CDC_SEND_ENCAPSULATED_COMMAND:
 773                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
 774                     goto setup_class_ok;
 775                   case CDC_GET_ENCAPSULATED_RESPONSE:
 776                     if (CDC_GetEncapsulatedResponse()) {
 777                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 778                       USB_DataInStage();                                 /* send requested data */
 779                       goto setup_class_ok;
 780                     }
 781                     break;
 782                   case CDC_SET_COMM_FEATURE:
 783                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
 784                     goto setup_class_ok;
 785                   case CDC_GET_COMM_FEATURE:
 786                     if (CDC_GetCommFeature(SetupPacket.wValue.W)) {
 787                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 788                       USB_DataInStage();                                 /* send requested data */
 789                       goto setup_class_ok;
 790                     }
 791                     break;
 792                   case CDC_CLEAR_COMM_FEATURE:
 793                     if (CDC_ClearCommFeature(SetupPacket.wValue.W)) {
 794                       USB_StatusInStage();                               /* send Acknowledge */
 795                       goto setup_class_ok;
 796                     }
 797                     break;
 798                   case CDC_SET_LINE_CODING:
 799                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
 800                     goto setup_class_ok;
 801                   case CDC_GET_LINE_CODING:
 802                     if (CDC_GetLineCoding()) {
 803                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
 804                       USB_DataInStage();                                 /* send requested data */
 805                       goto setup_class_ok;
 806                     }
 807                     break;
 808                   case CDC_SET_CONTROL_LINE_STATE:
 809                     if (CDC_SetControlLineState(SetupPacket.wValue.W)) {
 810                       USB_StatusInStage();                               /* send Acknowledge */
 811                       goto setup_class_ok;
 812                     }
 813                     break;
 814                   case CDC_SEND_BREAK:
 815                     if (CDC_SendBreak(SetupPacket.wValue.W)) {
 816                       USB_StatusInStage();                               /* send Acknowledge */
 817                       goto setup_class_ok;
 818                     }
 819                     break;
 820                 }
 821               }
 822 #endif  /* USB_CDC */
 823               goto stall_i;                                              /* not supported */
 824               /* end case REQUEST_TO_INTERFACE */
 825
 826             case REQUEST_TO_ENDPOINT:
 827 #if USB_AUDIO
 828               switch (SetupPacket.bRequest) {
 829                 case AUDIO_REQUEST_GET_CUR:
 830                 case AUDIO_REQUEST_GET_MIN:
 831                 case AUDIO_REQUEST_GET_MAX:
 832                 case AUDIO_REQUEST_GET_RES:
 833                   if (ADC_EP_GetRequest()) {
 834                     EP0Data.pData = EP0Buf;                              /* point to data to be sent */
 835                     USB_DataInStage();                                   /* send requested data */
 836                     goto setup_class_ok;
 837                   }
 838                   break;
 839                 case AUDIO_REQUEST_SET_CUR:
 840 //              case AUDIO_REQUEST_SET_MIN:
 841 //              case AUDIO_REQUEST_SET_MAX:
 842 //              case AUDIO_REQUEST_SET_RES:
 843                   EP0Data.pData = EP0Buf;                                /* data to be received */
 844                   goto setup_class_ok;
 845               }
 846 #endif  /* USB_AUDIO */
 847               goto stall_i;
 848               /* end case REQUEST_TO_ENDPOINT */
 849
 850             default:
 851               goto stall_i;
 852           }
 853 setup_class_ok:                                                          /* request finished successfully */
 854           break;  /* end case REQUEST_CLASS */
 855 #endif  /* USB_CLASS */
 856
 857 #if USB_VENDOR
 858         case REQUEST_VENDOR:
 859           switch (SetupPacket.bmRequestType.BM.Recipient) {
 860
 861             case REQUEST_TO_DEVICE:
 862               if (!USB_ReqVendorDev(TRUE)) {
 863                 goto stall_i;                                            /* not supported */
 864               }
 865               break;
 866
 867             case REQUEST_TO_INTERFACE:
 868               if (!USB_ReqVendorIF(TRUE)) {
 869                 goto stall_i;                                            /* not supported */
 870               }
 871               break;
 872
 873             case REQUEST_TO_ENDPOINT:
 874               if (!USB_ReqVendorEP(TRUE)) {
 875                 goto stall_i;                                            /* not supported */
 876               }
 877               break;
 878
 879             default:
 880               goto stall_i;
 881           }
 882
 883           if (SetupPacket.wLength) {
 884             if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
 885               USB_DataInStage();
 886             }
 887           } else {
 888             USB_StatusInStage();
 889           }
 890
 891           break;  /* end case REQUEST_VENDOR */
 892 #endif  /* USB_VENDOR */
 893
 894         default:
 895 stall_i:  USB_SetStallEP(0x80);
 896           EP0Data.Count = 0;
 897           break;
 898       }
 899       break;  /* end case USB_EVT_SETUP */
 900
 901     case USB_EVT_OUT:
 902       if (SetupPacket.bmRequestType.BM.Dir == REQUEST_HOST_TO_DEVICE) {
 903         if (EP0Data.Count) {                                             /* still data to receive ? */
 904           USB_DataOutStage();                                            /* receive data */
 905           if (EP0Data.Count == 0) {                                      /* data complete ? */
 906             switch (SetupPacket.bmRequestType.BM.Type) {
 907
 908               case REQUEST_STANDARD:
 909                 goto stall_i;                                            /* not supported */
 910
 911 #if (USB_CLASS)
 912               case REQUEST_CLASS:
 913                 switch (SetupPacket.bmRequestType.BM.Recipient) {
 914                   case REQUEST_TO_DEVICE:
 915                     goto stall_i;                                        /* not supported */
 916
 917                   case REQUEST_TO_INTERFACE:
 918 #if USB_HID
 919                     if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) {     /* IF number correct? */
 920                       switch (SetupPacket.bRequest) {
 921                         case HID_REQUEST_SET_REPORT:
 922                           if (HID_SetReport()) {
 923                             USB_StatusInStage();                         /* send Acknowledge */
 924                             goto out_class_ok;
 925                           }
 926                           break;
 927                       }
 928                     }
 929 #endif  /* USB_HID */
 930 #if USB_AUDIO
 931                     if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM)  || /* IF number correct? */
 932                         (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
 933                         (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
 934                       switch (SetupPacket.bRequest) {
 935                         case AUDIO_REQUEST_SET_CUR:
 936 //                      case AUDIO_REQUEST_SET_MIN:
 937 //                      case AUDIO_REQUEST_SET_MAX:
 938 //                      case AUDIO_REQUEST_SET_RES:
 939                           if (ADC_IF_SetRequest()) {
 940                             USB_StatusInStage();                         /* send Acknowledge */
 941                             goto out_class_ok;
 942                           }
 943                           break;
 944                       }
 945                     }
 946 #endif  /* USB_AUDIO */
 947 #if USB_CDC
 948                     if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM)  || /* IF number correct? */
 949                         (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
 950                       switch (SetupPacket.bRequest) {
 951                         case CDC_SEND_ENCAPSULATED_COMMAND:
 952                           if (CDC_SendEncapsulatedCommand()) {
 953                             USB_StatusInStage();                         /* send Acknowledge */
 954                             goto out_class_ok;
 955                           }
 956                           break;
 957                         case CDC_SET_COMM_FEATURE:
 958                           if (CDC_SetCommFeature(SetupPacket.wValue.W)) {
 959                             USB_StatusInStage();                         /* send Acknowledge */
 960                             goto out_class_ok;
 961                           }
 962                           break;
 963                         case CDC_SET_LINE_CODING:
 964                           if (CDC_SetLineCoding()) {
 965                             USB_StatusInStage();                         /* send Acknowledge */
 966                             goto out_class_ok;
 967                           }
 968                           break;
 969                       }
 970                     }
 971 #endif  /* USB_CDC */
 972                     goto stall_i;
 973                     /* end case REQUEST_TO_INTERFACE */
 974
 975                   case REQUEST_TO_ENDPOINT:
 976 #if USB_AUDIO
 977                     switch (SetupPacket.bRequest) {
 978                       case AUDIO_REQUEST_SET_CUR:
 979 //                    case AUDIO_REQUEST_SET_MIN:
 980 //                    case AUDIO_REQUEST_SET_MAX:
 981 //                    case AUDIO_REQUEST_SET_RES:
 982                         if (ADC_EP_SetRequest()) {
 983                           USB_StatusInStage();                           /* send Acknowledge */
 984                           goto out_class_ok;
 985                         }
 986                         break;
 987                     }
 988 #endif  /* USB_AUDIO */
 989                     goto stall_i;
 990                     /* end case REQUEST_TO_ENDPOINT */
 991
 992                   default:
 993                     goto stall_i;
 994                 }
 995 out_class_ok:                                                            /* request finished successfully */
 996                 break; /* end case REQUEST_CLASS */
 997 #endif  /* USB_CLASS */
 998
 999 #if USB_VENDOR
1000               case REQUEST_VENDOR:
1001                 switch (SetupPacket.bmRequestType.BM.Recipient) {
1002
1003                   case REQUEST_TO_DEVICE:
1004                     if (!USB_ReqVendorDev(FALSE)) {
1005                       goto stall_i;                                      /* not supported */
1006                     }
1007                     break;
1008
1009                   case REQUEST_TO_INTERFACE:
1010                     if (!USB_ReqVendorIF(FALSE)) {
1011                       goto stall_i;                                      /* not supported */
1012                     }
1013                     break;
1014
1015                   case REQUEST_TO_ENDPOINT:
1016                     if (!USB_ReqVendorEP(FALSE)) {
1017                       goto stall_i;                                      /* not supported */
1018                     }
1019                     break;
1020
1021                   default:
1022                     goto stall_i;
1023                 }
1024
1025                 USB_StatusInStage();
1026
1027                 break;  /* end case REQUEST_VENDOR */
1028 #endif  /* USB_VENDOR */
1029
1030               default:
1031                 goto stall_i;
1032             }
1033           }
1034         }
1035       } else {
1036         USB_StatusOutStage();                                            /* receive Acknowledge */
1037       }
1038       break;  /* end case USB_EVT_OUT */
1039
1040     case USB_EVT_IN :
1041       if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
1042         USB_DataInStage();                                               /* send data */
1043       } else {
1044         if (USB_DeviceAddress & 0x80) {
1045           USB_DeviceAddress &= 0x7F;
1046           USB_SetAddress(USB_DeviceAddress);
1047         }
1048       }
1049       break;  /* end case USB_EVT_IN */
1050
1051     case USB_EVT_OUT_STALL:
1052       USB_ClrStallEP(0x00);
1053       break;
1054
1055     case USB_EVT_IN_STALL:
1056       USB_ClrStallEP(0x80);
1057       break;
1058
1059   }
1060 }