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          = 8,
 234
 235     /* specified in config.h */
 236     .VendorID               = VENDOR_ID,
 237     .ProductID              = PRODUCT_ID,
 238     .ReleaseNumber          = DEVICE_VER,
 239
 240     .ManufacturerStrIndex   = 0x01,
 241     .ProductStrIndex        = 0x02,
 242     .SerialNumStrIndex      = NO_DESCRIPTOR,
 243
 244     .NumberOfConfigurations = 1
 245 };
 246
 247 /*******************************************************************************
 248  * Configuration Descriptors
 249  ******************************************************************************/
 250 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
 251 {
 252     .Config =
 253         {
 254             .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
 255
 256             .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
 257             .TotalInterfaces        = TOTAL_INTERFACES,
 258
 259             .ConfigurationNumber    = 1,
 260             .ConfigurationStrIndex  = NO_DESCRIPTOR,
 261
 262             .ConfigAttributes       = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
 263
 264             .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
 265         },
 266
 267     /*
 268      * Keyboard
 269      */
 270     .Keyboard_Interface =
 271         {
 272             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 273
 274             .InterfaceNumber        = KEYBOARD_INTERFACE,
 275             .AlternateSetting       = 0x00,
 276
 277             .TotalEndpoints         = 1,
 278
 279             .Class                  = HID_CSCP_HIDClass,
 280             .SubClass               = HID_CSCP_BootSubclass,
 281             .Protocol               = HID_CSCP_KeyboardBootProtocol,
 282
 283             .InterfaceStrIndex      = NO_DESCRIPTOR
 284         },
 285
 286     .Keyboard_HID =
 287         {
 288             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 289
 290             .HIDSpec                = VERSION_BCD(01.11),
 291             .CountryCode            = 0x00,
 292             .TotalReportDescriptors = 1,
 293             .HIDReportType          = HID_DTYPE_Report,
 294             .HIDReportLength        = sizeof(KeyboardReport)
 295         },
 296
 297     .Keyboard_INEndpoint =
 298         {
 299             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 300
 301             .EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
 302             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 303             .EndpointSize           = KEYBOARD_EPSIZE,
 304             .PollingIntervalMS      = 0x01
 305         },
 306
 307     /*
 308      * Mouse
 309      */
 310 #ifdef MOUSE_ENABLE
 311     .Mouse_Interface =
 312         {
 313             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 314
 315             .InterfaceNumber        = MOUSE_INTERFACE,
 316             .AlternateSetting       = 0x00,
 317
 318             .TotalEndpoints         = 1,
 319
 320             .Class                  = HID_CSCP_HIDClass,
 321             .SubClass               = HID_CSCP_BootSubclass,
 322             .Protocol               = HID_CSCP_MouseBootProtocol,
 323
 324             .InterfaceStrIndex      = NO_DESCRIPTOR
 325         },
 326
 327     .Mouse_HID =
 328         {
 329             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 330
 331             .HIDSpec                = VERSION_BCD(01.11),
 332             .CountryCode            = 0x00,
 333             .TotalReportDescriptors = 1,
 334             .HIDReportType          = HID_DTYPE_Report,
 335             .HIDReportLength        = sizeof(MouseReport)
 336         },
 337
 338     .Mouse_INEndpoint =
 339         {
 340             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 341
 342             .EndpointAddress        = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
 343             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 344             .EndpointSize           = MOUSE_EPSIZE,
 345             .PollingIntervalMS      = 0x01
 346         },
 347 #endif
 348
 349     /*
 350      * Extra
 351      */
 352 #ifdef EXTRAKEY_ENABLE
 353     .Extrakey_Interface =
 354         {
 355             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 356
 357             .InterfaceNumber        = EXTRAKEY_INTERFACE,
 358             .AlternateSetting       = 0x00,
 359
 360             .TotalEndpoints         = 1,
 361
 362             .Class                  = HID_CSCP_HIDClass,
 363             .SubClass               = HID_CSCP_NonBootSubclass,
 364             .Protocol               = HID_CSCP_NonBootProtocol,
 365
 366             .InterfaceStrIndex      = NO_DESCRIPTOR
 367         },
 368
 369     .Extrakey_HID =
 370         {
 371             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 372
 373             .HIDSpec                = VERSION_BCD(01.11),
 374             .CountryCode            = 0x00,
 375             .TotalReportDescriptors = 1,
 376             .HIDReportType          = HID_DTYPE_Report,
 377             .HIDReportLength        = sizeof(ExtrakeyReport)
 378         },
 379
 380     .Extrakey_INEndpoint =
 381         {
 382             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 383
 384             .EndpointAddress        = (ENDPOINT_DIR_IN | EXTRAKEY_IN_EPNUM),
 385             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 386             .EndpointSize           = EXTRAKEY_EPSIZE,
 387             .PollingIntervalMS      = 0x01
 388         },
 389 #endif
 390
 391     /*
 392      * Console
 393      */
 394 #ifdef CONSOLE_ENABLE
 395     .Console_Interface =
 396         {
 397             .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 398
 399             .InterfaceNumber        = CONSOLE_INTERFACE,
 400             .AlternateSetting       = 0x00,
 401
 402             .TotalEndpoints         = 2,
 403
 404             .Class                  = HID_CSCP_HIDClass,
 405             .SubClass               = HID_CSCP_NonBootSubclass,
 406             .Protocol               = HID_CSCP_NonBootProtocol,
 407
 408             .InterfaceStrIndex      = NO_DESCRIPTOR
 409         },
 410
 411     .Console_HID =
 412         {
 413             .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 414
 415             .HIDSpec                = VERSION_BCD(01.11),
 416             .CountryCode            = 0x00,
 417             .TotalReportDescriptors = 1,
 418             .HIDReportType          = HID_DTYPE_Report,
 419             .HIDReportLength        = sizeof(ConsoleReport)
 420         },
 421
 422     .Console_INEndpoint =
 423         {
 424             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 425
 426             .EndpointAddress        = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
 427             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 428             .EndpointSize           = CONSOLE_EPSIZE,
 429             .PollingIntervalMS      = 0x01
 430         },
 431
 432     .Console_OUTEndpoint =
 433         {
 434             .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 435
 436             .EndpointAddress        = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
 437             .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 438             .EndpointSize           = CONSOLE_EPSIZE,
 439             .PollingIntervalMS      = 0x01
 440         },
 441 #endif
 442 };
 443
 444
 445 /*******************************************************************************
 446  * String Descriptors
 447  ******************************************************************************/
 448 const USB_Descriptor_String_t PROGMEM LanguageString =
 449 {
 450     .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
 451
 452     .UnicodeString          = {LANGUAGE_ID_ENG}
 453 };
 454
 455 const USB_Descriptor_String_t PROGMEM ManufacturerString =
 456 {
 457     /* subtract 1 for null terminator */
 458     .Header                 = {.Size = USB_STRING_LEN(sizeof(STR(MANUFACTURER))-1), .Type = DTYPE_String},
 459
 460     .UnicodeString          = LSTR(MANUFACTURER)
 461 };
 462
 463 const USB_Descriptor_String_t PROGMEM ProductString =
 464 {
 465     /* subtract 1 for null terminator */
 466     .Header                 = {.Size = USB_STRING_LEN(sizeof(STR(PRODUCT))-1), .Type = DTYPE_String},
 467
 468     .UnicodeString          = LSTR(PRODUCT)
 469 };
 470
 471
 472 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
 473  *  documentation) by the application code so that the address and size of a requested descriptor can be given
 474  *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
 475  *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
 476  *  USB host.
 477  */
 478 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
 479                                     const uint8_t wIndex,
 480                                     const void** const DescriptorAddress)
 481 {
 482     const uint8_t  DescriptorType   = (wValue >> 8);
 483     const uint8_t  DescriptorIndex  = (wValue & 0xFF);
 484
 485     const void* Address = NULL;
 486     uint16_t    Size    = NO_DESCRIPTOR;
 487
 488     switch (DescriptorType)
 489     {
 490         case DTYPE_Device:
 491             Address = &DeviceDescriptor;
 492             Size    = sizeof(USB_Descriptor_Device_t);
 493             break;
 494         case DTYPE_Configuration:
 495             Address = &ConfigurationDescriptor;
 496             Size    = sizeof(USB_Descriptor_Configuration_t);
 497             break;
 498         case DTYPE_String:
 499             switch (DescriptorIndex )
 500             {
 501                 case 0x00:
 502                     Address = &LanguageString;
 503                     Size    = pgm_read_byte(&LanguageString.Header.Size);
 504                     break;
 505                 case 0x01:
 506                     Address = &ManufacturerString;
 507                     Size    = pgm_read_byte(&ManufacturerString.Header.Size);
 508                     break;
 509                 case 0x02:
 510                     Address = &ProductString;
 511                     Size    = pgm_read_byte(&ProductString.Header.Size);
 512                     break;
 513             }
 514             break;
 515         case HID_DTYPE_HID:
 516             switch (wIndex) {
 517             case KEYBOARD_INTERFACE:
 518                 Address = &ConfigurationDescriptor.Keyboard_HID;
 519                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 520                 break;
 521 #ifdef MOUSE_ENABLE
 522             case MOUSE_INTERFACE:
 523                 Address = &ConfigurationDescriptor.Mouse_HID;
 524                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 525                 break;
 526 #endif
 527 #ifdef EXTRAKEY_ENABLE
 528             case EXTRAKEY_INTERFACE:
 529                 Address = &ConfigurationDescriptor.Extrakey_HID;
 530                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 531                 break;
 532 #endif
 533 #ifdef CONSOLE_ENABLE
 534             case CONSOLE_INTERFACE:
 535                 Address = &ConfigurationDescriptor.Console_HID;
 536                 Size    = sizeof(USB_HID_Descriptor_HID_t);
 537                 break;
 538 #endif
 539             }
 540             break;
 541         case HID_DTYPE_Report:
 542             switch (wIndex) {
 543             case KEYBOARD_INTERFACE:
 544                 Address = &KeyboardReport;
 545                 Size    = sizeof(KeyboardReport);
 546                 break;
 547 #ifdef MOUSE_ENABLE
 548             case MOUSE_INTERFACE:
 549                 Address = &MouseReport;
 550                 Size    = sizeof(MouseReport);
 551                 break;
 552 #endif
 553 #ifdef EXTRAKEY_ENABLE
 554             case EXTRAKEY_INTERFACE:
 555                 Address = &ExtrakeyReport;
 556                 Size    = sizeof(ExtrakeyReport);
 557                 break;
 558 #endif
 559 #ifdef CONSOLE_ENABLE
 560             case CONSOLE_INTERFACE:
 561                 Address = &ConsoleReport;
 562                 Size    = sizeof(ConsoleReport);
 563                 break;
 564 #endif
 565             }
 566             break;
 567     }
 568
 569     *DescriptorAddress = Address;
 570     return Size;
 571 }