Output/pjrcUSB/arm/usb_desc.c

   1 /* Teensyduino Core Library
   2  * http://www.pjrc.com/teensy/
   3  * Copyright (c) 2013 PJRC.COM, LLC.
   4  * Modified by Jacob Alexander (2013-2016)
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * 1. The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * 2. If the Software is incorporated into a build system that allows
  18  * selection among a list of target devices, then similar target
  19  * devices manufactured by PJRC.COM must be included in the list of
  20  * target devices and selectable in the same manner.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  26  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  27  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  29  * SOFTWARE.
  30  */
  31
  32 // ----- Includes -----
  33
  34 // Local Includes
  35 #include "usb_desc.h"
  36
  37 // Generated Includes
  38 #include <kll_defs.h>
  39
  40
  41
  42 // ----- Macros -----
  43
  44 #define LSB(n) ((n) & 255)
  45 #define MSB(n) (((n) >> 8) & 255)
  46
  47
  48
  49 // ----- USB Device Descriptor -----
  50
  51 // USB Device Descriptor.  The USB host reads this first, to learn
  52 // what type of device is connected.
  53 static uint8_t device_descriptor[] = {
  54         18,                                     // bLength
  55         1,                                      // bDescriptorType
  56         0x00, 0x02,                             // bcdUSB
  57         DEVICE_CLASS,                           // bDeviceClass
  58         DEVICE_SUBCLASS,                        // bDeviceSubClass
  59         DEVICE_PROTOCOL,                        // bDeviceProtocol
  60         EP0_SIZE,                               // bMaxPacketSize0
  61         LSB(VENDOR_ID), MSB(VENDOR_ID),         // idVendor
  62         LSB(PRODUCT_ID), MSB(PRODUCT_ID),       // idProduct
  63         0x00, 0x01,                             // bcdDevice
  64         1,                                      // iManufacturer
  65         2,                                      // iProduct
  66         3,                                      // iSerialNumber
  67         1                                       // bNumConfigurations
  68 };
  69
  70 // USB Device Qualifier Descriptor
  71 static uint8_t device_qualifier_descriptor[] = {
  72         0                                       // Indicate only single speed
  73         /* Device qualifier example (used for specifying multiple USB speeds)
  74         10,                                     // bLength
  75         6,                                      // bDescriptorType
  76         0x00, 0x02,                             // bcdUSB
  77         DEVICE_CLASS,                           // bDeviceClass
  78         DEVICE_SUBCLASS,                        // bDeviceSubClass
  79         DEVICE_PROTOCOL,                        // bDeviceProtocol
  80         EP0_SIZE,                               // bMaxPacketSize0
  81         0,                                      // bNumOtherSpeedConfigurations
  82         0                                       // bReserved
  83         */
  84 };
  85
  86 // USB Debug Descriptor
  87 // XXX Not sure of exact use, lsusb requests it
  88 static uint8_t usb_debug_descriptor[] = {
  89         0
  90 };
  91
  92 // XXX
  93 // These descriptors must NOT be "const", because the USB DMA
  94 // has trouble accessing flash memory with enough bandwidth
  95 // while the processor is executing from flash.
  96 // XXX
  97
  98
  99
 100 // ----- USB HID Report Descriptors -----
 101
 102 // Each HID interface needs a special report descriptor that tells
 103 // the meaning and format of the data.
 104
 105 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 106 static uint8_t keyboard_report_desc[] = {
 107         // Keyboard Collection
 108         0x05, 0x01,          // Usage Page (Generic Desktop),
 109         0x09, 0x06,          // Usage (Keyboard),
 110         0xA1, 0x01,          // Collection (Application) - Keyboard,
 111
 112         // Modifier Byte
 113         0x75, 0x01,          //   Report Size (1),
 114         0x95, 0x08,          //   Report Count (8),
 115         0x05, 0x07,          //   Usage Page (Key Codes),
 116         0x19, 0xE0,          //   Usage Minimum (224),
 117         0x29, 0xE7,          //   Usage Maximum (231),
 118         0x15, 0x00,          //   Logical Minimum (0),
 119         0x25, 0x01,          //   Logical Maximum (1),
 120         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 121
 122         // Reserved Byte
 123         0x75, 0x08,          //   Report Size (8),
 124         0x95, 0x01,          //   Report Count (1),
 125         0x81, 0x03,          //   Output (Constant),
 126
 127         // LED Report
 128         0x75, 0x01,          //   Report Size (1),
 129         0x95, 0x05,          //   Report Count (5),
 130         0x05, 0x08,          //   Usage Page (LEDs),
 131         0x19, 0x01,          //   Usage Minimum (1),
 132         0x29, 0x05,          //   Usage Maximum (5),
 133         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 134
 135         // LED Report Padding
 136         0x75, 0x03,          //   Report Size (3),
 137         0x95, 0x01,          //   Report Count (1),
 138         0x91, 0x03,          //   Output (Constant),
 139
 140         // Normal Keys
 141         0x75, 0x08,          //   Report Size (8),
 142         0x95, 0x06,          //   Report Count (6),
 143         0x15, 0x00,          //   Logical Minimum (0),
 144         0x25, 0x7F,          //   Logical Maximum(104),
 145         0x05, 0x07,          //   Usage Page (Key Codes),
 146         0x19, 0x00,          //   Usage Minimum (0),
 147         0x29, 0x7F,          //   Usage Maximum (104),
 148         0x81, 0x00,          //   Input (Data, Array),
 149         0xc0,                // End Collection - Keyboard
 150 };
 151
 152 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 153 static uint8_t nkro_keyboard_report_desc[] = {
 154         // Keyboard Collection
 155         0x05, 0x01,          // Usage Page (Generic Desktop),
 156         0x09, 0x06,          // Usage (Keyboard),
 157         0xA1, 0x01,          // Collection (Application) - Keyboard,
 158
 159         // LED Report
 160         0x85, 0x01,          //   Report ID (1),
 161         0x75, 0x01,          //   Report Size (1),
 162         0x95, 0x05,          //   Report Count (5),
 163         0x05, 0x08,          //   Usage Page (LEDs),
 164         0x19, 0x01,          //   Usage Minimum (1),
 165         0x29, 0x05,          //   Usage Maximum (5),
 166         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 167
 168         // LED Report Padding
 169         0x75, 0x03,          //   Report Size (3),
 170         0x95, 0x01,          //   Report Count (1),
 171         0x91, 0x03,          //   Output (Constant),
 172
 173         // Normal Keys - Using an NKRO Bitmap
 174         //
 175         // NOTES:
 176         // Supports all keys defined by the spec, except 1-3 which define error events
 177         //  and 0 which is "no keys pressed"
 178         // See http://www.usb.org/developers/hidpage/Hut1_12v2.pdf Chapter 10
 179         // Or Macros/PartialMap/usb_hid.h
 180         //
 181         // 50 (ISO \ due to \ bug) and 156 (Clear due to Delete bug) must be excluded
 182         //  due to a Linux bug with bitmaps (not useful anyways)
 183         // 165-175 are reserved/unused as well as 222-223 and 232-65535
 184         //
 185         // Compatibility Notes:
 186         //  - Using a second endpoint for a boot mode device helps with compatibility
 187         //  - DO NOT use Padding in the descriptor for bitfields
 188         //    (Mac OSX silently fails... Windows/Linux work correctly)
 189         //  - DO NOT use Report IDs, Windows 8.1 will not update keyboard correctly (modifiers disappear)
 190         //    (all other OSs, including OSX work fine...)
 191         //    (you can use them *iff* you only have 1 per collection)
 192         //  - Mac OSX and Windows 8.1 are extremely picky about padding
 193         //
 194         // Packing of bitmaps are as follows:
 195         //   4-49  :  6 bytes (0x04-0x31) ( 46 bits + 2 padding bits for 6 bytes total)
 196         //  51-155 : 14 bytes (0x33-0x9B) (105 bits + 6 padding bits for 15 bytes total)
 197         // 157-164 :  1 byte  (0x9D-0xA4) (  8 bits)
 198         // 176-221 :  6 bytes (0xB0-0xDD) ( 46 bits + 2 padding bits for 6 bytes total)
 199         // 224-231 :  1 byte  (0xE0-0xE7) (  8 bits)
 200
 201         // Modifier Byte
 202         0x75, 0x01,          //   Report Size (1),
 203         0x95, 0x08,          //   Report Count (8),
 204         0x15, 0x00,          //   Logical Minimum (0),
 205         0x25, 0x01,          //   Logical Maximum (1),
 206         0x05, 0x07,          //   Usage Page (Key Codes),
 207         0x19, 0xE0,          //   Usage Minimum (224),
 208         0x29, 0xE7,          //   Usage Maximum (231),
 209         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 210
 211         // 4-49 (6 bytes/46 bits) - MainKeys
 212         0x75, 0x01,          //   Report Size (1),
 213         0x95, 0x2E,          //   Report Count (46),
 214         0x15, 0x00,          //   Logical Minimum (0),
 215         0x25, 0x01,          //   Logical Maximum (1),
 216         0x05, 0x07,          //   Usage Page (Key Codes),
 217         0x19, 0x04,          //   Usage Minimum (4),
 218         0x29, 0x31,          //   Usage Maximum (49),
 219         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 220
 221         // Padding (2 bits)
 222         0x75, 0x02,          //   Report Size (2),
 223         0x95, 0x01,          //   Report Count (1),
 224         0x81, 0x03,          //   Input (Constant),
 225
 226         // 51-155 (14 bytes/105 bits) - SecondaryKeys
 227         0x75, 0x01,          //   Report Size (1),
 228         0x95, 0x69,          //   Report Count (105),
 229         0x15, 0x00,          //   Logical Minimum (0),
 230         0x25, 0x01,          //   Logical Maximum (1),
 231         0x05, 0x07,          //   Usage Page (Key Codes),
 232         0x19, 0x33,          //   Usage Minimum (51),
 233         0x29, 0x9B,          //   Usage Maximum (155),
 234         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 235
 236         // Padding (7 bits)
 237         0x75, 0x07,          //   Report Size (7),
 238         0x95, 0x01,          //   Report Count (1),
 239         0x81, 0x03,          //   Input (Constant),
 240
 241         // 157-164 (1 byte/8 bits) - TertiaryKeys
 242         0x75, 0x01,          //   Report Size (1),
 243         0x95, 0x08,          //   Report Count (8),
 244         0x15, 0x00,          //   Logical Minimum (0),
 245         0x25, 0x01,          //   Logical Maximum (1),
 246         0x05, 0x07,          //   Usage Page (Key Codes),
 247         0x19, 0x9D,          //   Usage Minimum (157),
 248         0x29, 0xA4,          //   Usage Maximum (164),
 249         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 250
 251         // 176-221 (6 bytes/46 bits) - QuartiaryKeys
 252         0x75, 0x01,          //   Report Size (1),
 253         0x95, 0x2E,          //   Report Count (46),
 254         0x15, 0x00,          //   Logical Minimum (0),
 255         0x25, 0x01,          //   Logical Maximum (1),
 256         0x05, 0x07,          //   Usage Page (Key Codes),
 257         0x19, 0xB0,          //   Usage Minimum (176),
 258         0x29, 0xDD,          //   Usage Maximum (221),
 259         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 260
 261         // Padding (2 bits)
 262         0x75, 0x02,          //   Report Size (2),
 263         0x95, 0x01,          //   Report Count (1),
 264         0x81, 0x03,          //   Input (Constant),
 265         0xc0,                // End Collection - Keyboard
 266 };
 267
 268 // System Control and Consumer Control
 269 static uint8_t sys_ctrl_report_desc[] = {
 270         // System Control Collection (8 bits)
 271         //
 272         // NOTES:
 273         // Not bothering with NKRO for this table. If there's need, I can implement it. -HaaTa
 274         // Using a 1KRO scheme
 275         0x05, 0x01,          // Usage Page (Generic Desktop),
 276         0x09, 0x80,          // Usage (System Control),
 277         0xA1, 0x01,          // Collection (Application),
 278         0x85, 0x02,          //   Report ID (2),
 279         0x75, 0x08,          //   Report Size (8),
 280         0x95, 0x01,          //   Report Count (1),
 281         0x16, 0x81, 0x00,    //   Logical Minimum (129),
 282         0x26, 0xB7, 0x00,    //   Logical Maximum (183),
 283         0x19, 0x81,          //   Usage Minimum (129),
 284         0x29, 0xB7,          //   Usage Maximum (183),
 285         0x81, 0x00,          //   Input (Data, Array),
 286         0xc0,                // End Collection - System Control
 287
 288         // Consumer Control Collection - Media Keys (16 bits)
 289         //
 290         // NOTES:
 291         // Not bothering with NKRO for this table. If there's a need, I can implement it. -HaaTa
 292         // Using a 1KRO scheme
 293         0x05, 0x0c,          // Usage Page (Consumer),
 294         0x09, 0x01,          // Usage (Consumer Control),
 295         0xA1, 0x01,          // Collection (Application),
 296         0x85, 0x03,          //   Report ID (3),
 297         0x75, 0x10,          //   Report Size (16),
 298         0x95, 0x01,          //   Report Count (1),
 299         0x16, 0x01, 0x00,    //   Logical Minimum (1),
 300         0x26, 0x9D, 0x02,    //   Logical Maximum (669),
 301         0x05, 0x0C,          //   Usage Page (Consumer),
 302         0x19, 0x01,          //   Usage Minimum (1),
 303         0x2A, 0x9D, 0x02,    //   Usage Maximum (669),
 304         0x81, 0x00,          //   Input (Data, Array),
 305         0xc0,                // End Collection - Consumer Control
 306 };
 307
 308 // Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension
 309 static uint8_t mouse_report_desc[] = {
 310         0x05, 0x01,        // Usage Page (Generic Desktop)
 311         0x09, 0x02,        // Usage (Mouse)
 312         0xA1, 0x01,        // Collection (Application)
 313         0x09, 0x02,        //   Usage (Mouse)
 314         0xA1, 0x02,        //   Collection (Logical)
 315         0x09, 0x01,        //     Usage (Pointer)
 316
 317         // Buttons (16 bits)
 318         0xA1, 0x00,        //     Collection (Physical) - Buttons
 319         0x05, 0x09,        //       Usage Page (Button)
 320         0x19, 0x01,        //       Usage Minimum (Button 1)
 321         0x29, 0x10,        //       Usage Maximum (Button 16)
 322         0x15, 0x00,        //       Logical Minimum (0)
 323         0x25, 0x01,        //       Logical Maximum (1)
 324         0x75, 0x01,        //       Report Size (1)
 325         0x95, 0x10,        //       Report Count (16)
 326         0x81, 0x02,        //       Input (Data,Var,Abs)
 327
 328         // Pointer (32 bits)
 329         0x05, 0x01,        //       Usage PAGE (Generic Desktop)
 330         0x09, 0x30,        //       Usage (X)
 331         0x09, 0x31,        //       Usage (Y)
 332         0x16, 0x01, 0x80,  //       Logical Minimum (-32 767)
 333         0x26, 0xFF, 0x7F,  //       Logical Maximum (32 767)
 334         0x75, 0x10,        //       Report Size (16)
 335         0x95, 0x02,        //       Report Count (2)
 336         0x81, 0x06,        //       Input (Data,Var,Rel)
 337
 338         /*
 339         // Vertical Wheel
 340         // - Multiplier (2 bits)
 341         0xa1, 0x02,        //       Collection (Logical)
 342         0x09, 0x48,        //         Usage (Resolution Multiplier)
 343         0x15, 0x00,        //         Logical Minimum (0)
 344         0x25, 0x01,        //         Logical Maximum (1)
 345         0x35, 0x01,        //         Physical Minimum (1)
 346         0x45, 0x04,        //         Physical Maximum (4)
 347         0x75, 0x02,        //         Report Size (2)
 348         0x95, 0x01,        //         Report Count (1)
 349         0xa4,              //         Push
 350         0xb1, 0x02,        //         Feature (Data,Var,Abs)
 351         // - Device (8 bits)
 352         0x09, 0x38,        //         Usage (Wheel)
 353         0x15, 0x81,        //         Logical Minimum (-127)
 354         0x25, 0x7f,        //         Logical Maximum (127)
 355         0x35, 0x00,        //         Physical Minimum (0)        - reset physical
 356         0x45, 0x00,        //         Physical Maximum (0)
 357         0x75, 0x08,        //         Report Size (8)
 358         0x81, 0x06,        //         Input (Data,Var,Rel)
 359         0xc0,              //       End Collection - Vertical Wheel
 360
 361         // Horizontal Wheel
 362         // - Multiplier (2 bits)
 363         0xa1, 0x02,        //       Collection (Logical)
 364         0x09, 0x48,        //         Usage (Resolution Multiplier)
 365         0xb4,              //         Pop
 366         0xb1, 0x02,        //         Feature (Data,Var,Abs)
 367         // - Padding (4 bits)
 368         0x35, 0x00,        //         Physical Minimum (0)        - reset physical
 369         0x45, 0x00,        //         Physical Maximum (0)
 370         0x75, 0x04,        //         Report Size (4)
 371         0xb1, 0x03,        //         Feature (Cnst,Var,Abs)
 372         // - Device (8 bits)
 373         0x05, 0x0c,        //         Usage Page (Consumer Devices)
 374         0x0a, 0x38, 0x02,  //         Usage (AC Pan)
 375         0x15, 0x81,        //         Logical Minimum (-127)
 376         0x25, 0x7f,        //         Logical Maximum (127)
 377         0x75, 0x08,        //         Report Size (8)
 378         0x81, 0x06,        //         Input (Data,Var,Rel)
 379         0xc0,              //       End Collection - Horizontal Wheel
 380
 381         */
 382         0xc0,              //     End Collection - Buttons
 383         0xc0,              //   End Collection - Mouse Logical
 384         0xc0               // End Collection - Mouse Application
 385 };
 386
 387 // Joystick Protocol, HID 1.11 spec, Apendix D, page 64-65
 388 static uint8_t joystick_report_desc[] = {
 389         0x05, 0x01,                     // Usage Page (Generic Desktop)
 390         0x09, 0x04,                     // Usage (Joystick)
 391         0xA1, 0x01,                     // Collection (Application)
 392         0x15, 0x00,                     // Logical Minimum (0)
 393         0x25, 0x01,                     // Logical Maximum (1)
 394         0x75, 0x01,                     // Report Size (1)
 395         0x95, 0x20,                     // Report Count (32)
 396         0x05, 0x09,                     // Usage Page (Button)
 397         0x19, 0x01,                     // Usage Minimum (Button #1)
 398         0x29, 0x20,                     // Usage Maximum (Button #32)
 399         0x81, 0x02,                     // Input (variable,absolute)
 400         0x15, 0x00,                     // Logical Minimum (0)
 401         0x25, 0x07,                     // Logical Maximum (7)
 402         0x35, 0x00,                     // Physical Minimum (0)
 403         0x46, 0x3B, 0x01,               // Physical Maximum (315)
 404         0x75, 0x04,                     // Report Size (4)
 405         0x95, 0x01,                     // Report Count (1)
 406         0x65, 0x14,                     // Unit (20)
 407         0x05, 0x01,                     // Usage Page (Generic Desktop)
 408         0x09, 0x39,                     // Usage (Hat switch)
 409         0x81, 0x42,                     // Input (variable,absolute,null_state)
 410         0x05, 0x01,                     // Usage Page (Generic Desktop)
 411         0x09, 0x01,                     // Usage (Pointer)
 412         0xA1, 0x00,                     // Collection ()
 413         0x15, 0x00,                     //   Logical Minimum (0)
 414         0x26, 0xFF, 0x03,               //   Logical Maximum (1023)
 415         0x75, 0x0A,                     //   Report Size (10)
 416         0x95, 0x04,                     //   Report Count (4)
 417         0x09, 0x30,                     //   Usage (X)
 418         0x09, 0x31,                     //   Usage (Y)
 419         0x09, 0x32,                     //   Usage (Z)
 420         0x09, 0x35,                     //   Usage (Rz)
 421         0x81, 0x02,                     //   Input (variable,absolute)
 422         0xC0,                           // End Collection
 423         0x15, 0x00,                     // Logical Minimum (0)
 424         0x26, 0xFF, 0x03,               // Logical Maximum (1023)
 425         0x75, 0x0A,                     // Report Size (10)
 426         0x95, 0x02,                     // Report Count (2)
 427         0x09, 0x36,                     // Usage (Slider)
 428         0x09, 0x36,                     // Usage (Slider)
 429         0x81, 0x02,                     // Input (variable,absolute)
 430         0xC0                            // End Collection
 431 };
 432
 433
 434
 435 // ----- USB Configuration -----
 436
 437 // USB Configuration Descriptor.  This huge descriptor tells all
 438 // of the devices capbilities.
 439 static uint8_t config_descriptor[CONFIG_DESC_SIZE] = {
 440 // --- Configuration ---
 441 // - 9 bytes -
 442         // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
 443         9,                                      // bLength;
 444         2,                                      // bDescriptorType;
 445         LSB(CONFIG_DESC_SIZE),                  // wTotalLength
 446         MSB(CONFIG_DESC_SIZE),
 447         NUM_INTERFACE,                          // bNumInterfaces
 448         1,                                      // bConfigurationValue
 449         0,                                      // iConfiguration
 450         0xA0,                                   // bmAttributes
 451         250,                                    // bMaxPower - Entry Index 8
 452
 453 // --- Keyboard HID --- Boot Mode Keyboard Interface
 454 // - 9 bytes -
 455         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 456         9,                                      // bLength
 457         4,                                      // bDescriptorType
 458         KEYBOARD_INTERFACE,                     // bInterfaceNumber
 459         0,                                      // bAlternateSetting
 460         1,                                      // bNumEndpoints
 461         0x03,                                   // bInterfaceClass (0x03 = HID)
 462         0x01,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 463         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 464         KEYBOARD_INTERFACE + 4,                 // iInterface
 465 // - 9 bytes -
 466         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 467         9,                                      // bLength
 468         0x21,                                   // bDescriptorType
 469         0x11, 0x01,                             // bcdHID
 470         KeyboardLocale_define,                  // bCountryCode
 471         1,                                      // bNumDescriptors
 472         0x22,                                   // bDescriptorType
 473         LSB(sizeof(keyboard_report_desc)),      // wDescriptorLength
 474         MSB(sizeof(keyboard_report_desc)),
 475 // - 7 bytes -
 476         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 477         7,                                      // bLength
 478         5,                                      // bDescriptorType
 479         KEYBOARD_ENDPOINT | 0x80,               // bEndpointAddress
 480         0x03,                                   // bmAttributes (0x03=intr)
 481         KEYBOARD_SIZE, 0,                       // wMaxPacketSize
 482         KEYBOARD_INTERVAL,                      // bInterval
 483
 484 // --- NKRO Keyboard HID --- OS Mode Keyboard Interface
 485 // - 9 bytes -
 486         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 487         9,                                      // bLength
 488         4,                                      // bDescriptorType
 489         NKRO_KEYBOARD_INTERFACE,                // bInterfaceNumber
 490         0,                                      // bAlternateSetting
 491         1,                                      // bNumEndpoints
 492         0x03,                                   // bInterfaceClass (0x03 = HID)
 493         0x00,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 494         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 495         NKRO_KEYBOARD_INTERFACE + 4,            // iInterface
 496 // - 9 bytes -
 497         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 498         9,                                      // bLength
 499         0x21,                                   // bDescriptorType
 500         0x11, 0x01,                             // bcdHID
 501         KeyboardLocale_define,                  // bCountryCode
 502         1,                                      // bNumDescriptors
 503         0x22,                                   // bDescriptorType
 504         LSB(sizeof(nkro_keyboard_report_desc)), // wDescriptorLength
 505         MSB(sizeof(nkro_keyboard_report_desc)),
 506 // - 7 bytes -
 507         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 508         7,                                      // bLength
 509         5,                                      // bDescriptorType
 510         NKRO_KEYBOARD_ENDPOINT | 0x80,          // bEndpointAddress
 511         0x03,                                   // bmAttributes (0x03=intr)
 512         NKRO_KEYBOARD_SIZE, 0,                  // wMaxPacketSize
 513         NKRO_KEYBOARD_INTERVAL,                 // bInterval
 514
 515 // --- Serial CDC --- CDC IAD Descriptor
 516 // - 8 bytes -
 517         // interface association descriptor, USB ECN, Table 9-Z
 518         8,                                      // bLength
 519         11,                                     // bDescriptorType
 520         CDC_STATUS_INTERFACE,                   // bFirstInterface
 521         2,                                      // bInterfaceCount
 522         0x02,                                   // bFunctionClass
 523         0x02,                                   // bFunctionSubClass
 524         0x01,                                   // bFunctionProtocol
 525         CDC_STATUS_INTERFACE + 4,               // iFunction
 526
 527 // --- Serial CDC --- CDC Data Interface
 528 // - 9 bytes -
 529         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 530         9,                                      // bLength
 531         4,                                      // bDescriptorType
 532         CDC_STATUS_INTERFACE,                   // bInterfaceNumber
 533         0,                                      // bAlternateSetting
 534         1,                                      // bNumEndpoints
 535         0x02,                                   // bInterfaceClass
 536         0x02,                                   // bInterfaceSubClass
 537         0x01,                                   // bInterfaceProtocol
 538         CDC_STATUS_INTERFACE + 4,               // iInterface
 539 // - 5 bytes -
 540         // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26
 541         5,                                      // bFunctionLength
 542         0x24,                                   // bDescriptorType
 543         0x00,                                   // bDescriptorSubtype
 544         0x10, 0x01,                             // bcdCDC
 545 // - 5 bytes -
 546         // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27
 547         5,                                      // bFunctionLength
 548         0x24,                                   // bDescriptorType
 549         0x01,                                   // bDescriptorSubtype
 550         0x01,                                   // bmCapabilities
 551         CDC_DATA_INTERFACE,                     // bDataInterface
 552 // - 4 bytes -
 553         // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28
 554         4,                                      // bFunctionLength
 555         0x24,                                   // bDescriptorType
 556         0x02,                                   // bDescriptorSubtype
 557         0x06,                                   // bmCapabilities
 558 // - 5 bytes -
 559         // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33
 560         5,                                      // bFunctionLength
 561         0x24,                                   // bDescriptorType
 562         0x06,                                   // bDescriptorSubtype
 563         CDC_STATUS_INTERFACE,                   // bMasterInterface
 564         CDC_DATA_INTERFACE,                     // bSlaveInterface0
 565 // - 7 bytes -
 566         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 567         7,                                      // bLength
 568         5,                                      // bDescriptorType
 569         CDC_ACM_ENDPOINT | 0x80,                // bEndpointAddress
 570         0x03,                                   // bmAttributes (0x03=intr)
 571         CDC_ACM_SIZE, 0,                        // wMaxPacketSize
 572         64,                                     // bInterval
 573 // - 9 bytes -
 574         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 575         9,                                      // bLength
 576         4,                                      // bDescriptorType
 577         CDC_DATA_INTERFACE,                     // bInterfaceNumber
 578         0,                                      // bAlternateSetting
 579         2,                                      // bNumEndpoints
 580         0x0A,                                   // bInterfaceClass
 581         0x00,                                   // bInterfaceSubClass
 582         0x00,                                   // bInterfaceProtocol
 583         CDC_DATA_INTERFACE + 4,                 // iInterface
 584 // - 7 bytes -
 585         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 586         7,                                      // bLength
 587         5,                                      // bDescriptorType
 588         CDC_RX_ENDPOINT,                        // bEndpointAddress
 589         0x02,                                   // bmAttributes (0x02=bulk)
 590         CDC_RX_SIZE, 0,                         // wMaxPacketSize
 591         0,                                      // bInterval
 592 // - 7 bytes -
 593         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 594         7,                                      // bLength
 595         5,                                      // bDescriptorType
 596         CDC_TX_ENDPOINT | 0x80,                 // bEndpointAddress
 597         0x02,                                   // bmAttributes (0x02=bulk)
 598         CDC_TX_SIZE, 0,                         // wMaxPacketSize
 599         0,                                      // bInterval
 600
 601 // --- Mouse Interface ---
 602 // - 9 bytes -
 603         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 604         9,                                      // bLength
 605         4,                                      // bDescriptorType
 606         MOUSE_INTERFACE,                        // bInterfaceNumber
 607         0,                                      // bAlternateSetting
 608         1,                                      // bNumEndpoints
 609         0x03,                                   // bInterfaceClass (0x03 = HID)
 610         0x00,                                   // bInterfaceSubClass (0x01 = Boot)
 611         0x02,                                   // bInterfaceProtocol (0x02 = Mouse)
 612         MOUSE_INTERFACE + 4,                    // iInterface
 613 // - 9 bytes -
 614         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 615         9,                                      // bLength
 616         0x21,                                   // bDescriptorType
 617         0x11, 0x01,                             // bcdHID
 618         0,                                      // bCountryCode
 619         1,                                      // bNumDescriptors
 620         0x22,                                   // bDescriptorType
 621         LSB(sizeof(mouse_report_desc)),         // wDescriptorLength
 622         MSB(sizeof(mouse_report_desc)),
 623 // - 7 bytes -
 624         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 625         7,                                      // bLength
 626         5,                                      // bDescriptorType
 627         MOUSE_ENDPOINT | 0x80,                  // bEndpointAddress
 628         0x03,                                   // bmAttributes (0x03=intr)
 629         MOUSE_SIZE, 0,                          // wMaxPacketSize
 630         MOUSE_INTERVAL,                         // bInterval
 631
 632 // --- Joystick Interface ---
 633 // - 9 bytes -
 634         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 635         9,                                      // bLength
 636         4,                                      // bDescriptorType
 637         JOYSTICK_INTERFACE,                     // bInterfaceNumber
 638         0,                                      // bAlternateSetting
 639         1,                                      // bNumEndpoints
 640         0x03,                                   // bInterfaceClass (0x03 = HID)
 641         0x00,                                   // bInterfaceSubClass
 642         0x00,                                   // bInterfaceProtocol
 643         JOYSTICK_INTERFACE + 4,                 // iInterface
 644 // - 9 bytes -
 645         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 646         9,                                      // bLength
 647         0x21,                                   // bDescriptorType
 648         0x11, 0x01,                             // bcdHID
 649         0,                                      // bCountryCode
 650         1,                                      // bNumDescriptors
 651         0x22,                                   // bDescriptorType
 652         LSB(sizeof(joystick_report_desc)),      // wDescriptorLength
 653         MSB(sizeof(joystick_report_desc)),
 654 // - 7 bytes -
 655         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 656         7,                                      // bLength
 657         5,                                      // bDescriptorType
 658         JOYSTICK_ENDPOINT | 0x80,               // bEndpointAddress
 659         0x03,                                   // bmAttributes (0x03=intr)
 660         JOYSTICK_SIZE, 0,                       // wMaxPacketSize
 661         JOYSTICK_INTERVAL,                      // bInterval
 662
 663 // --- System/Consumer Control ---
 664 // - 9 bytes -
 665         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 666         9,                                      // bLength
 667         4,                                      // bDescriptorType
 668         SYS_CTRL_INTERFACE,                     // bInterfaceNumber
 669         0,                                      // bAlternateSetting
 670         1,                                      // bNumEndpoints
 671         0x03,                                   // bInterfaceClass (0x03 = HID)
 672         0x01,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 673         0x00,                                   // bInterfaceProtocol (0x00 = None)
 674         SYS_CTRL_INTERFACE + 4,                 // iInterface
 675 // - 9 bytes -
 676         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 677         9,                                      // bLength
 678         0x21,                                   // bDescriptorType
 679         0x11, 0x01,                             // bcdHID
 680         KeyboardLocale_define,                  // bCountryCode
 681         1,                                      // bNumDescriptors
 682         0x22,                                   // bDescriptorType
 683         LSB(sizeof(sys_ctrl_report_desc)),      // wDescriptorLength
 684         MSB(sizeof(sys_ctrl_report_desc)),
 685 // - 7 bytes -
 686         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 687         7,                                      // bLength
 688         5,                                      // bDescriptorType
 689         SYS_CTRL_ENDPOINT | 0x80,               // bEndpointAddress
 690         0x03,                                   // bmAttributes (0x03=intr)
 691         SYS_CTRL_SIZE, 0,                       // wMaxPacketSize
 692         SYS_CTRL_INTERVAL,                      // bInterval
 693 };
 694
 695 uint8_t *usb_bMaxPower = &config_descriptor[8];
 696
 697
 698
 699 // ----- String Descriptors -----
 700
 701 // The descriptors above can provide human readable strings,
 702 // referenced by index numbers.  These descriptors are the
 703 // actual string data
 704
 705 struct usb_string_descriptor_struct {
 706         uint8_t bLength;
 707         uint8_t bDescriptorType;
 708         uint16_t wString[];
 709 };
 710
 711 extern struct usb_string_descriptor_struct usb_string_manufacturer_name
 712         __attribute__ ((weak, alias("usb_string_manufacturer_name_default")));
 713 extern struct usb_string_descriptor_struct usb_string_product_name
 714         __attribute__ ((weak, alias("usb_string_product_name_default")));
 715 extern struct usb_string_descriptor_struct usb_string_serial_number
 716         __attribute__ ((weak, alias("usb_string_serial_number_default")));
 717
 718 struct usb_string_descriptor_struct string0 = {
 719         4,
 720         3,
 721         {0x0409}
 722 };
 723
 724 #define usb_string_descriptor(name, str) \
 725         struct usb_string_descriptor_struct name = { \
 726                 sizeof(str), \
 727                 3, \
 728                 {str} \
 729         }
 730
 731 usb_string_descriptor( usb_string_manufacturer_name_default, STR_MANUFACTURER );
 732 usb_string_descriptor( usb_string_product_name_default, STR_PRODUCT );
 733 usb_string_descriptor( usb_string_serial_number_default, STR_SERIAL );
 734 usb_string_descriptor( usb_string_keyboard_name, KEYBOARD_NAME );
 735 usb_string_descriptor( usb_string_nkro_keyboard_name, NKRO_KEYBOARD_NAME );
 736 usb_string_descriptor( usb_string_cdc_status_name, CDC_STATUS_NAME );
 737 usb_string_descriptor( usb_string_cdc_data_name, CDC_DATA_NAME );
 738 usb_string_descriptor( usb_string_mouse_name, MOUSE_NAME );
 739 usb_string_descriptor( usb_string_joystick_name, JOYSTICK_NAME );
 740 usb_string_descriptor( usb_string_sys_ctrl_name, SYS_CTRL_NAME );
 741
 742
 743
 744 // ----- Descriptors List -----
 745
 746 // This table provides access to all the descriptor data above.
 747
 748 const usb_descriptor_list_t usb_descriptor_list[] = {
 749         //wValue, wIndex, address,          length
 750         {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
 751         {0x0200, 0x0000, config_descriptor, sizeof(config_descriptor)},
 752         {0x0600, 0x0000, device_qualifier_descriptor, sizeof(device_qualifier_descriptor)},
 753         {0x0A00, 0x0000, usb_debug_descriptor, sizeof(usb_debug_descriptor)},
 754
 755         {0x2200, KEYBOARD_INTERFACE, keyboard_report_desc, sizeof(keyboard_report_desc)},
 756         {0x2100, KEYBOARD_INTERFACE, config_descriptor + KEYBOARD_DESC_OFFSET, 9},
 757
 758         {0x2200, NKRO_KEYBOARD_INTERFACE, nkro_keyboard_report_desc, sizeof(nkro_keyboard_report_desc)},
 759         {0x2100, NKRO_KEYBOARD_INTERFACE, config_descriptor + NKRO_KEYBOARD_DESC_OFFSET, 9},
 760
 761         {0x2200, MOUSE_INTERFACE, mouse_report_desc, sizeof(mouse_report_desc)},
 762         {0x2100, MOUSE_INTERFACE, config_descriptor + MOUSE_DESC_OFFSET, 9},
 763
 764         {0x2200, JOYSTICK_INTERFACE, joystick_report_desc, sizeof(joystick_report_desc)},
 765         {0x2100, JOYSTICK_INTERFACE, config_descriptor + JOYSTICK_DESC_OFFSET, 9},
 766
 767         {0x2200, SYS_CTRL_INTERFACE, sys_ctrl_report_desc, sizeof(sys_ctrl_report_desc)},
 768         {0x2100, SYS_CTRL_INTERFACE, config_descriptor + SYS_CTRL_DESC_OFFSET, 9},
 769
 770 #define iInterfaceString(num, var) \
 771         {0x0300 + 4 + num, 0x409, (const uint8_t *)&var, 0 }
 772
 773         {0x0300, 0x0000, (const uint8_t *)&string0, 0},
 774         {0x0301, 0x0409, (const uint8_t *)&usb_string_manufacturer_name, 0},
 775         {0x0302, 0x0409, (const uint8_t *)&usb_string_product_name, 0},
 776         {0x0303, 0x0409, (const uint8_t *)&usb_string_serial_number, 0},
 777         iInterfaceString( KEYBOARD_INTERFACE, usb_string_keyboard_name ),
 778         iInterfaceString( NKRO_KEYBOARD_INTERFACE, usb_string_nkro_keyboard_name ),
 779         iInterfaceString( CDC_STATUS_INTERFACE, usb_string_cdc_status_name ),
 780         iInterfaceString( CDC_DATA_INTERFACE, usb_string_cdc_data_name ),
 781         iInterfaceString( MOUSE_INTERFACE, usb_string_mouse_name ),
 782         iInterfaceString( JOYSTICK_INTERFACE, usb_string_joystick_name ),
 783         iInterfaceString( SYS_CTRL_INTERFACE, usb_string_sys_ctrl_name ),
 784         {0, 0, NULL, 0}
 785 };
 786
 787
 788
 789 // ----- Endpoint Configuration -----
 790
 791 // See usb_desc.h for Endpoint configuration
 792 // 0x00 = not used
 793 // 0x19 = Recieve only
 794 // 0x15 = Transmit only
 795 // 0x1D = Transmit & Recieve
 796 //
 797 const uint8_t usb_endpoint_config_table[NUM_ENDPOINTS] =
 798 {
 799 #if (defined(ENDPOINT1_CONFIG) && NUM_ENDPOINTS >= 1)
 800         ENDPOINT1_CONFIG,
 801 #elif (NUM_ENDPOINTS >= 1)
 802         ENDPOINT_UNUSED,
 803 #endif
 804 #if (defined(ENDPOINT2_CONFIG) && NUM_ENDPOINTS >= 2)
 805         ENDPOINT2_CONFIG,
 806 #elif (NUM_ENDPOINTS >= 2)
 807         ENDPOINT_UNUSED,
 808 #endif
 809 #if (defined(ENDPOINT3_CONFIG) && NUM_ENDPOINTS >= 3)
 810         ENDPOINT3_CONFIG,
 811 #elif (NUM_ENDPOINTS >= 3)
 812         ENDPOINT_UNUSED,
 813 #endif
 814 #if (defined(ENDPOINT4_CONFIG) && NUM_ENDPOINTS >= 4)
 815         ENDPOINT4_CONFIG,
 816 #elif (NUM_ENDPOINTS >= 4)
 817         ENDPOINT_UNUSED,
 818 #endif
 819 #if (defined(ENDPOINT5_CONFIG) && NUM_ENDPOINTS >= 5)
 820         ENDPOINT5_CONFIG,
 821 #elif (NUM_ENDPOINTS >= 5)
 822         ENDPOINT_UNUSED,
 823 #endif
 824 #if (defined(ENDPOINT6_CONFIG) && NUM_ENDPOINTS >= 6)
 825         ENDPOINT6_CONFIG,
 826 #elif (NUM_ENDPOINTS >= 6)
 827         ENDPOINT_UNUSED,
 828 #endif
 829 #if (defined(ENDPOINT7_CONFIG) && NUM_ENDPOINTS >= 7)
 830         ENDPOINT7_CONFIG,
 831 #elif (NUM_ENDPOINTS >= 7)
 832         ENDPOINT_UNUSED,
 833 #endif
 834 #if (defined(ENDPOINT8_CONFIG) && NUM_ENDPOINTS >= 8)
 835         ENDPOINT8_CONFIG,
 836 #elif (NUM_ENDPOINTS >= 8)
 837         ENDPOINT_UNUSED,
 838 #endif
 839 #if (defined(ENDPOINT9_CONFIG) && NUM_ENDPOINTS >= 9)
 840         ENDPOINT9_CONFIG,
 841 #elif (NUM_ENDPOINTS >= 9)
 842         ENDPOINT_UNUSED,
 843 #endif
 844 #if (defined(ENDPOINT10_CONFIG) && NUM_ENDPOINTS >= 10)
 845         ENDPOINT10_CONFIG,
 846 #elif (NUM_ENDPOINTS >= 10)
 847         ENDPOINT_UNUSED,
 848 #endif
 849 #if (defined(ENDPOINT11_CONFIG) && NUM_ENDPOINTS >= 11)
 850         ENDPOINT11_CONFIG,
 851 #elif (NUM_ENDPOINTS >= 11)
 852         ENDPOINT_UNUSED,
 853 #endif
 854 #if (defined(ENDPOINT12_CONFIG) && NUM_ENDPOINTS >= 12)
 855         ENDPOINT12_CONFIG,
 856 #elif (NUM_ENDPOINTS >= 12)
 857         ENDPOINT_UNUSED,
 858 #endif
 859 #if (defined(ENDPOINT13_CONFIG) && NUM_ENDPOINTS >= 13)
 860         ENDPOINT13_CONFIG,
 861 #elif (NUM_ENDPOINTS >= 13)
 862         ENDPOINT_UNUSED,
 863 #endif
 864 #if (defined(ENDPOINT14_CONFIG) && NUM_ENDPOINTS >= 14)
 865         ENDPOINT14_CONFIG,
 866 #elif (NUM_ENDPOINTS >= 14)
 867         ENDPOINT_UNUSED,
 868 #endif
 869 #if (defined(ENDPOINT15_CONFIG) && NUM_ENDPOINTS >= 15)
 870         ENDPOINT15_CONFIG,
 871 #elif (NUM_ENDPOINTS >= 15)
 872         ENDPOINT_UNUSED,
 873 #endif
 874 };
 875
 876