Output/pjrcUSB/avr/usb_keyboard_serial.h

   1 /* USB Keyboard and CDC Serial Device for Teensy USB Development Board
   2  * Copyright (c) 2009 PJRC.COM, LLC
   3  * Modifications by Jacob Alexander (2011-2014)
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21  * THE SOFTWARE.
  22  */
  23
  24 #ifndef usb_keyboard_serial_h__
  25 #define usb_keyboard_serial_h__
  26
  27 // ----- Includes -----
  28
  29 // Compiler Includes
  30 #include <stdint.h>
  31
  32 // AVR Includes
  33 #include <avr/io.h>
  34 #include <avr/pgmspace.h>
  35 #include <avr/interrupt.h>
  36 #include <avr/wdt.h>
  37
  38 // AVR Util Includes
  39 #include <util/delay.h>
  40
  41 // Local Includes
  42 #include "output_com.h"
  43
  44
  45
  46 // ----- Function Declarations -----
  47
  48 // Basic USB Configuration
  49 uint8_t usb_init();                     // initialize everything
  50 uint8_t usb_configured();               // is the USB port configured
  51
  52 // Keyboard HID Functions
  53 void usb_keyboard_send();
  54
  55 // Chip Level Functions
  56 void usb_device_reload();               // Enable firmware reflash mode
  57
  58 // USB Serial CDC Functions
  59 int16_t usb_serial_getchar();   // receive a character (-1 if timeout/error)
  60 uint8_t usb_serial_available(); // number of bytes in receive buffer
  61 void usb_serial_flush_input();  // discard any buffered input
  62
  63 // transmitting data
  64 int8_t usb_serial_putchar(uint8_t c);        // transmit a character
  65 int8_t usb_serial_putchar_nowait(uint8_t c); // transmit a character, do not wait
  66 int8_t usb_serial_write(const char *buffer, uint16_t size); // transmit a buffer
  67 void usb_serial_flush_output();              // immediately transmit any buffered output
  68
  69 // serial parameters
  70 uint32_t usb_serial_get_baud();      // get the baud rate
  71 uint8_t usb_serial_get_stopbits();   // get the number of stop bits
  72 uint8_t usb_serial_get_paritytype(); // get the parity type
  73 uint8_t usb_serial_get_numbits();    // get the number of data bits
  74 uint8_t usb_serial_get_control();    // get the RTS and DTR signal state
  75 int8_t usb_serial_set_control(uint8_t signals); // set DSR, DCD, RI, etc
  76
  77
  78
  79 // ----- Macros -----
  80
  81 // Software reset the chip
  82 #define usb_device_software_reset() do { wdt_enable( WDTO_15MS ); for(;;); } while(0)
  83
  84 // See EPSIZE -> UECFG1X - 128 and 256 bytes are for endpoint 1 only
  85 #define EP_SIZE(s)      ((s) == 256 ? 0x50 : \
  86                         ((s) == 128 ? 0x40 : \
  87                         ((s) ==  64 ? 0x30 : \
  88                         ((s) ==  32 ? 0x20 : \
  89                         ((s) ==  16 ? 0x10 : \
  90                                       0x00)))))
  91
  92 #define LSB(n) (n & 255)
  93 #define MSB(n) ((n >> 8) & 255)
  94
  95
  96
  97 // ----- Defines -----
  98
  99 // constants corresponding to the various serial parameters
 100 #define USB_SERIAL_DTR                  0x01
 101 #define USB_SERIAL_RTS                  0x02
 102 #define USB_SERIAL_1_STOP               0
 103 #define USB_SERIAL_1_5_STOP             1
 104 #define USB_SERIAL_2_STOP               2
 105 #define USB_SERIAL_PARITY_NONE          0
 106 #define USB_SERIAL_PARITY_ODD           1
 107 #define USB_SERIAL_PARITY_EVEN          2
 108 #define USB_SERIAL_PARITY_MARK          3
 109 #define USB_SERIAL_PARITY_SPACE         4
 110 #define USB_SERIAL_DCD                  0x01
 111 #define USB_SERIAL_DSR                  0x02
 112 #define USB_SERIAL_BREAK                0x04
 113 #define USB_SERIAL_RI                   0x08
 114 #define USB_SERIAL_FRAME_ERR            0x10
 115 #define USB_SERIAL_PARITY_ERR           0x20
 116 #define USB_SERIAL_OVERRUN_ERR          0x40
 117
 118 #define EP_TYPE_CONTROL                 0x00
 119 #define EP_TYPE_BULK_IN                 0x81
 120 #define EP_TYPE_BULK_OUT                0x80
 121 #define EP_TYPE_INTERRUPT_IN            0xC1
 122 #define EP_TYPE_INTERRUPT_OUT           0xC0
 123 #define EP_TYPE_ISOCHRONOUS_IN          0x41
 124 #define EP_TYPE_ISOCHRONOUS_OUT         0x40
 125
 126 #define EP_SINGLE_BUFFER                0x02
 127 #define EP_DOUBLE_BUFFER                0x06
 128
 129 #define MAX_ENDPOINT            4
 130
 131 #if defined(__AVR_AT90USB162__)
 132 #define HW_CONFIG()
 133 #define PLL_CONFIG() (PLLCSR = ((1<<PLLE)|(1<<PLLP0)))
 134 #define USB_CONFIG() (USBCON = (1<<USBE))
 135 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 136
 137 #elif defined(__AVR_ATmega32U4__)
 138 #define HW_CONFIG() (UHWCON = 0x01)
 139 #define PLL_CONFIG() (PLLCSR = 0x12)
 140 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 141 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 142
 143 #elif defined(__AVR_AT90USB646__)
 144 #define HW_CONFIG() (UHWCON = 0x81)
 145 #define PLL_CONFIG() (PLLCSR = 0x1A)
 146 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 147 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 148
 149 #elif defined(__AVR_AT90USB1286__)
 150 #define HW_CONFIG() (UHWCON = 0x81)
 151 #define PLL_CONFIG() (PLLCSR = 0x16)
 152 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 153 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 154 #endif
 155
 156 // standard control endpoint request types
 157 #define GET_STATUS                      0
 158 #define CLEAR_FEATURE                   1
 159 #define SET_FEATURE                     3
 160 #define SET_ADDRESS                     5
 161 #define GET_DESCRIPTOR                  6
 162 #define GET_CONFIGURATION               8
 163 #define SET_CONFIGURATION               9
 164 #define GET_INTERFACE                   10
 165 #define SET_INTERFACE                   11
 166
 167 // HID (human interface device)
 168 #define HID_GET_REPORT                  1
 169 #define HID_GET_IDLE                    2
 170 #define HID_GET_PROTOCOL                3
 171 #define HID_SET_REPORT                  9
 172 #define HID_SET_IDLE                    10
 173 #define HID_SET_PROTOCOL                11
 174
 175 // CDC (communication class device)
 176 #define CDC_SET_LINE_CODING             0x20
 177 #define CDC_GET_LINE_CODING             0x21
 178 #define CDC_SET_CONTROL_LINE_STATE      0x22
 179
 180 // CDC Configuration
 181 // When you write data, it goes into a USB endpoint buffer, which
 182 // is transmitted to the PC when it becomes full, or after a timeout
 183 // with no more writes.  Even if you write in exactly packet-size
 184 // increments, this timeout is used to send a "zero length packet"
 185 // that tells the PC no more data is expected and it should pass
 186 // any buffered data to the application that may be waiting.  If
 187 // you want data sent immediately, call usb_serial_flush_output().
 188 #define TRANSMIT_FLUSH_TIMEOUT  5   /* in milliseconds */
 189
 190 // If the PC is connected but not "listening", this is the length
 191 // of time before usb_serial_getchar() returns with an error.  This
 192 // is roughly equivilant to a real UART simply transmitting the
 193 // bits on a wire where nobody is listening, except you get an error
 194 // code which you can ignore for serial-like discard of data, or
 195 // use to know your data wasn't sent.
 196 #define TRANSMIT_TIMEOUT        25   /* in milliseconds */
 197
 198
 199
 200 // ----- Endpoint Configuration -----
 201
 202 #define ENDPOINT0_SIZE           32
 203
 204 #define KEYBOARD_NKRO_INTERFACE  0
 205 #define KEYBOARD_NKRO_ENDPOINT   1
 206 #define KEYBOARD_NKRO_SIZE       64
 207 #define KEYBOARD_NKRO_HID_BUFFER EP_DOUBLE_BUFFER
 208
 209 #define KEYBOARD_INTERFACE       1
 210 #define KEYBOARD_ENDPOINT        2
 211 #define KEYBOARD_SIZE            8
 212 #define KEYBOARD_HID_BUFFER      EP_DOUBLE_BUFFER
 213
 214 #define CDC_IAD_DESCRIPTOR       1
 215 #define CDC_STATUS_INTERFACE     2
 216 #define CDC_DATA_INTERFACE       3
 217 #define CDC_ACM_ENDPOINT         3
 218 #define CDC_RX_ENDPOINT          4
 219 #define CDC_TX_ENDPOINT          5
 220 #if defined(__AVR_AT90USB162__)
 221 #define CDC_ACM_SIZE             16
 222 #define CDC_ACM_BUFFER           EP_SINGLE_BUFFER
 223 #define CDC_RX_SIZE              32
 224 #define CDC_RX_BUFFER            EP_DOUBLE_BUFFER
 225 #define CDC_TX_SIZE              32
 226 #define CDC_TX_BUFFER            EP_DOUBLE_BUFFER
 227 #else
 228 #define CDC_ACM_SIZE             16
 229 #define CDC_ACM_BUFFER           EP_SINGLE_BUFFER
 230 #define CDC_RX_SIZE              64
 231 #define CDC_RX_BUFFER            EP_DOUBLE_BUFFER
 232 #define CDC_TX_SIZE              64
 233 #define CDC_TX_BUFFER            EP_DOUBLE_BUFFER
 234 #endif
 235
 236 // Endpoint 0 is reserved for the control endpoint
 237 // Endpoint 1 has a 256 byte buffer
 238 // Endpoints 2-6 have 64 byte buffers
 239 static const uint8_t PROGMEM endpoint_config_table[] = {
 240         1, EP_TYPE_INTERRUPT_IN,  EP_SIZE(KEYBOARD_NKRO_SIZE) | KEYBOARD_NKRO_HID_BUFFER, // 256 byte
 241         1, EP_TYPE_INTERRUPT_IN,  EP_SIZE(KEYBOARD_SIZE)      | KEYBOARD_HID_BUFFER,      // 64 byte
 242         1, EP_TYPE_INTERRUPT_IN,  EP_SIZE(CDC_ACM_SIZE)       | CDC_ACM_BUFFER,           // 64 byte
 243         1, EP_TYPE_BULK_OUT,      EP_SIZE(CDC_RX_SIZE)        | CDC_RX_BUFFER,            // 64 byte
 244         1, EP_TYPE_BULK_IN,       EP_SIZE(CDC_TX_SIZE)        | CDC_TX_BUFFER,            // 64 byte
 245         0,                                                                                // 64 byte
 246 };
 247
 248
 249
 250 // ----- Descriptor Configuration -----
 251
 252 // Descriptors are the data that your computer reads when it auto-detects
 253 // this USB device (called "enumeration" in USB lingo).  The most commonly
 254 // changed items are editable at the top of this file.  Changing things
 255 // in here should only be done by those who've read chapter 9 of the USB
 256 // spec and relevant portions of any USB class specifications!
 257
 258
 259 static const uint8_t PROGMEM device_descriptor[] = {
 260         18,                                     // bLength
 261         1,                                      // bDescriptorType
 262         0x00, 0x02,                             // bcdUSB
 263         0x00,                                   // bDeviceClass - Composite device, 0x00 is required for Windows
 264         0,                                      // bDeviceSubClass
 265         0,                                      // bDeviceProtocol
 266         ENDPOINT0_SIZE,                         // bMaxPacketSize0
 267         LSB(VENDOR_ID), MSB(VENDOR_ID),         // idVendor
 268         LSB(PRODUCT_ID), MSB(PRODUCT_ID),       // idProduct
 269         0x00, 0x01,                             // bcdDevice
 270         1,                                      // iManufacturer
 271         2,                                      // iProduct
 272         3,                                      // iSerialNumber
 273         1                                       // bNumConfigurations
 274 };
 275
 276 // Specify only a single USB speed
 277 static const uint8_t PROGMEM device_qualifier_descriptor[] = {
 278         0
 279 };
 280
 281 // Disable USB debug descriptor
 282 static const uint8_t PROGMEM usb_debug_descriptor[] = {
 283         0
 284 };
 285
 286 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 287 static const uint8_t PROGMEM keyboard_hid_report_desc[] = {
 288         // Keyboard Collection
 289         0x05, 0x01,          // Usage Page (Generic Desktop),
 290         0x09, 0x06,          // Usage (Keyboard),
 291         0xA1, 0x01,          // Collection (Application) - Keyboard,
 292
 293         // Modifier Byte
 294         0x75, 0x01,          //   Report Size (1),
 295         0x95, 0x08,          //   Report Count (8),
 296         0x05, 0x07,          //   Usage Page (Key Codes),
 297         0x19, 0xE0,          //   Usage Minimum (224),
 298         0x29, 0xE7,          //   Usage Maximum (231),
 299         0x15, 0x00,          //   Logical Minimum (0),
 300         0x25, 0x01,          //   Logical Maximum (1),
 301         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 302
 303         // Reserved Byte
 304         0x75, 0x08,          //   Report Size (8),
 305         0x95, 0x01,          //   Report Count (1),
 306         0x81, 0x03,          //   Output (Constant),
 307
 308         // LED Report
 309         0x75, 0x01,          //   Report Size (1),
 310         0x95, 0x05,          //   Report Count (5),
 311         0x05, 0x08,          //   Usage Page (LEDs),
 312         0x19, 0x01,          //   Usage Minimum (1),
 313         0x29, 0x05,          //   Usage Maximum (5),
 314         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 315
 316         // LED Report Padding
 317         0x75, 0x03,          //   Report Size (3),
 318         0x95, 0x01,          //   Report Count (1),
 319         0x91, 0x03,          //   Output (Constant),
 320
 321         // Normal Keys
 322         0x75, 0x08,          //   Report Size (8),
 323         0x95, 0x06,          //   Report Count (6),
 324         0x15, 0x00,          //   Logical Minimum (0),
 325         0x25, 0x7F,          //   Logical Maximum(104),
 326         0x05, 0x07,          //   Usage Page (Key Codes),
 327         0x19, 0x00,          //   Usage Minimum (0),
 328         0x29, 0x7F,          //   Usage Maximum (104),
 329         0x81, 0x00,          //   Input (Data, Array),
 330         0xc0,                // End Collection - Keyboard
 331 };
 332
 333 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 334 static const uint8_t PROGMEM keyboard_nkro_hid_report_desc[] = {
 335         // Keyboard Collection
 336         0x05, 0x01,          // Usage Page (Generic Desktop),
 337         0x09, 0x06,          // Usage (Keyboard),
 338         0xA1, 0x01,          // Collection (Application) - Keyboard,
 339
 340         // LED Report
 341         0x85, 0x01,          //   Report ID (1),
 342         0x75, 0x01,          //   Report Size (1),
 343         0x95, 0x05,          //   Report Count (5),
 344         0x05, 0x08,          //   Usage Page (LEDs),
 345         0x19, 0x01,          //   Usage Minimum (1),
 346         0x29, 0x05,          //   Usage Maximum (5),
 347         0x91, 0x02,          //   Output (Data, Variable, Absolute),
 348
 349         // LED Report Padding
 350         0x75, 0x03,          //   Report Size (3),
 351         0x95, 0x01,          //   Report Count (1),
 352         0x91, 0x03,          //   Output (Constant),
 353
 354         // Normal Keys - Using an NKRO Bitmap
 355         //
 356         // NOTES:
 357         // Supports all keys defined by the spec, except 1-3 which define error events
 358         //  and 0 which is "no keys pressed"
 359         // See http://www.usb.org/developers/hidpage/Hut1_12v2.pdf Chapter 10
 360         // Or Macros/PartialMap/usb_hid.h
 361         //
 362         // 50 (ISO \ due to \ bug) and 156 (Clear due to Delete bug) must be excluded
 363         //  due to a Linux bug with bitmaps (not useful anyways)
 364         // 165-175 are reserved/unused as well as 222-223 and 232-65535
 365         //
 366         // Compatibility Notes:
 367         //  - Using a second endpoint for a boot mode device helps with compatibility
 368         //  - DO NOT use Padding in the descriptor for bitfields
 369         //    (Mac OSX silently fails... Windows/Linux work correctly)
 370         //  - DO NOT use Report IDs, Windows 8.1 will not update keyboard correctly (modifiers disappear)
 371         //    (all other OSs, including OSX work fine...)
 372         //    (you can use them *iff* you only have 1 per collection)
 373         //  - Mac OSX and Windows 8.1 are extremely picky about padding
 374         //
 375         // Packing of bitmaps are as follows:
 376         //   4-49  :  6 bytes (0x04-0x31) ( 46 bits + 2 padding bits for 6 bytes total)
 377         //  51-155 : 14 bytes (0x33-0x9B) (105 bits + 6 padding bits for 15 bytes total)
 378         // 157-164 :  1 byte  (0x9D-0xA4) (  8 bits)
 379         // 176-221 :  6 bytes (0xB0-0xDD) ( 46 bits + 2 padding bits for 6 bytes total)
 380         // 224-231 :  1 byte  (0xE0-0xE7) (  8 bits)
 381
 382         // Modifier Byte
 383         0x75, 0x01,          //   Report Size (1),
 384         0x95, 0x08,          //   Report Count (8),
 385         0x15, 0x00,          //   Logical Minimum (0),
 386         0x25, 0x01,          //   Logical Maximum (1),
 387         0x05, 0x07,          //   Usage Page (Key Codes),
 388         0x19, 0xE0,          //   Usage Minimum (224),
 389         0x29, 0xE7,          //   Usage Maximum (231),
 390         0x81, 0x02,          //   Input (Data, Variable, Absolute),
 391
 392         // 4-49 (6 bytes/46 bits) - MainKeys
 393         0x75, 0x01,          //   Report Size (1),
 394         0x95, 0x2E,          //   Report Count (46),
 395         0x15, 0x00,          //   Logical Minimum (0),
 396         0x25, 0x01,          //   Logical Maximum (1),
 397         0x05, 0x07,          //   Usage Page (Key Codes),
 398         0x19, 0x04,          //   Usage Minimum (4),
 399         0x29, 0x31,          //   Usage Maximum (49),
 400         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 401
 402         // Padding (2 bits)
 403         0x75, 0x02,          //   Report Size (2),
 404         0x95, 0x01,          //   Report Count (1),
 405         0x81, 0x03,          //   Input (Constant),
 406
 407         // 51-155 (14 bytes/105 bits) - SecondaryKeys
 408         0x75, 0x01,          //   Report Size (1),
 409         0x95, 0x69,          //   Report Count (105),
 410         0x15, 0x00,          //   Logical Minimum (0),
 411         0x25, 0x01,          //   Logical Maximum (1),
 412         0x05, 0x07,          //   Usage Page (Key Codes),
 413         0x19, 0x33,          //   Usage Minimum (51),
 414         0x29, 0x9B,          //   Usage Maximum (155),
 415         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 416
 417         // Padding (7 bits)
 418         0x75, 0x07,          //   Report Size (7),
 419         0x95, 0x01,          //   Report Count (1),
 420         0x81, 0x03,          //   Input (Constant),
 421
 422         // 157-164 (1 byte/8 bits) - TertiaryKeys
 423         0x75, 0x01,          //   Report Size (1),
 424         0x95, 0x08,          //   Report Count (8),
 425         0x15, 0x00,          //   Logical Minimum (0),
 426         0x25, 0x01,          //   Logical Maximum (1),
 427         0x05, 0x07,          //   Usage Page (Key Codes),
 428         0x19, 0x9D,          //   Usage Minimum (157),
 429         0x29, 0xA4,          //   Usage Maximum (164),
 430         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 431
 432         // 176-221 (6 bytes/46 bits) - QuartiaryKeys
 433         0x75, 0x01,          //   Report Size (1),
 434         0x95, 0x2E,          //   Report Count (46),
 435         0x15, 0x00,          //   Logical Minimum (0),
 436         0x25, 0x01,          //   Logical Maximum (1),
 437         0x05, 0x07,          //   Usage Page (Key Codes),
 438         0x19, 0xB0,          //   Usage Minimum (176),
 439         0x29, 0xDD,          //   Usage Maximum (221),
 440         0x81, 0x02,          //   Input (Data, Variable, Absolute, Bitfield),
 441
 442         // Padding (2 bits)
 443         0x75, 0x02,          //   Report Size (2),
 444         0x95, 0x01,          //   Report Count (1),
 445         0x81, 0x03,          //   Input (Constant),
 446         0xc0,                // End Collection - Keyboard
 447
 448         // System Control Collection
 449         //
 450         // NOTES:
 451         // Not bothering with NKRO for this table. If there's need, I can implement it. -HaaTa
 452         // Using a 1KRO scheme
 453         0x05, 0x01,          // Usage Page (Generic Desktop),
 454         0x09, 0x80,          // Usage (System Control),
 455         0xA1, 0x01,          // Collection (Application),
 456         0x85, 0x02,          //   Report ID (2),
 457         0x75, 0x08,          //   Report Size (8),
 458         0x95, 0x01,          //   Report Count (1),
 459         0x16, 0x81, 0x00,    //   Logical Minimum (129),
 460         0x26, 0xB7, 0x00,    //   Logical Maximum (183),
 461         0x19, 0x81,          //   Usage Minimum (129),
 462         0x29, 0xB7,          //   Usage Maximum (183),
 463         0x81, 0x00,          //   Input (Data, Array),
 464         0xc0,                // End Collection - System Control
 465
 466         // Consumer Control Collection - Media Keys
 467         //
 468         // NOTES:
 469         // Not bothering with NKRO for this table. If there's a need, I can implement it. -HaaTa
 470         // Using a 1KRO scheme
 471         0x05, 0x0c,          // Usage Page (Consumer),
 472         0x09, 0x01,          // Usage (Consumer Control),
 473         0xA1, 0x01,          // Collection (Application),
 474         0x85, 0x03,          //   Report ID (3),
 475         0x75, 0x10,          //   Report Size (16),
 476         0x95, 0x01,          //   Report Count (1),
 477         0x16, 0x20, 0x00,    //   Logical Minimum (32),
 478         0x26, 0x9C, 0x02,    //   Logical Maximum (668),
 479         0x05, 0x0C,          //   Usage Page (Consumer),
 480         0x19, 0x20,          //   Usage Minimum (32),
 481         0x2A, 0x9C, 0x02,    //   Usage Maximum (668),
 482         0x81, 0x00,          //   Input (Data, Array),
 483         0xc0,                // End Collection - Consumer Control
 484 };
 485
 486 // <Configuration> + <Keyboard HID> + <NKRO Keyboard HID> + <Serial CDC>
 487 #define CONFIG1_DESC_SIZE             (9 + 9+9+7 + 9+9+7 + 8+9+5+5+4+5+7+9+7+7)
 488 #define KEYBOARD_HID_DESC_OFFSET      (9 + 9)
 489 #define KEYBOARD_NKRO_HID_DESC_OFFSET (9 + 9+9+7 + 9)
 490 #define SERIAL_CDC_DESC_OFFSET        (9 + 9+9+7 + 9+9+7)
 491 static const uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = {
 492 // --- Configuration ---
 493 // - 9 bytes -
 494         // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
 495         9,                                      // bLength;
 496         2,                                      // bDescriptorType;
 497         LSB(CONFIG1_DESC_SIZE),                 // wTotalLength
 498         MSB(CONFIG1_DESC_SIZE),
 499         4,                                      // bNumInterfaces
 500         1,                                      // bConfigurationValue
 501         0,                                      // iConfiguration
 502         0x80,                                   // bmAttributes
 503         250,                                    // bMaxPower
 504
 505 // --- Keyboard HID ---
 506 // - 9 bytes -
 507         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 508         9,                                      // bLength
 509         4,                                      // bDescriptorType
 510         KEYBOARD_INTERFACE,                     // bInterfaceNumber
 511         0,                                      // bAlternateSetting
 512         1,                                      // bNumEndpoints
 513         0x03,                                   // bInterfaceClass (0x03 = HID)
 514         0x01,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 515         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 516         0,                                      // iInterface
 517 // - 9 bytes -
 518         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 519         9,                                      // bLength
 520         0x21,                                   // bDescriptorType
 521         0x11, 0x01,                             // bcdHID
 522         0,                                      // bCountryCode - Setting to 0/Undefined
 523         1,                                      // bNumDescriptors
 524         0x22,                                   // bDescriptorType
 525         LSB(sizeof(keyboard_hid_report_desc)),  // wDescriptorLength
 526         MSB(sizeof(keyboard_hid_report_desc)),
 527 // - 7 bytes -
 528         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 529         7,                                      // bLength
 530         5,                                      // bDescriptorType
 531         KEYBOARD_ENDPOINT | 0x80,               // bEndpointAddress
 532         0x03,                                   // bmAttributes (0x03=intr)
 533         KEYBOARD_SIZE, 0,                       // wMaxPacketSize
 534         1,                                      // bInterval
 535
 536 // --- NKRO Keyboard HID ---
 537 // - 9 bytes -
 538         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 539         9,                                      // bLength
 540         4,                                      // bDescriptorType
 541         KEYBOARD_NKRO_INTERFACE,                // bInterfaceNumber
 542         0,                                      // bAlternateSetting
 543         1,                                      // bNumEndpoints
 544         0x03,                                   // bInterfaceClass (0x03 = HID)
 545         0x00,                                   // bInterfaceSubClass (0x00 = Non-Boot, 0x01 = Boot)
 546         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)
 547         0,                                      // iInterface
 548 // - 9 bytes -
 549         // HID interface descriptor, HID 1.11 spec, section 6.2.1
 550         9,                                      // bLength
 551         0x21,                                   // bDescriptorType
 552         0x11, 0x01,                             // bcdHID
 553         0,                                      // bCountryCode - Setting to 0/Undefined
 554         1,                                      // bNumDescriptors
 555         0x22,                                   // bDescriptorType
 556                                                 // wDescriptorLength
 557         LSB(sizeof(keyboard_nkro_hid_report_desc)),
 558         MSB(sizeof(keyboard_nkro_hid_report_desc)),
 559 // - 7 bytes -
 560         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 561         7,                                      // bLength
 562         5,                                      // bDescriptorType
 563         KEYBOARD_NKRO_ENDPOINT | 0x80,          // bEndpointAddress
 564         0x03,                                   // bmAttributes (0x03=intr)
 565         KEYBOARD_NKRO_SIZE, 0,                  // wMaxPacketSize
 566         1,                                      // bInterval
 567
 568 // --- Serial CDC ---
 569 // - 8 bytes -
 570         // interface association descriptor, USB ECN, Table 9-Z
 571         8,                                      // bLength
 572         11,                                     // bDescriptorType
 573         CDC_STATUS_INTERFACE,                   // bFirstInterface
 574         2,                                      // bInterfaceCount
 575         0x02,                                   // bFunctionClass
 576         0x02,                                   // bFunctionSubClass
 577         0x01,                                   // bFunctionProtocol
 578         4,                                      // iFunction
 579 // - 9 bytes -
 580         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 581         9,                                      // bLength
 582         4,                                      // bDescriptorType
 583         CDC_STATUS_INTERFACE,                   // bInterfaceNumber
 584         0,                                      // bAlternateSetting
 585         1,                                      // bNumEndpoints
 586         0x02,                                   // bInterfaceClass
 587         0x02,                                   // bInterfaceSubClass
 588         0x01,                                   // bInterfaceProtocol
 589         0,                                      // iInterface
 590 // - 5 bytes -
 591         // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26
 592         5,                                      // bFunctionLength
 593         0x24,                                   // bDescriptorType
 594         0x00,                                   // bDescriptorSubtype
 595         0x10, 0x01,                             // bcdCDC
 596 // - 5 bytes -
 597         // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27
 598         5,                                      // bFunctionLength
 599         0x24,                                   // bDescriptorType
 600         0x01,                                   // bDescriptorSubtype
 601         0x01,                                   // bmCapabilities
 602         1,                                      // bDataInterface
 603 // - 4 bytes -
 604         // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28
 605         4,                                      // bFunctionLength
 606         0x24,                                   // bDescriptorType
 607         0x02,                                   // bDescriptorSubtype
 608         0x06,                                   // bmCapabilities
 609 // - 5 bytes -
 610         // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33
 611         5,                                      // bFunctionLength
 612         0x24,                                   // bDescriptorType
 613         0x06,                                   // bDescriptorSubtype
 614         CDC_STATUS_INTERFACE,                   // bMasterInterface
 615         CDC_DATA_INTERFACE,                     // bSlaveInterface0
 616 // - 7 bytes -
 617         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 618         7,                                      // bLength
 619         5,                                      // bDescriptorType
 620         CDC_ACM_ENDPOINT | 0x80,                // bEndpointAddress
 621         0x03,                                   // bmAttributes (0x03=intr)
 622         CDC_ACM_SIZE, 0,                        // wMaxPacketSize
 623         64,                                     // bInterval
 624 // - 9 bytes -
 625         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 626         9,                                      // bLength
 627         4,                                      // bDescriptorType
 628         CDC_DATA_INTERFACE,                     // bInterfaceNumber
 629         0,                                      // bAlternateSetting
 630         2,                                      // bNumEndpoints
 631         0x0A,                                   // bInterfaceClass
 632         0x00,                                   // bInterfaceSubClass
 633         0x00,                                   // bInterfaceProtocol
 634         0,                                      // iInterface
 635 // - 7 bytes -
 636         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 637         7,                                      // bLength
 638         5,                                      // bDescriptorType
 639         CDC_RX_ENDPOINT,                        // bEndpointAddress
 640         0x02,                                   // bmAttributes (0x02=bulk)
 641         CDC_RX_SIZE, 0,                         // wMaxPacketSize
 642         0,                                      // bInterval
 643 // - 7 bytes -
 644         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 645         7,                                      // bLength
 646         5,                                      // bDescriptorType
 647         CDC_TX_ENDPOINT | 0x80,                 // bEndpointAddress
 648         0x02,                                   // bmAttributes (0x02=bulk)
 649         CDC_TX_SIZE, 0,                         // wMaxPacketSize
 650         0,                                      // bInterval
 651 };
 652
 653
 654 // Configuration Endpoint (0) Descriptor
 655 struct usb_string_descriptor_struct {
 656         uint8_t bLength;
 657         uint8_t bDescriptorType;
 658         int16_t wString[];
 659 };
 660 static const struct usb_string_descriptor_struct PROGMEM string0 = {
 661         4,
 662         3,
 663         {0x0409}
 664 };
 665 static const struct usb_string_descriptor_struct PROGMEM string1 = {
 666         sizeof(STR_MANUFACTURER),
 667         3,
 668         STR_MANUFACTURER
 669 };
 670 static const struct usb_string_descriptor_struct PROGMEM string2 = {
 671         sizeof(STR_PRODUCT),
 672         3,
 673         STR_PRODUCT
 674 };
 675 static const struct usb_string_descriptor_struct PROGMEM string3 = {
 676         sizeof(STR_SERIAL),
 677         3,
 678         STR_SERIAL
 679 };
 680
 681 // This table defines which descriptor data is sent for each specific
 682 // request from the host (in wValue and wIndex).
 683 static const struct descriptor_list_struct {
 684         uint16_t        wValue;
 685         uint16_t        wIndex;
 686         const uint8_t   *addr;
 687         uint8_t         length;
 688 } PROGMEM descriptor_list[] = {
 689         {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
 690         {0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)},
 691         {0x0600, 0x0000, device_qualifier_descriptor, sizeof(device_qualifier_descriptor)},
 692         {0x0A00, 0x0000, usb_debug_descriptor, sizeof(usb_debug_descriptor)},
 693         {0x2200, KEYBOARD_INTERFACE, keyboard_hid_report_desc, sizeof(keyboard_hid_report_desc)},
 694         {0x2100, KEYBOARD_INTERFACE, config1_descriptor + KEYBOARD_HID_DESC_OFFSET, 9},
 695         {0x2200, KEYBOARD_NKRO_INTERFACE, keyboard_nkro_hid_report_desc, sizeof(keyboard_nkro_hid_report_desc)},
 696         {0x2100, KEYBOARD_NKRO_INTERFACE, config1_descriptor + KEYBOARD_NKRO_HID_DESC_OFFSET, 9},
 697         {0x0300, 0x0000, (const uint8_t *)&string0, 4},
 698         {0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)},
 699         {0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_PRODUCT)},
 700         {0x0303, 0x0409, (const uint8_t *)&string3, sizeof(STR_SERIAL)}
 701 };
 702 #define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct))
 703
 704
 705
 706 #endif // usb_keyboard_serial_h__
 707