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 #ifdef MOUSE_ENABLE
  84 const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
  85 {
  86     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
  87     HID_RI_USAGE(8, 0x02), /* Mouse */
  88     HID_RI_COLLECTION(8, 0x01), /* Application */
  89         HID_RI_USAGE(8, 0x01), /* Pointer */
  90         HID_RI_COLLECTION(8, 0x00), /* Physical */
  91
  92             HID_RI_USAGE_PAGE(8, 0x09), /* Button */
  93             HID_RI_USAGE_MINIMUM(8, 0x01),  /* Button 1 */
  94             HID_RI_USAGE_MAXIMUM(8, 0x05),  /* Button 5 */
  95             HID_RI_LOGICAL_MINIMUM(8, 0x00),
  96             HID_RI_LOGICAL_MAXIMUM(8, 0x01),
  97             HID_RI_REPORT_COUNT(8, 0x05),
  98             HID_RI_REPORT_SIZE(8, 0x01),
  99             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 100             HID_RI_REPORT_COUNT(8, 0x01),
 101             HID_RI_REPORT_SIZE(8, 0x03),
 102             HID_RI_INPUT(8, HID_IOF_CONSTANT),
 103
 104             HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 105             HID_RI_USAGE(8, 0x30), /* Usage X */
 106             HID_RI_USAGE(8, 0x31), /* Usage Y */
 107             HID_RI_LOGICAL_MINIMUM(8, -127),
 108             HID_RI_LOGICAL_MAXIMUM(8, 127),
 109             HID_RI_REPORT_COUNT(8, 0x02),
 110             HID_RI_REPORT_SIZE(8, 0x08),
 111             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 112
 113             HID_RI_USAGE(8, 0x38), /* Wheel */
 114             HID_RI_LOGICAL_MINIMUM(8, -127),
 115             HID_RI_LOGICAL_MAXIMUM(8, 127),
 116             HID_RI_REPORT_COUNT(8, 0x01),
 117             HID_RI_REPORT_SIZE(8, 0x08),
 118             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 119
 120             HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 121             HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
 122             HID_RI_LOGICAL_MINIMUM(8, -127),
 123             HID_RI_LOGICAL_MAXIMUM(8, 127),
 124             HID_RI_REPORT_COUNT(8, 0x01),
 125             HID_RI_REPORT_SIZE(8, 0x08),
 126             HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 127
 128         HID_RI_END_COLLECTION(0),
 129     HID_RI_END_COLLECTION(0),
 130 };
 131 #endif
 132
 133 #ifdef EXTRAKEY_ENABLE
 134 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtrakeyReport[] =
 135 {
 136     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 137     HID_RI_USAGE(8, 0x80), /* System Control */
 138     HID_RI_COLLECTION(8, 0x01), /* Application */
 139         HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
 140         HID_RI_LOGICAL_MINIMUM(16, 0x0001),
 141         HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
 142         HID_RI_USAGE_MINIMUM(16, 0x0001), /* System Power Down */
 143         HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
 144         HID_RI_REPORT_SIZE(8, 16),
 145         HID_RI_REPORT_COUNT(8, 1),
 146         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 147     HID_RI_END_COLLECTION(0),
 148
 149     HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 150     HID_RI_USAGE(8, 0x01), /* Consumer Control */
 151     HID_RI_COLLECTION(8, 0x01), /* Application */
 152         HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
 153         HID_RI_LOGICAL_MINIMUM(16, 0x0001),
 154         HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
 155         HID_RI_USAGE_MINIMUM(16, 0x0001), /* +10 */
 156         HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
 157         HID_RI_REPORT_SIZE(8, 16),
 158         HID_RI_REPORT_COUNT(8, 1),
 159         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 160     HID_RI_END_COLLECTION(0),
 161 };
 162 #endif
 163
 164 #ifdef CONSOLE_ENABLE
 165 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
 166 {
 167     HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
 168     HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
 169     HID_RI_COLLECTION(8, 0x01), /* Application */
 170         HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
 171         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 172         HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 173         HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 174         HID_RI_REPORT_SIZE(8, 0x08),
 175         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 176         HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
 177         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 178         HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 179         HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 180         HID_RI_REPORT_SIZE(8, 0x08),
 181         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
 182     HID_RI_END_COLLECTION(0),
 183 };
 184 #endif
 185
 186 #ifdef NKRO_ENABLE
 187 const USB_Descriptor_HIDReport_Datatype_t PROGMEM NKROReport[] =
 188 {
 189     HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 190     HID_RI_USAGE(8, 0x06), /* Keyboard */
 191     HID_RI_COLLECTION(8, 0x01), /* Application */
 192         HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
 193         HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
 194         HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
 195         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 196         HID_RI_LOGICAL_MAXIMUM(8, 0x01),
 197         HID_RI_REPORT_COUNT(8, 0x08),
 198         HID_RI_REPORT_SIZE(8, 0x01),
 199         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 200
 201         HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
 202         HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
 203         HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
 204         HID_RI_REPORT_COUNT(8, 0x05),
 205         HID_RI_REPORT_SIZE(8, 0x01),
 206         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
 207         HID_RI_REPORT_COUNT(8, 0x01),
 208         HID_RI_REPORT_SIZE(8, 0x03),
 209         HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
 210
 211         HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
 212         HID_RI_USAGE_MINIMUM(8, 0x00), /* Keyboard 0 */
 213         HID_RI_USAGE_MAXIMUM(8, NKRO_SIZE*8-1), /* Keyboard Right GUI */
 214         HID_RI_LOGICAL_MINIMUM(8, 0x00),
 215         HID_RI_LOGICAL_MAXIMUM(8, 0x01),
 216         HID_RI_REPORT_COUNT(8, NKRO_SIZE*8),
 217         HID_RI_REPORT_SIZE(8, 0x01),
 218 };
 219 #endif
 220
 221 /*******************************************************************************
 222  * Device Descriptors
 223  ******************************************************************************/
 224 const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
 225 {
 226     .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
 227
 228     .USBSpecification       = VERSION_BCD(01.10),
 229     .Class                  = USB_CSCP_NoDeviceClass,
 230     .SubClass               = USB_CSCP_NoDeviceSubclass,
 231     .Protocol               = USB_CSCP_NoDeviceProtocol,
 232
 233     .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
 234
 235     .VendorID               = VENDOR_ID,
 236     .ProductID              = PRODUCT_ID,
 237     .ReleaseNumber          = DEVICE_VER,
 238
 239     .ManufacturerStrIndex   = 0x01,
 240     .ProductStrIndex        = 0x02,
 241     .SerialNumStrIndex      = NO_DESCRIPTOR,
 242
 243     .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
 244 };
 245
 246 /*******************************************************************************
 247  * Configuration Descriptors
 248  ******************************************************************************/
 249 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
 250 {
 251     .Config =
 252         {
 253             .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
 254
 255             .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
 256             .TotalInterfaces        = TOTAL_INTERFACES,
 257
 258             .ConfigurationNumber    = 1,
 259             .ConfigurationStrIndex  = NO_DESCRIPTOR,
 260
 261             .ConfigAttributes       = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
 262
 263             .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
 264         },
 265
 266     /*
 267      * Keyboard
 268      */
 269     .Keyboard_Interface =
 270         {
 271             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 272
 273             .InterfaceNumber        = KEYBOARD_INTERFACE,
 274             .AlternateSetting       = 0x00,
 275
 276             .TotalEndpoints         = 1,
 277
 278             .Class                  = HID_CSCP_HIDClass,
 279             .SubClass               = HID_CSCP_BootSubclass,
 280             .Protocol               = HID_CSCP_KeyboardBootProtocol,
 281
 282             .InterfaceStrIndex      = NO_DESCRIPTOR
 283         },
 284
 285     .Keyboard_HID =
 286         {
 287             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 288
 289             .HIDSpec                = VERSION_BCD(01.11),
 290             .CountryCode            = 0x00,
 291             .TotalReportDescriptors = 1,
 292             .HIDReportType          = HID_DTYPE_Report,
 293             .HIDReportLength        = sizeof(KeyboardReport)
 294         },
 295
 296     .Keyboard_INEndpoint =
 297         {
 298             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 299
 300             .EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
 301             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 302             .EndpointSize           = KEYBOARD_EPSIZE,
 303             .PollingIntervalMS      = 0x01
 304         },
 305
 306     /*
 307      * Mouse
 308      */
 309 #ifdef MOUSE_ENABLE
 310     .Mouse_Interface =
 311         {
 312             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 313
 314             .InterfaceNumber        = MOUSE_INTERFACE,
 315             .AlternateSetting       = 0x00,
 316
 317             .TotalEndpoints         = 1,
 318
 319             .Class                  = HID_CSCP_HIDClass,
 320             .SubClass               = HID_CSCP_BootSubclass,
 321             .Protocol               = HID_CSCP_MouseBootProtocol,
 322
 323             .InterfaceStrIndex      = NO_DESCRIPTOR
 324         },
 325
 326     .Mouse_HID =
 327         {
 328             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 329
 330             .HIDSpec                = VERSION_BCD(01.11),
 331             .CountryCode            = 0x00,
 332             .TotalReportDescriptors = 1,
 333             .HIDReportType          = HID_DTYPE_Report,
 334             .HIDReportLength        = sizeof(MouseReport)
 335         },
 336
 337     .Mouse_INEndpoint =
 338         {
 339             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 340
 341             .EndpointAddress        = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
 342             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 343             .EndpointSize           = MOUSE_EPSIZE,
 344             .PollingIntervalMS      = 0x01
 345         },
 346 #endif
 347
 348     /*
 349      * Extra
 350      */
 351 #ifdef EXTRAKEY_ENABLE
 352     .Extrakey_Interface =
 353         {
 354             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 355
 356             .InterfaceNumber        = EXTRAKEY_INTERFACE,
 357             .AlternateSetting       = 0x00,
 358
 359             .TotalEndpoints         = 1,
 360
 361             .Class                  = HID_CSCP_HIDClass,
 362             .SubClass               = HID_CSCP_NonBootSubclass,
 363             .Protocol               = HID_CSCP_NonBootProtocol,
 364
 365             .InterfaceStrIndex      = NO_DESCRIPTOR
 366         },
 367
 368     .Extrakey_HID =
 369         {
 370             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 371
 372             .HIDSpec                = VERSION_BCD(01.11),
 373             .CountryCode            = 0x00,
 374             .TotalReportDescriptors = 1,
 375             .HIDReportType          = HID_DTYPE_Report,
 376             .HIDReportLength        = sizeof(ExtrakeyReport)
 377         },
 378
 379     .Extrakey_INEndpoint =
 380         {
 381             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 382
 383             .EndpointAddress        = (ENDPOINT_DIR_IN | EXTRAKEY_IN_EPNUM),
 384             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 385             .EndpointSize           = EXTRAKEY_EPSIZE,
 386             .PollingIntervalMS      = 0x01
 387         },
 388 #endif
 389
 390     /*
 391      * Console
 392      */
 393 #ifdef CONSOLE_ENABLE
 394     .Console_Interface =
 395         {
 396             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 397
 398             .InterfaceNumber        = CONSOLE_INTERFACE,
 399             .AlternateSetting       = 0x00,
 400
 401             .TotalEndpoints         = 2,
 402
 403             .Class                  = HID_CSCP_HIDClass,
 404             .SubClass               = HID_CSCP_NonBootSubclass,
 405             .Protocol               = HID_CSCP_NonBootProtocol,
 406
 407             .InterfaceStrIndex      = NO_DESCRIPTOR
 408         },
 409
 410     .Console_HID =
 411         {
 412             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 413
 414             .HIDSpec                = VERSION_BCD(01.11),
 415             .CountryCode            = 0x00,
 416             .TotalReportDescriptors = 1,
 417             .HIDReportType          = HID_DTYPE_Report,
 418             .HIDReportLength        = sizeof(ConsoleReport)
 419         },
 420
 421     .Console_INEndpoint =
 422         {
 423             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 424
 425             .EndpointAddress        = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
 426             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 427             .EndpointSize           = CONSOLE_EPSIZE,
 428             .PollingIntervalMS      = 0x01
 429         },
 430
 431     .Console_OUTEndpoint =
 432         {
 433             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 434
 435             .EndpointAddress        = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
 436             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 437             .EndpointSize           = CONSOLE_EPSIZE,
 438             .PollingIntervalMS      = 0x01
 439         },
 440 #endif
 441 };
 442
 443
 444 /*******************************************************************************
 445  * String Descriptors
 446  ******************************************************************************/
 447 const USB_Descriptor_String_t PROGMEM LanguageString =
 448 {
 449     .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
 450
 451     .UnicodeString          = {LANGUAGE_ID_ENG}
 452 };
 453
 454 const USB_Descriptor_String_t PROGMEM ManufacturerString =
 455 {
 456     .Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
 457
 458     .UnicodeString          = LSTR(MANUFACTURER)
 459 };
 460
 461 const USB_Descriptor_String_t PROGMEM ProductString =
 462 {
 463     .Header                 = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String},
 464
 465     .UnicodeString          = LSTR(PRODUCT)
 466 };
 467
 468
 469 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
 470  *  documentation) by the application code so that the address and size of a requested descriptor can be given
 471  *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
 472  *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
 473  *  USB host.
 474  */
 475 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
 476                                     const uint8_t wIndex,
 477                                     const void** const DescriptorAddress)
 478 {
 479     const uint8_t  DescriptorType   = (wValue >> 8);
 480     const uint8_t  DescriptorIndex  = (wValue & 0xFF);
 481
 482     const void* Address = NULL;
 483     uint16_t    Size    = NO_DESCRIPTOR;
 484
 485     switch (DescriptorType)
 486     {
 487         case DTYPE_Device:
 488             Address = &DeviceDescriptor;
 489             Size    = sizeof(USB_Descriptor_Device_t);
 490             break;
 491         case DTYPE_Configuration:
 492             Address = &ConfigurationDescriptor;
 493             Size    = sizeof(USB_Descriptor_Configuration_t);
 494             break;
 495         case DTYPE_String:
 496             switch (DescriptorIndex )
 497             {
 498                 case 0x00:
 499                     Address = &LanguageString;
 500                     Size    = pgm_read_byte(&LanguageString.Header.Size);
 501                     break;
 502                 case 0x01:
 503                     Address = &ManufacturerString;
 504                     Size    = pgm_read_byte(&ManufacturerString.Header.Size);
 505                     break;
 506                 case 0x02:
 507                     Address = &ProductString;
 508                     Size    = pgm_read_byte(&ProductString.Header.Size);
 509                     break;
 510             }
 511             break;
 512         case HID_DTYPE_HID:
 513             switch (wIndex) {
 514             case KEYBOARD_INTERFACE:
 515                 Address = &ConfigurationDescriptor.Keyboard_HID;
 516                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 517                 break;
 518 #ifdef MOUSE_ENABLE
 519             case MOUSE_INTERFACE:
 520                 Address = &ConfigurationDescriptor.Mouse_HID;
 521                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 522                 break;
 523 #endif
 524 #ifdef EXTRAKEY_ENABLE
 525             case EXTRAKEY_INTERFACE:
 526                 Address = &ConfigurationDescriptor.Extrakey_HID;
 527                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 528                 break;
 529 #endif
 530 #ifdef CONSOLE_ENABLE
 531             case CONSOLE_INTERFACE:
 532                 Address = &ConfigurationDescriptor.Console_HID;
 533                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 534                 break;
 535 #endif
 536             }
 537             break;
 538         case HID_DTYPE_Report:
 539             switch (wIndex) {
 540             case KEYBOARD_INTERFACE:
 541                 Address = &KeyboardReport;
 542                 Size    = sizeof(KeyboardReport);
 543                 break;
 544 #ifdef MOUSE_ENABLE
 545             case MOUSE_INTERFACE:
 546                 Address = &MouseReport;
 547                 Size    = sizeof(MouseReport);
 548                 break;
 549 #endif
 550 #ifdef EXTRAKEY_ENABLE
 551             case EXTRAKEY_INTERFACE:
 552                 Address = &ExtrakeyReport;
 553                 Size    = sizeof(ExtrakeyReport);
 554                 break;
 555 #endif
 556 #ifdef CONSOLE_ENABLE
 557             case CONSOLE_INTERFACE:
 558                 Address = &ConsoleReport;
 559                 Size    = sizeof(ConsoleReport);
 560                 break;
 561 #endif
 562             }
 563             break;
 564     }
 565
 566     *DescriptorAddress = Address;
 567     return Size;
 568 }