protocol/lufa/descriptor.c

   1 /*
   2  * Copyright 2012 Jun Wako <wakojun@gmail.com>
   3  * This file is based on:
   4  *     LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse
   5  *     LUFA-120219/Demos/Device/Lowlevel/GenericHID
   6  */
   7
   8 /*
   9              LUFA Library
  10      Copyright (C) Dean Camera, 2012.
  11
  12   dean [at] fourwalledcubicle [dot] com
  13            www.lufa-lib.org
  14 */
  15
  16 /*
  17   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  18   Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
  19
  20   Permission to use, copy, modify, distribute, and sell this
  21   software and its documentation for any purpose is hereby granted
  22   without fee, provided that the above copyright notice appear in
  23   all copies and that both that the copyright notice and this
  24   permission notice and warranty disclaimer appear in supporting
  25   documentation, and that the name of the author not be used in
  26   advertising or publicity pertaining to distribution of the
  27   software without specific, written prior permission.
  28
  29   The author disclaim all warranties with regard to this
  30   software, including all implied warranties of merchantability
  31   and fitness.  In no event shall the author be liable for any
  32   special, indirect or consequential damages or any damages
  33   whatsoever resulting from loss of use, data or profits, whether
  34   in an action of contract, negligence or other tortious action,
  35   arising out of or in connection with the use or performance of
  36   this software.
  37 */
  38
  39 #include "util.h"
  40 #include "report.h"
  41 #include "descriptor.h"
  42
  43
  44 /*******************************************************************************
  45  * HID Report Descriptors
  46  ******************************************************************************/
  47 const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
  48 {
  49     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
  50     HID_RI_USAGE(8, 0x06), /* Keyboard */
  51     HID_RI_COLLECTION(8, 0x01), /* Application */
  52         HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
  53         HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
  54         HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
  55         HID_RI_LOGICAL_MINIMUM(8, 0x00),
  56         HID_RI_LOGICAL_MAXIMUM(8, 0x01),
  57         HID_RI_REPORT_COUNT(8, 0x08),
  58         HID_RI_REPORT_SIZE(8, 0x01),
  59         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
  60         HID_RI_REPORT_COUNT(8, 0x01),
  61         HID_RI_REPORT_SIZE(8, 0x08),
  62         HID_RI_INPUT(8, HID_IOF_CONSTANT),
  63         HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
  64         HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
  65         HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
  66         HID_RI_REPORT_COUNT(8, 0x05),
  67         HID_RI_REPORT_SIZE(8, 0x01),
  68         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
  69         HID_RI_REPORT_COUNT(8, 0x01),
  70         HID_RI_REPORT_SIZE(8, 0x03),
  71         HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
  72         HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
  73         HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
  74         HID_RI_USAGE_MAXIMUM(8, 0xFF), /* Keyboard Application */
  75         HID_RI_LOGICAL_MINIMUM(8, 0x00),
  76         HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
  77         HID_RI_REPORT_COUNT(8, 0x06),
  78         HID_RI_REPORT_SIZE(8, 0x08),
  79         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
  80     HID_RI_END_COLLECTION(0),
  81 };
  82
  83 const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
  84 {
  85     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
  86     HID_RI_USAGE(8, 0x02), /* Mouse */
  87     HID_RI_COLLECTION(8, 0x01), /* Application */
  88         HID_RI_USAGE(8, 0x01), /* Pointer */
  89         HID_RI_COLLECTION(8, 0x00), /* Physical */
  90
  91             HID_RI_USAGE_PAGE(8, 0x09), /* Button */
  92             HID_RI_USAGE_MINIMUM(8, 0x01),  /* Button 1 */
  93             HID_RI_USAGE_MAXIMUM(8, 0x05),  /* Button 5 */
  94             HID_RI_LOGICAL_MINIMUM(8, 0x00),
  95             HID_RI_LOGICAL_MAXIMUM(8, 0x01),
  96             HID_RI_REPORT_COUNT(8, 0x05),
  97             HID_RI_REPORT_SIZE(8, 0x01),
  98             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
  99             HID_RI_REPORT_COUNT(8, 0x01),
 100             HID_RI_REPORT_SIZE(8, 0x03),
 101             HID_RI_INPUT(8, HID_IOF_CONSTANT),
 102
 103             HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 104             HID_RI_USAGE(8, 0x30), /* Usage X */
 105             HID_RI_USAGE(8, 0x31), /* Usage Y */
 106             HID_RI_LOGICAL_MINIMUM(8, -127),
 107             HID_RI_LOGICAL_MAXIMUM(8, 127),
 108             HID_RI_REPORT_COUNT(8, 0x02),
 109             HID_RI_REPORT_SIZE(8, 0x08),
 110             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 111
 112             HID_RI_USAGE(8, 0x38), /* Wheel */
 113             HID_RI_LOGICAL_MINIMUM(8, -127),
 114             HID_RI_LOGICAL_MAXIMUM(8, 127),
 115             HID_RI_REPORT_COUNT(8, 0x01),
 116             HID_RI_REPORT_SIZE(8, 0x08),
 117             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 118
 119             HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 120             HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
 121             HID_RI_LOGICAL_MINIMUM(8, -127),
 122             HID_RI_LOGICAL_MAXIMUM(8, 127),
 123             HID_RI_REPORT_COUNT(8, 0x01),
 124             HID_RI_REPORT_SIZE(8, 0x08),
 125             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 126
 127         HID_RI_END_COLLECTION(0),
 128     HID_RI_END_COLLECTION(0),
 129 };
 130
 131 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
 132 {
 133     HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
 134     HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
 135     HID_RI_COLLECTION(8, 0x01), /* Application */
 136         HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
 137         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 138         HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 139         HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 140         HID_RI_REPORT_SIZE(8, 0x08),
 141         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 142         HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
 143         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 144         HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 145         HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 146         HID_RI_REPORT_SIZE(8, 0x08),
 147         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
 148     HID_RI_END_COLLECTION(0),
 149 };
 150
 151 #ifdef EXTRAKEY_ENABLE
 152 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtraReport[] =
 153 {
 154     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 155     HID_RI_USAGE(8, 0x80), /* System Control */
 156     HID_RI_COLLECTION(8, 0x01), /* Application */
 157         HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
 158         HID_RI_LOGICAL_MINIMUM(16, 0x0081),
 159         HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
 160         HID_RI_USAGE_MINIMUM(16, 0x0081), /* System Power Down */
 161         HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
 162         HID_RI_REPORT_SIZE(8, 16),
 163         HID_RI_REPORT_COUNT(8, 1),
 164         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 165     HID_RI_END_COLLECTION(0),
 166
 167     HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 168     HID_RI_USAGE(8, 0x01), /* Consumer Control */
 169     HID_RI_COLLECTION(8, 0x01), /* Application */
 170         HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
 171         HID_RI_LOGICAL_MINIMUM(16, 0x0010),
 172         HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
 173         HID_RI_USAGE_MINIMUM(16, 0x0010), /* +10 */
 174         HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
 175         HID_RI_REPORT_SIZE(8, 16),
 176         HID_RI_REPORT_COUNT(8, 1),
 177         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 178     HID_RI_END_COLLECTION(0),
 179 };
 180 #endif
 181
 182 #ifdef NKRO_ENABLE
 183 const USB_Descriptor_HIDReport_Datatype_t PROGMEM NKROReport[] =
 184 {
 185     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 186     HID_RI_USAGE(8, 0x06), /* Keyboard */
 187     HID_RI_COLLECTION(8, 0x01), /* Application */
 188         HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
 189         HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
 190         HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
 191         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 192         HID_RI_LOGICAL_MAXIMUM(8, 0x01),
 193         HID_RI_REPORT_COUNT(8, 0x08),
 194         HID_RI_REPORT_SIZE(8, 0x01),
 195         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 196
 197         HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
 198         HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
 199         HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
 200         HID_RI_REPORT_COUNT(8, 0x05),
 201         HID_RI_REPORT_SIZE(8, 0x01),
 202         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
 203         HID_RI_REPORT_COUNT(8, 0x01),
 204         HID_RI_REPORT_SIZE(8, 0x03),
 205         HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
 206
 207         HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
 208         HID_RI_USAGE_MINIMUM(8, 0x00), /* Keyboard 0 */
 209         HID_RI_USAGE_MAXIMUM(8, NKRO_SIZE*8-1), /* Keyboard Right GUI */
 210         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 211         HID_RI_LOGICAL_MAXIMUM(8, 0x01),
 212         HID_RI_REPORT_COUNT(8, NKRO_SIZE*8),
 213         HID_RI_REPORT_SIZE(8, 0x01),
 214 };
 215 #endif
 216
 217 /*******************************************************************************
 218  * Device Descriptors
 219  ******************************************************************************/
 220 const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
 221 {
 222     .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
 223
 224     .USBSpecification       = VERSION_BCD(01.10),
 225     .Class                  = USB_CSCP_NoDeviceClass,
 226     .SubClass               = USB_CSCP_NoDeviceSubclass,
 227     .Protocol               = USB_CSCP_NoDeviceProtocol,
 228
 229     .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
 230
 231     .VendorID               = VENDOR_ID,
 232     .ProductID              = PRODUCT_ID,
 233     .ReleaseNumber          = DEVICE_VER,
 234
 235     .ManufacturerStrIndex   = 0x01,
 236     .ProductStrIndex        = 0x02,
 237     .SerialNumStrIndex      = NO_DESCRIPTOR,
 238
 239     .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
 240 };
 241
 242 /*******************************************************************************
 243  * Configuration Descriptors
 244  ******************************************************************************/
 245 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
 246 {
 247     .Config =
 248         {
 249             .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
 250
 251             .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
 252             .TotalInterfaces        = TOTAL_INTERFACES,
 253
 254             .ConfigurationNumber    = 1,
 255             .ConfigurationStrIndex  = NO_DESCRIPTOR,
 256
 257             .ConfigAttributes       = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
 258
 259             .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
 260         },
 261
 262     /*
 263      * Keyboard
 264      */
 265     .Keyboard_Interface =
 266         {
 267             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 268
 269             .InterfaceNumber        = KEYBOARD_INTERFACE,
 270             .AlternateSetting       = 0x00,
 271
 272             .TotalEndpoints         = 1,
 273
 274             .Class                  = HID_CSCP_HIDClass,
 275             .SubClass               = HID_CSCP_BootSubclass,
 276             .Protocol               = HID_CSCP_KeyboardBootProtocol,
 277
 278             .InterfaceStrIndex      = NO_DESCRIPTOR
 279         },
 280
 281     .Keyboard_HID =
 282         {
 283             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 284
 285             .HIDSpec                = VERSION_BCD(01.11),
 286             .CountryCode            = 0x00,
 287             .TotalReportDescriptors = 1,
 288             .HIDReportType          = HID_DTYPE_Report,
 289             .HIDReportLength        = sizeof(KeyboardReport)
 290         },
 291
 292     .Keyboard_INEndpoint =
 293         {
 294             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 295
 296             .EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
 297             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 298             .EndpointSize           = KEYBOARD_EPSIZE,
 299             .PollingIntervalMS      = 0x01
 300         },
 301
 302     /*
 303      * Mouse
 304      */
 305 #ifdef MOUSE_ENABLE
 306     .Mouse_Interface =
 307         {
 308             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 309
 310             .InterfaceNumber        = MOUSE_INTERFACE,
 311             .AlternateSetting       = 0x00,
 312
 313             .TotalEndpoints         = 1,
 314
 315             .Class                  = HID_CSCP_HIDClass,
 316             .SubClass               = HID_CSCP_BootSubclass,
 317             .Protocol               = HID_CSCP_MouseBootProtocol,
 318
 319             .InterfaceStrIndex      = NO_DESCRIPTOR
 320         },
 321
 322     .Mouse_HID =
 323         {
 324             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 325
 326             .HIDSpec                = VERSION_BCD(01.11),
 327             .CountryCode            = 0x00,
 328             .TotalReportDescriptors = 1,
 329             .HIDReportType          = HID_DTYPE_Report,
 330             .HIDReportLength        = sizeof(MouseReport)
 331         },
 332
 333     .Mouse_INEndpoint =
 334         {
 335             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 336
 337             .EndpointAddress        = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
 338             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 339             .EndpointSize           = MOUSE_EPSIZE,
 340             .PollingIntervalMS      = 0x01
 341         },
 342 #endif
 343
 344     /*
 345      * Console
 346      */
 347     .Console_Interface =
 348         {
 349             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 350
 351             .InterfaceNumber        = CONSOLE_INTERFACE,
 352             .AlternateSetting       = 0x00,
 353
 354             .TotalEndpoints         = 2,
 355
 356             .Class                  = HID_CSCP_HIDClass,
 357             .SubClass               = HID_CSCP_NonBootSubclass,
 358             .Protocol               = HID_CSCP_NonBootProtocol,
 359
 360             .InterfaceStrIndex      = NO_DESCRIPTOR
 361         },
 362
 363     .Console_HID =
 364         {
 365             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 366
 367             .HIDSpec                = VERSION_BCD(01.11),
 368             .CountryCode            = 0x00,
 369             .TotalReportDescriptors = 1,
 370             .HIDReportType          = HID_DTYPE_Report,
 371             .HIDReportLength        = sizeof(ConsoleReport)
 372         },
 373
 374     .Console_INEndpoint =
 375         {
 376             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 377
 378             .EndpointAddress        = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
 379             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 380             .EndpointSize           = CONSOLE_EPSIZE,
 381             .PollingIntervalMS      = 0x01
 382         },
 383
 384     .Console_OUTEndpoint =
 385         {
 386             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 387
 388             .EndpointAddress        = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
 389             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 390             .EndpointSize           = CONSOLE_EPSIZE,
 391             .PollingIntervalMS      = 0x01
 392         },
 393
 394     /*
 395      * Extra
 396      */
 397 #ifdef EXTRAKEY_ENABLE
 398     .Extra_Interface =
 399         {
 400             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 401
 402             .InterfaceNumber        = EXTRA_INTERFACE,
 403             .AlternateSetting       = 0x00,
 404
 405             .TotalEndpoints         = 1,
 406
 407             .Class                  = HID_CSCP_HIDClass,
 408             .SubClass               = HID_CSCP_NonBootSubclass,
 409             .Protocol               = HID_CSCP_NonBootProtocol,
 410
 411             .InterfaceStrIndex      = NO_DESCRIPTOR
 412         },
 413
 414     .Extra_HID =
 415         {
 416             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 417
 418             .HIDSpec                = VERSION_BCD(01.11),
 419             .CountryCode            = 0x00,
 420             .TotalReportDescriptors = 1,
 421             .HIDReportType          = HID_DTYPE_Report,
 422             .HIDReportLength        = sizeof(ExtraReport)
 423         },
 424
 425     .Extra_INEndpoint =
 426         {
 427             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 428
 429             .EndpointAddress        = (ENDPOINT_DIR_IN | EXTRA_IN_EPNUM),
 430             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 431             .EndpointSize           = EXTRA_EPSIZE,
 432             .PollingIntervalMS      = 0x01
 433         },
 434 #endif
 435 };
 436
 437
 438 /*******************************************************************************
 439  * String Descriptors
 440  ******************************************************************************/
 441 const USB_Descriptor_String_t PROGMEM LanguageString =
 442 {
 443     .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
 444
 445     .UnicodeString          = {LANGUAGE_ID_ENG}
 446 };
 447
 448 const USB_Descriptor_String_t PROGMEM ManufacturerString =
 449 {
 450     .Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
 451
 452     .UnicodeString          = LSTR(MANUFACTURER)
 453 };
 454
 455 const USB_Descriptor_String_t PROGMEM ProductString =
 456 {
 457     .Header                 = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String},
 458
 459     .UnicodeString          = LSTR(PRODUCT)
 460 };
 461
 462
 463 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
 464  *  documentation) by the application code so that the address and size of a requested descriptor can be given
 465  *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
 466  *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
 467  *  USB host.
 468  */
 469 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
 470                                     const uint8_t wIndex,
 471                                     const void** const DescriptorAddress)
 472 {
 473     const uint8_t  DescriptorType   = (wValue >> 8);
 474     const uint8_t  DescriptorIndex  = (wValue & 0xFF);
 475
 476     const void* Address = NULL;
 477     uint16_t    Size    = NO_DESCRIPTOR;
 478
 479     switch (DescriptorType)
 480     {
 481         case DTYPE_Device:
 482             Address = &DeviceDescriptor;
 483             Size    = sizeof(USB_Descriptor_Device_t);
 484             break;
 485         case DTYPE_Configuration:
 486             Address = &ConfigurationDescriptor;
 487             Size    = sizeof(USB_Descriptor_Configuration_t);
 488             break;
 489         case DTYPE_String:
 490             switch (DescriptorIndex )
 491             {
 492                 case 0x00:
 493                     Address = &LanguageString;
 494                     Size    = pgm_read_byte(&LanguageString.Header.Size);
 495                     break;
 496                 case 0x01:
 497                     Address = &ManufacturerString;
 498                     Size    = pgm_read_byte(&ManufacturerString.Header.Size);
 499                     break;
 500                 case 0x02:
 501                     Address = &ProductString;
 502                     Size    = pgm_read_byte(&ProductString.Header.Size);
 503                     break;
 504             }
 505             break;
 506         case HID_DTYPE_HID:
 507             switch (wIndex) {
 508             case KEYBOARD_INTERFACE:
 509                 Address = &ConfigurationDescriptor.Keyboard_HID;
 510                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 511                 break;
 512 #ifdef MOUSE_ENABLE
 513             case MOUSE_INTERFACE:
 514                 Address = &ConfigurationDescriptor.Mouse_HID;
 515                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 516                 break;
 517 #endif
 518             case CONSOLE_INTERFACE:
 519                 Address = &ConfigurationDescriptor.Console_HID;
 520                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 521                 break;
 522 #ifdef EXTRAKEY_ENABLE
 523             case EXTRA_INTERFACE:
 524                 Address = &ConfigurationDescriptor.Extra_HID;
 525                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 526                 break;
 527 #endif
 528             }
 529             break;
 530         case HID_DTYPE_Report:
 531             switch (wIndex) {
 532             case KEYBOARD_INTERFACE:
 533                 Address = &KeyboardReport;
 534                 Size    = sizeof(KeyboardReport);
 535                 break;
 536 #ifdef MOUSE_ENABLE
 537             case MOUSE_INTERFACE:
 538                 Address = &MouseReport;
 539                 Size    = sizeof(MouseReport);
 540                 break;
 541 #endif
 542             case CONSOLE_INTERFACE:
 543                 Address = &ConsoleReport;
 544                 Size    = sizeof(ConsoleReport);
 545                 break;
 546 #ifdef EXTRAKEY_ENABLE
 547             case EXTRA_INTERFACE:
 548                 Address = &ExtraReport;
 549                 Size    = sizeof(ExtraReport);
 550                 break;
 551 #endif
 552             }
 553             break;
 554     }
 555
 556     *DescriptorAddress = Address;
 557     return Size;
 558 }