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-2014)
   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
  38
  39 // ----- Macros -----
  40
  41 #define LSB(n) ((n) & 255)
  42 #define MSB(n) (((n) >> 8) & 255)
  43
  44
  45
  46 // ----- USB Device Descriptor -----
  47
  48 // USB Device Descriptor.  The USB host reads this first, to learn
  49 // what type of device is connected.
  50 static uint8_t device_descriptor[] = {
  51         18,                                     // bLength
  52         1,                                      // bDescriptorType
  53         0x00, 0x02,                             // bcdUSB
  54         DEVICE_CLASS,                           // bDeviceClass
  55         DEVICE_SUBCLASS,                        // bDeviceSubClass
  56         DEVICE_PROTOCOL,                        // bDeviceProtocol
  57         EP0_SIZE,                               // bMaxPacketSize0
  58         LSB(VENDOR_ID), MSB(VENDOR_ID),         // idVendor
  59         LSB(PRODUCT_ID), MSB(PRODUCT_ID),       // idProduct
  60         0x00, 0x01,                             // bcdDevice
  61         1,                                      // iManufacturer
  62         2,                                      // iProduct
  63         3,                                      // iSerialNumber
  64         1                                       // bNumConfigurations
  65 };
  66
  67 // USB Device Qualifier Descriptor
  68 static uint8_t device_qualifier_descriptor[] = {
  69         0                                       // Indicate only single speed
  70         /* Device qualifier example (used for specifying multiple USB speeds)
  71         10,                                     // bLength
  72         6,                                      // bDescriptorType
  73         0x00, 0x02,                             // bcdUSB
  74         DEVICE_CLASS,                           // bDeviceClass
  75         DEVICE_SUBCLASS,                        // bDeviceSubClass
  76         DEVICE_PROTOCOL,                        // bDeviceProtocol
  77         EP0_SIZE,                               // bMaxPacketSize0
  78         0,                                      // bNumOtherSpeedConfigurations
  79         0                                       // bReserved
  80         */
  81 };
  82
  83 // USB Debug Descriptor
  84 // XXX Not sure of exact use, lsusb requests it
  85 static uint8_t usb_debug_descriptor[] = {
  86         0
  87 };
  88
  89 // XXX
  90 // These descriptors must NOT be "const", because the USB DMA
  91 // has trouble accessing flash memory with enough bandwidth
  92 // while the processor is executing from flash.
  93 // XXX
  94
  95
  96
  97 // ----- USB HID Report Descriptsors -----
  98
  99 // Each HID interface needs a special report descriptor that tells
 100 // the meaning and format of the data.
 101
 102 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 103 static uint8_t keyboard_report_desc[] = {
 104         // Keyboard Collection
 105         0x05, 0x01,          // Usage Page (Generic Desktop),
 106         0x09, 0x06,          // Usage (Keyboard),
 107         0xA1, 0x01,          // Collection (Application) - Keyboard,
 108
 109         // Modifier Byte
 110         0x75, 0x01,          //   Report Size (1),
 111         0x95, 0x08,          //   Report Count (8),
 112         0x05, 0x07,          //   Usage Page (Key Codes),
 113         0x19, 0xE0,          //   Usage Minimum (224),
 114         0x29, 0xE7,          //   Usage Maximum (231),
 115         0x15, 0x00,          //   Logical Minimum (0),
 116         0x25, 0x01,          //   Logical Maximum (1),
 117         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 118
 119         // Reserved Byte
 120         0x75, 0x08,          //   Report Size (8),
 121         0x95, 0x01,          //   Report Count (1),
 122         0x81, 0x03,          //   Output (Constant),
 123
 124         // LED Report
 125         0x75, 0x01,          //   Report Size (1),
 126         0x95, 0x05,          //   Report Count (5),
 127         0x05, 0x08,          //   Usage Page (LEDs),
 128         0x19, 0x01,          //   Usage Minimum (1),
 129         0x29, 0x05,          //   Usage Maximum (5),
 130         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 131
 132         // LED Report Padding
 133         0x75, 0x03,          //   Report Size (3),
 134         0x95, 0x01,          //   Report Count (1),
 135         0x91, 0x03,          //   Output (Constant),
 136
 137         // Normal Keys
 138         0x75, 0x08,          //   Report Size (8),
 139         0x95, 0x06,          //   Report Count (6),
 140         0x15, 0x00,          //   Logical Minimum (0),
 141         0x25, 0x7F,          //   Logical Maximum(104),
 142         0x05, 0x07,          //   Usage Page (Key Codes),
 143         0x19, 0x00,          //   Usage Minimum (0),
 144         0x29, 0x7F,          //   Usage Maximum (104),
 145         0x81, 0x00,          //   Input (Data, Array),
 146         0xc0,                // End Collection - Keyboard
 147 };
 148
 149 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 150 static uint8_t nkro_keyboard_report_desc[] = {
 151         // Keyboard Collection
 152         0x05, 0x01,          // Usage Page (Generic Desktop),
 153         0x09, 0x06,          // Usage (Keyboard),
 154         0xA1, 0x01,          // Collection (Application) - Keyboard,
 155
 156         // Modifier Byte
 157         0x85, 0x01,          //   Report ID (1),
 158         0x75, 0x01,          //   Report Size (1),
 159         0x95, 0x08,          //   Report Count (8),
 160         0x15, 0x00,          //   Logical Minimum (0),
 161         0x25, 0x01,          //   Logical Maximum (1),
 162         0x05, 0x07,          //   Usage Page (Key Codes),
 163         0x19, 0xE0,          //   Usage Minimum (224),
 164         0x29, 0xE7,          //   Usage Maximum (231),
 165         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 166
 167         // LED Report
 168         0x85, 0x02,          //   Report ID (2),
 169         0x75, 0x01,          //   Report Size (1),
 170         0x95, 0x05,          //   Report Count (5),
 171         0x05, 0x08,          //   Usage Page (LEDs),
 172         0x19, 0x01,          //   Usage Minimum (1),
 173         0x29, 0x05,          //   Usage Maximum (5),
 174         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 175
 176         // LED Report Padding
 177         0x75, 0x03,          //   Report Size (3),
 178         0x95, 0x01,          //   Report Count (1),
 179         0x91, 0x03,          //   Output (Constant),
 180
 181         // Normal Keys - Using an NKRO Bitmap
 182         //
 183         // NOTES:
 184         // Supports all keys defined by the spec, except 1-3 which define error events
 185         //  and 0 which is "no keys pressed"
 186         // See http://www.usb.org/developers/hidpage/Hut1_12v2.pdf Chapter 10
 187         // Or Macros/PartialMap/usb_hid.h
 188         //
 189         // 50 must be excluded due to a Linux bug with bitmaps (not useful anyways)
 190         // 165-175 are reserved/unused as well as 222-223 and 232-65535
 191         // 224-231 are used for modifiers (see above)
 192         //
 193         // Compatibility Notes:
 194         //  - Using a second endpoint for a boot mode device helps with compatibility
 195         //  - DO NOT use Padding in the descriptor for bitfields
 196         //    (Mac OSX silently fails... Windows/Linux work correctly)
 197         //
 198         // Packing of bitmaps are as follows:
 199         //   4-49  :  6 bytes + 1 Report ID byte (0x04-0x31) ( 46 bits + 2 padding bits for 6 bytes total)
 200         //  51-164 : 20 bytes + 1 Report ID byte (0x33-0xA4) (114 bits + 6 padding bits for 15 bytes total)
 201         // 176-221 :  6 bytes + 1 Report ID byte (0xB0-0xDD) ( 46 bits + 2 padding bits for 6 bytes total)
 202         //
 203         // 4-49 (6 bytes/46 bits)
 204         0x85, 0x03,          //   Report ID (3),
 205         0x75, 0x01,          //   Report Size (1),
 206         0x95, 0x2E,          //   Report Count (46),
 207         0x15, 0x00,          //   Logical Minimum (0),
 208         0x25, 0x01,          //   Logical Maximum (1),
 209         0x05, 0x07,          //   Usage Page (Key Codes),
 210         0x19, 0x04,          //   Usage Minimum (4),
 211         0x29, 0x31,          //   Usage Maximum (49),
 212         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 213
 214         // Should pad 2 bits according to the spec, but OSX doesn't like this -HaaTa
 215
 216         // 51-164 (15 bytes/160 bits)
 217         0x85, 0x04,          //   Report ID (4),
 218         0x75, 0x01,          //   Report Size (1),
 219         0x95, 0xA0,          //   Report Count (160),
 220         0x15, 0x00,          //   Logical Minimum (0),
 221         0x25, 0x01,          //   Logical Maximum (1),
 222         0x05, 0x07,          //   Usage Page (Key Codes),
 223         0x19, 0x33,          //   Usage Minimum (51),
 224         0x29, 0xA4,          //   Usage Maximum (164),
 225         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 226
 227         // Should pad 6 bits according to the spec, but OSX doesn't like this -HaaTa
 228
 229         // 176-221 (6 bytes/46 bits)
 230         0x85, 0x05,          //   Report ID (5),
 231         0x75, 0x01,          //   Report Size (1),
 232         0x95, 0x2D,          //   Report Count (45),
 233         0x15, 0x00,          //   Logical Minimum (0),
 234         0x25, 0x01,          //   Logical Maximum (1),
 235         0x05, 0x07,          //   Usage Page (Key Codes),
 236         0x19, 0xB0,          //   Usage Minimum (176),
 237         0x29, 0xDD,          //   Usage Maximum (221),
 238         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 239
 240         // Should pad 2 bits according to the spec, but OSX doesn't like this -HaaTa
 241
 242         0xc0,                // End Collection - Keyboard
 243
 244         // System Control Collection
 245         //
 246         // NOTES:
 247         // Not bothering with NKRO for this table. If there's need, I can implement it. -HaaTa
 248         // Using a 1KRO scheme
 249         0x05, 0x01,          // Usage Page (Generic Desktop),
 250         0x09, 0x80,          // Usage (System Control),
 251         0xA1, 0x01,          // Collection (Application),
 252         0x85, 0x06,          //   Report ID (6),
 253         0x75, 0x08,          //   Report Size (8),
 254         0x95, 0x01,          //   Report Count (1),
 255         0x16, 0x81, 0x00,    //   Logical Minimum (129),
 256         0x26, 0xB7, 0x00,    //   Logical Maximum (183),
 257         0x19, 0x81,          //   Usage Minimum (129),
 258         0x29, 0xB7,          //   Usage Maximum (183),
 259         0x81, 0x00,          //   Input (Data, Array),
 260         0xc0,                // End Collection - System Control
 261
 262         // Consumer Control Collection - Media Keys
 263         //
 264         // NOTES:
 265         // Not bothering with NKRO for this table. If there's a need, I can implement it. -HaaTa
 266         // Using a 1KRO scheme
 267         0x05, 0x0c,          // Usage Page (Consumer),
 268         0x09, 0x01,          // Usage (Consumer Control),
 269         0xA1, 0x01,          // Collection (Application),
 270         0x85, 0x07,          //   Report ID (7),
 271         0x75, 0x10,          //   Report Size (16),
 272         0x95, 0x01,          //   Report Count (1),
 273         0x16, 0x20, 0x00,    //   Logical Minimum (32),
 274         0x26, 0x9C, 0x02,    //   Logical Maximum (668),
 275         0x05, 0x0C,          //   Usage Page (Consumer),
 276         0x19, 0x20,          //   Usage Minimum (32),
 277         0x2A, 0x9C, 0x02,    //   Usage Maximum (668),
 278         0x81, 0x00,          //   Input (Data, Array),
 279         0xc0,                // End Collection - Consumer Control
 280 };
 281
 282 /* MOUSE
 283 // Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension
 284 static uint8_t mouse_report_desc[] = {
 285         0x05, 0x01,                     // Usage Page (Generic Desktop)
 286         0x09, 0x02,                     // Usage (Mouse)
 287         0xA1, 0x01,                     // Collection (Application)
 288         0x05, 0x09,                     //   Usage Page (Button)
 289         0x19, 0x01,                     //   Usage Minimum (Button #1)
 290         0x29, 0x03,                     //   Usage Maximum (Button #3)
 291         0x15, 0x00,                     //   Logical Minimum (0)
 292         0x25, 0x01,                     //   Logical Maximum (1)
 293         0x95, 0x03,                     //   Report Count (3)
 294         0x75, 0x01,                     //   Report Size (1)
 295         0x81, 0x02,                     //   Input (Data, Variable, Absolute)
 296         0x95, 0x01,                     //   Report Count (1)
 297         0x75, 0x05,                     //   Report Size (5)
 298         0x81, 0x03,                     //   Input (Constant)
 299         0x05, 0x01,                     //   Usage Page (Generic Desktop)
 300         0x09, 0x30,                     //   Usage (X)
 301         0x09, 0x31,                     //   Usage (Y)
 302         0x15, 0x00,                     //   Logical Minimum (0)
 303         0x26, 0xFF, 0x7F,               //   Logical Maximum (32767)
 304         0x75, 0x10,                     //   Report Size (16),
 305         0x95, 0x02,                     //   Report Count (2),
 306         0x81, 0x02,                     //   Input (Data, Variable, Absolute)
 307         0x09, 0x38,                     //   Usage (Wheel)
 308         0x15, 0x81,                     //   Logical Minimum (-127)
 309         0x25, 0x7F,                     //   Logical Maximum (127)
 310         0x75, 0x08,                     //   Report Size (8),
 311         0x95, 0x01,                     //   Report Count (1),
 312         0x81, 0x06,                     //   Input (Data, Variable, Relative)
 313         0xC0                            // End Collection
 314 };
 315 */
 316
 317
 318
 319 // ----- USB Configuration -----
 320
 321 // USB Configuration Descriptor.  This huge descriptor tells all
 322 // of the devices capbilities.
 323 static uint8_t config_descriptor[CONFIG_DESC_SIZE] = {
 324 // --- Configuration ---
 325 // - 9 bytes -
 326         // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
 327         9,                                      // bLength;
 328         2,                                      // bDescriptorType;
 329         LSB(CONFIG_DESC_SIZE),                  // wTotalLength
 330         MSB(CONFIG_DESC_SIZE),
 331         NUM_INTERFACE,                          // bNumInterfaces
 332         1,                                      // bConfigurationValue
 333         0,                                      // iConfiguration
 334         0xA0,                                   // bmAttributes
 335         250,                                    // bMaxPower
 336
 337 // --- Keyboard HID --- Boot Mode Keyboard Interface
 338 // - 9 bytes -
 339         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 340         9,                                      // bLength
 341         4,                                      // bDescriptorType
 342         KEYBOARD_INTERFACE,                     // bInterfaceNumber
 343         0,                                      // bAlternateSetting
 344         1,                                      // bNumEndpoints
 345         0x03,                                   // bInterfaceClass (0x03 = HID)
 346         0x01,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 347         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 348         0,                                      // iInterface
 349 // - 9 bytes -
 350         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 351         9,                                      // bLength
 352         0x21,                                   // bDescriptorType
 353         0x11, 0x01,                             // bcdHID
 354         0,                                      // bCountryCode
 355         1,                                      // bNumDescriptors
 356         0x22,                                   // bDescriptorType
 357         LSB(sizeof(keyboard_report_desc)),      // wDescriptorLength
 358         MSB(sizeof(keyboard_report_desc)),
 359 // - 7 bytes -
 360         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 361         7,                                      // bLength
 362         5,                                      // bDescriptorType
 363         KEYBOARD_ENDPOINT | 0x80,               // bEndpointAddress
 364         0x03,                                   // bmAttributes (0x03=intr)
 365         KEYBOARD_SIZE, 0,                       // wMaxPacketSize
 366         KEYBOARD_INTERVAL,                      // bInterval
 367
 368 // --- NKRO Keyboard HID --- OS Mode Keyboard Interface
 369 // - 9 bytes -
 370         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 371         9,                                      // bLength
 372         4,                                      // bDescriptorType
 373         NKRO_KEYBOARD_INTERFACE,                // bInterfaceNumber
 374         0,                                      // bAlternateSetting
 375         1,                                      // bNumEndpoints
 376         0x03,                                   // bInterfaceClass (0x03 = HID)
 377         0x00,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 378         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 379         0,                                      // iInterface
 380 // - 9 bytes -
 381         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 382         9,                                      // bLength
 383         0x21,                                   // bDescriptorType
 384         0x11, 0x01,                             // bcdHID
 385         0,                                      // bCountryCode
 386         1,                                      // bNumDescriptors
 387         0x22,                                   // bDescriptorType
 388         LSB(sizeof(nkro_keyboard_report_desc)), // wDescriptorLength
 389         MSB(sizeof(nkro_keyboard_report_desc)),
 390 // - 7 bytes -
 391         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 392         7,                                      // bLength
 393         5,                                      // bDescriptorType
 394         NKRO_KEYBOARD_ENDPOINT | 0x80,          // bEndpointAddress
 395         0x03,                                   // bmAttributes (0x03=intr)
 396         NKRO_KEYBOARD_SIZE, 0,                  // wMaxPacketSize
 397         NKRO_KEYBOARD_INTERVAL,                 // bInterval
 398
 399 // --- Serial CDC --- CDC IAD Descriptor
 400 // - 8 bytes -
 401         // interface association descriptor, USB ECN, Table 9-Z
 402         8,                                      // bLength
 403         11,                                     // bDescriptorType
 404         CDC_STATUS_INTERFACE,                   // bFirstInterface
 405         2,                                      // bInterfaceCount
 406         0x02,                                   // bFunctionClass
 407         0x02,                                   // bFunctionSubClass
 408         0x01,                                   // bFunctionProtocol
 409         0,                                      // iFunction
 410
 411 // --- Serial CDC --- CDC Data Interface
 412 // - 9 bytes -
 413         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 414         9,                                      // bLength
 415         4,                                      // bDescriptorType
 416         CDC_STATUS_INTERFACE,                   // bInterfaceNumber
 417         0,                                      // bAlternateSetting
 418         1,                                      // bNumEndpoints
 419         0x02,                                   // bInterfaceClass
 420         0x02,                                   // bInterfaceSubClass
 421         0x01,                                   // bInterfaceProtocol
 422         0,                                      // iInterface
 423 // - 5 bytes -
 424         // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26
 425         5,                                      // bFunctionLength
 426         0x24,                                   // bDescriptorType
 427         0x00,                                   // bDescriptorSubtype
 428         0x10, 0x01,                             // bcdCDC
 429 // - 5 bytes -
 430         // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27
 431         5,                                      // bFunctionLength
 432         0x24,                                   // bDescriptorType
 433         0x01,                                   // bDescriptorSubtype
 434         0x01,                                   // bmCapabilities
 435         CDC_DATA_INTERFACE,                     // bDataInterface
 436 // - 4 bytes -
 437         // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28
 438         4,                                      // bFunctionLength
 439         0x24,                                   // bDescriptorType
 440         0x02,                                   // bDescriptorSubtype
 441         0x06,                                   // bmCapabilities
 442 // - 5 bytes -
 443         // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33
 444         5,                                      // bFunctionLength
 445         0x24,                                   // bDescriptorType
 446         0x06,                                   // bDescriptorSubtype
 447         CDC_STATUS_INTERFACE,                   // bMasterInterface
 448         CDC_DATA_INTERFACE,                     // bSlaveInterface0
 449 // - 7 bytes -
 450         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 451         7,                                      // bLength
 452         5,                                      // bDescriptorType
 453         CDC_ACM_ENDPOINT | 0x80,                // bEndpointAddress
 454         0x03,                                   // bmAttributes (0x03=intr)
 455         CDC_ACM_SIZE, 0,                        // wMaxPacketSize
 456         64,                                     // bInterval
 457 // - 9 bytes -
 458         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 459         9,                                      // bLength
 460         4,                                      // bDescriptorType
 461         CDC_DATA_INTERFACE,                     // bInterfaceNumber
 462         0,                                      // bAlternateSetting
 463         2,                                      // bNumEndpoints
 464         0x0A,                                   // bInterfaceClass
 465         0x00,                                   // bInterfaceSubClass
 466         0x00,                                   // bInterfaceProtocol
 467         0,                                      // iInterface
 468 // - 7 bytes -
 469         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 470         7,                                      // bLength
 471         5,                                      // bDescriptorType
 472         CDC_RX_ENDPOINT,                        // bEndpointAddress
 473         0x02,                                   // bmAttributes (0x02=bulk)
 474         CDC_RX_SIZE, 0,                         // wMaxPacketSize
 475         0,                                      // bInterval
 476 // - 7 bytes -
 477         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 478         7,                                      // bLength
 479         5,                                      // bDescriptorType
 480         CDC_TX_ENDPOINT | 0x80,                 // bEndpointAddress
 481         0x02,                                   // bmAttributes (0x02=bulk)
 482         CDC_TX_SIZE, 0,                         // wMaxPacketSize
 483         0,                                      // bInterval
 484
 485 /*
 486 // Mouse Interface
 487 // - 9 bytes -
 488         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 489         9,                                      // bLength
 490         4,                                      // bDescriptorType
 491         MOUSE_INTERFACE,                        // bInterfaceNumber
 492         0,                                      // bAlternateSetting
 493         1,                                      // bNumEndpoints
 494         0x03,                                   // bInterfaceClass (0x03 = HID)
 495         0x00,                                   // bInterfaceSubClass (0x01 = Boot)
 496         0x00,                                   // bInterfaceProtocol (0x02 = Mouse)
 497         0,                                      // iInterface
 498 // - 9 bytes -
 499         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 500         9,                                      // bLength
 501         0x21,                                   // bDescriptorType
 502         0x11, 0x01,                             // bcdHID
 503         0,                                      // bCountryCode
 504         1,                                      // bNumDescriptors
 505         0x22,                                   // bDescriptorType
 506         LSB(sizeof(mouse_report_desc)),         // wDescriptorLength
 507         MSB(sizeof(mouse_report_desc)),
 508 // - 7 bytes -
 509         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 510         7,                                      // bLength
 511         5,                                      // bDescriptorType
 512         MOUSE_ENDPOINT | 0x80,                  // bEndpointAddress
 513         0x03,                                   // bmAttributes (0x03=intr)
 514         MOUSE_SIZE, 0,                          // wMaxPacketSize
 515         MOUSE_INTERVAL,                         // bInterval
 516 #endif // MOUSE_INTERFACE
 517 */
 518 };
 519
 520
 521
 522 // ----- String Descriptors -----
 523
 524 // The descriptors above can provide human readable strings,
 525 // referenced by index numbers.  These descriptors are the
 526 // actual string data
 527
 528 struct usb_string_descriptor_struct {
 529         uint8_t bLength;
 530         uint8_t bDescriptorType;
 531         uint16_t wString[];
 532 };
 533
 534 extern struct usb_string_descriptor_struct usb_string_manufacturer_name
 535         __attribute__ ((weak, alias("usb_string_manufacturer_name_default")));
 536 extern struct usb_string_descriptor_struct usb_string_product_name
 537         __attribute__ ((weak, alias("usb_string_product_name_default")));
 538 extern struct usb_string_descriptor_struct usb_string_serial_number
 539         __attribute__ ((weak, alias("usb_string_serial_number_default")));
 540
 541 struct usb_string_descriptor_struct string0 = {
 542         4,
 543         3,
 544         {0x0409}
 545 };
 546
 547 struct usb_string_descriptor_struct usb_string_manufacturer_name_default = {
 548         sizeof(STR_MANUFACTURER),
 549         3,
 550         STR_MANUFACTURER
 551 };
 552 struct usb_string_descriptor_struct usb_string_product_name_default = {
 553         sizeof(STR_PRODUCT),
 554         3,
 555         STR_PRODUCT
 556 };
 557 struct usb_string_descriptor_struct usb_string_serial_number_default = {
 558         sizeof(STR_SERIAL),
 559         3,
 560         STR_SERIAL
 561 };
 562
 563
 564
 565 // ----- Descriptors List -----
 566
 567 // This table provides access to all the descriptor data above.
 568
 569 const usb_descriptor_list_t usb_descriptor_list[] = {
 570         //wValue, wIndex, address,          length
 571         {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
 572         {0x0200, 0x0000, config_descriptor, sizeof(config_descriptor)},
 573         {0x0600, 0x0000, device_qualifier_descriptor, sizeof(device_qualifier_descriptor)},
 574         {0x0A00, 0x0000, usb_debug_descriptor, sizeof(usb_debug_descriptor)},
 575         {0x2200, KEYBOARD_INTERFACE, keyboard_report_desc, sizeof(keyboard_report_desc)},
 576         {0x2100, KEYBOARD_INTERFACE, config_descriptor + KEYBOARD_DESC_OFFSET, 9},
 577         {0x2200, NKRO_KEYBOARD_INTERFACE, nkro_keyboard_report_desc, sizeof(nkro_keyboard_report_desc)},
 578         {0x2100, NKRO_KEYBOARD_INTERFACE, config_descriptor + NKRO_KEYBOARD_DESC_OFFSET, 9},
 579 /* MOUSE
 580         {0x2200, MOUSE_INTERFACE, mouse_report_desc, sizeof(mouse_report_desc)},
 581         {0x2100, MOUSE_INTERFACE, config_descriptor+MOUSE_DESC_OFFSET, 9},
 582 */
 583         {0x0300, 0x0000, (const uint8_t *)&string0, 0},
 584         {0x0301, 0x0409, (const uint8_t *)&usb_string_manufacturer_name, 0},
 585         {0x0302, 0x0409, (const uint8_t *)&usb_string_product_name, 0},
 586         {0x0303, 0x0409, (const uint8_t *)&usb_string_serial_number, 0},
 587         {0, 0, NULL, 0}
 588 };
 589
 590
 591
 592 // ----- Endpoint Configuration -----
 593
 594 // See usb_desc.h for Endpoint configuration
 595 // 0x00 = not used
 596 // 0x19 = Recieve only
 597 // 0x15 = Transmit only
 598 // 0x1D = Transmit & Recieve
 599 //
 600 const uint8_t usb_endpoint_config_table[NUM_ENDPOINTS] =
 601 {
 602 #if (defined(ENDPOINT1_CONFIG) && NUM_ENDPOINTS >= 1)
 603         ENDPOINT1_CONFIG,
 604 #elif (NUM_ENDPOINTS >= 1)
 605         ENDPOINT_UNUSED,
 606 #endif
 607 #if (defined(ENDPOINT2_CONFIG) && NUM_ENDPOINTS >= 2)
 608         ENDPOINT2_CONFIG,
 609 #elif (NUM_ENDPOINTS >= 2)
 610         ENDPOINT_UNUSED,
 611 #endif
 612 #if (defined(ENDPOINT3_CONFIG) && NUM_ENDPOINTS >= 3)
 613         ENDPOINT3_CONFIG,
 614 #elif (NUM_ENDPOINTS >= 3)
 615         ENDPOINT_UNUSED,
 616 #endif
 617 #if (defined(ENDPOINT4_CONFIG) && NUM_ENDPOINTS >= 4)
 618         ENDPOINT4_CONFIG,
 619 #elif (NUM_ENDPOINTS >= 4)
 620         ENDPOINT_UNUSED,
 621 #endif
 622 #if (defined(ENDPOINT5_CONFIG) && NUM_ENDPOINTS >= 5)
 623         ENDPOINT5_CONFIG,
 624 #elif (NUM_ENDPOINTS >= 5)
 625         ENDPOINT_UNUSED,
 626 #endif
 627 #if (defined(ENDPOINT6_CONFIG) && NUM_ENDPOINTS >= 6)
 628         ENDPOINT6_CONFIG,
 629 #elif (NUM_ENDPOINTS >= 6)
 630         ENDPOINT_UNUSED,
 631 #endif
 632 #if (defined(ENDPOINT7_CONFIG) && NUM_ENDPOINTS >= 7)
 633         ENDPOINT7_CONFIG,
 634 #elif (NUM_ENDPOINTS >= 7)
 635         ENDPOINT_UNUSED,
 636 #endif
 637 #if (defined(ENDPOINT8_CONFIG) && NUM_ENDPOINTS >= 8)
 638         ENDPOINT8_CONFIG,
 639 #elif (NUM_ENDPOINTS >= 8)
 640         ENDPOINT_UNUSED,
 641 #endif
 642 #if (defined(ENDPOINT9_CONFIG) && NUM_ENDPOINTS >= 9)
 643         ENDPOINT9_CONFIG,
 644 #elif (NUM_ENDPOINTS >= 9)
 645         ENDPOINT_UNUSED,
 646 #endif
 647 #if (defined(ENDPOINT10_CONFIG) && NUM_ENDPOINTS >= 10)
 648         ENDPOINT10_CONFIG,
 649 #elif (NUM_ENDPOINTS >= 10)
 650         ENDPOINT_UNUSED,
 651 #endif
 652 #if (defined(ENDPOINT11_CONFIG) && NUM_ENDPOINTS >= 11)
 653         ENDPOINT11_CONFIG,
 654 #elif (NUM_ENDPOINTS >= 11)
 655         ENDPOINT_UNUSED,
 656 #endif
 657 #if (defined(ENDPOINT12_CONFIG) && NUM_ENDPOINTS >= 12)
 658         ENDPOINT12_CONFIG,
 659 #elif (NUM_ENDPOINTS >= 12)
 660         ENDPOINT_UNUSED,
 661 #endif
 662 #if (defined(ENDPOINT13_CONFIG) && NUM_ENDPOINTS >= 13)
 663         ENDPOINT13_CONFIG,
 664 #elif (NUM_ENDPOINTS >= 13)
 665         ENDPOINT_UNUSED,
 666 #endif
 667 #if (defined(ENDPOINT14_CONFIG) && NUM_ENDPOINTS >= 14)
 668         ENDPOINT14_CONFIG,
 669 #elif (NUM_ENDPOINTS >= 14)
 670         ENDPOINT_UNUSED,
 671 #endif
 672 #if (defined(ENDPOINT15_CONFIG) && NUM_ENDPOINTS >= 15)
 673         ENDPOINT15_CONFIG,
 674 #elif (NUM_ENDPOINTS >= 15)
 675         ENDPOINT_UNUSED,
 676 #endif
 677 };
 678
 679