[jackhill/qmk/firmware.git] / protocol / lufa / descriptor.c

/* 
 * Copyright 2012 Jun Wako <wakojun@gmail.com>
 * This file is based on:
 *     LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse
 *     LUFA-120219/Demos/Device/Lowlevel/GenericHID
 */

/*
             LUFA Library
     Copyright (C) Dean Camera, 2012.

  dean [at] fourwalledcubicle [dot] com
           www.lufa-lib.org
*/

/*
  Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)

  Permission to use, copy, modify, distribute, and sell this
  software and its documentation for any purpose is hereby granted
  without fee, provided that the above copyright notice appear in
  all copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting
  documentation, and that the name of the author not be used in
  advertising or publicity pertaining to distribution of the
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

#include "util.h"
#include "report.h"
#include "descriptor.h"


/*******************************************************************************
 * HID Report Descriptors
 ******************************************************************************/
const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
{
    HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
    HID_RI_USAGE(8, 0x06), /* Keyboard */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
        HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
        HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0x01),
        HID_RI_REPORT_COUNT(8, 0x08),
        HID_RI_REPORT_SIZE(8, 0x01),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
        HID_RI_REPORT_COUNT(8, 0x01),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_INPUT(8, HID_IOF_CONSTANT),
        HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
        HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
        HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
        HID_RI_REPORT_COUNT(8, 0x05),
        HID_RI_REPORT_SIZE(8, 0x01),
        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
        HID_RI_REPORT_COUNT(8, 0x01),
        HID_RI_REPORT_SIZE(8, 0x03),
        HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
        HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
        HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
        HID_RI_USAGE_MAXIMUM(8, 0xFF), /* Keyboard Application */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_COUNT(8, 0x06),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
    HID_RI_END_COLLECTION(0),
};

const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
{
    HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
    HID_RI_USAGE(8, 0x02), /* Mouse */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_USAGE(8, 0x01), /* Pointer */
        HID_RI_COLLECTION(8, 0x00), /* Physical */

            HID_RI_USAGE_PAGE(8, 0x09), /* Button */
            HID_RI_USAGE_MINIMUM(8, 0x01),  /* Button 1 */
            HID_RI_USAGE_MAXIMUM(8, 0x05),  /* Button 5 */
            HID_RI_LOGICAL_MINIMUM(8, 0x00),
            HID_RI_LOGICAL_MAXIMUM(8, 0x01),
            HID_RI_REPORT_COUNT(8, 0x05),
            HID_RI_REPORT_SIZE(8, 0x01),
            HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
            HID_RI_REPORT_COUNT(8, 0x01),
            HID_RI_REPORT_SIZE(8, 0x03),
            HID_RI_INPUT(8, HID_IOF_CONSTANT),

            HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
            HID_RI_USAGE(8, 0x30), /* Usage X */
            HID_RI_USAGE(8, 0x31), /* Usage Y */
            HID_RI_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            HID_RI_REPORT_COUNT(8, 0x02),
            HID_RI_REPORT_SIZE(8, 0x08),
            HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),

            HID_RI_USAGE(8, 0x38), /* Wheel */
            HID_RI_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            HID_RI_REPORT_COUNT(8, 0x01),
            HID_RI_REPORT_SIZE(8, 0x08),
            HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),

            HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
            HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
            HID_RI_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            HID_RI_REPORT_COUNT(8, 0x01),
            HID_RI_REPORT_SIZE(8, 0x08),
            HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),

        HID_RI_END_COLLECTION(0),
    HID_RI_END_COLLECTION(0),
};

const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
{
    HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
    HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
        HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
    HID_RI_END_COLLECTION(0),
};

#ifdef EXTRAKEY_ENABLE
const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtraReport[] =
{
    HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
    HID_RI_USAGE(8, 0x80), /* System Control */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
        HID_RI_LOGICAL_MINIMUM(16, 0x0001),
        HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
        HID_RI_USAGE_MINIMUM(16, 0x0001), /* System Power Down */
        HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
        HID_RI_REPORT_SIZE(8, 16),
        HID_RI_REPORT_COUNT(8, 1),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
    HID_RI_END_COLLECTION(0),

    HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
    HID_RI_USAGE(8, 0x01), /* Consumer Control */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
        HID_RI_LOGICAL_MINIMUM(16, 0x0001),
        HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
        HID_RI_USAGE_MINIMUM(16, 0x0001), /* +10 */
        HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
        HID_RI_REPORT_SIZE(8, 16),
        HID_RI_REPORT_COUNT(8, 1),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
    HID_RI_END_COLLECTION(0),
};
#endif

#ifdef NKRO_ENABLE
const USB_Descriptor_HIDReport_Datatype_t PROGMEM NKROReport[] =
{
    HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
    HID_RI_USAGE(8, 0x06), /* Keyboard */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
        HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
        HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0x01),
        HID_RI_REPORT_COUNT(8, 0x08),
        HID_RI_REPORT_SIZE(8, 0x01),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),

        HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
        HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
        HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
        HID_RI_REPORT_COUNT(8, 0x05),
        HID_RI_REPORT_SIZE(8, 0x01),
        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
        HID_RI_REPORT_COUNT(8, 0x01),
        HID_RI_REPORT_SIZE(8, 0x03),
        HID_RI_OUTPUT(8, HID_IOF_CONSTANT),

        HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
        HID_RI_USAGE_MINIMUM(8, 0x00), /* Keyboard 0 */
        HID_RI_USAGE_MAXIMUM(8, NKRO_SIZE*8-1), /* Keyboard Right GUI */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0x01),
        HID_RI_REPORT_COUNT(8, NKRO_SIZE*8),
        HID_RI_REPORT_SIZE(8, 0x01),
};
#endif

/*******************************************************************************
 * Device Descriptors
 ******************************************************************************/
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
{
    .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},

    .USBSpecification       = VERSION_BCD(01.10),
    .Class                  = USB_CSCP_NoDeviceClass,
    .SubClass               = USB_CSCP_NoDeviceSubclass,
    .Protocol               = USB_CSCP_NoDeviceProtocol,

    .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,

    .VendorID               = VENDOR_ID,
    .ProductID              = PRODUCT_ID,
    .ReleaseNumber          = DEVICE_VER,

    .ManufacturerStrIndex   = 0x01,
    .ProductStrIndex        = 0x02,
    .SerialNumStrIndex      = NO_DESCRIPTOR,

    .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
};

/*******************************************************************************
 * Configuration Descriptors
 ******************************************************************************/
const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
{
    .Config =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},

            .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
            .TotalInterfaces        = TOTAL_INTERFACES,

            .ConfigurationNumber    = 1,
            .ConfigurationStrIndex  = NO_DESCRIPTOR,

            .ConfigAttributes       = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),

            .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
        },

    /*
     * Keyboard
     */
    .Keyboard_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = KEYBOARD_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 1,

            .Class                  = HID_CSCP_HIDClass,
            .SubClass               = HID_CSCP_BootSubclass,
            .Protocol               = HID_CSCP_KeyboardBootProtocol,

            .InterfaceStrIndex      = NO_DESCRIPTOR
        },

    .Keyboard_HID =
        {
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},

            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = HID_DTYPE_Report,
            .HIDReportLength        = sizeof(KeyboardReport)
        },

    .Keyboard_INEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = KEYBOARD_EPSIZE,
            .PollingIntervalMS      = 0x01
        },

    /*
     * Mouse
     */
#ifdef MOUSE_ENABLE
    .Mouse_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = MOUSE_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 1,

            .Class                  = HID_CSCP_HIDClass,
            .SubClass               = HID_CSCP_BootSubclass,
            .Protocol               = HID_CSCP_MouseBootProtocol,

            .InterfaceStrIndex      = NO_DESCRIPTOR
        },

    .Mouse_HID =
        {
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},

            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = HID_DTYPE_Report,
            .HIDReportLength        = sizeof(MouseReport)
        },

    .Mouse_INEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = MOUSE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },
#endif

    /*
     * Console
     */
    .Console_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = CONSOLE_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 2,

            .Class                  = HID_CSCP_HIDClass,
            .SubClass               = HID_CSCP_NonBootSubclass,
            .Protocol               = HID_CSCP_NonBootProtocol,

            .InterfaceStrIndex      = NO_DESCRIPTOR
        },

    .Console_HID =
        {
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},

            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = HID_DTYPE_Report,
            .HIDReportLength        = sizeof(ConsoleReport)
        },

    .Console_INEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = CONSOLE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },

    .Console_OUTEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = CONSOLE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },

    /*
     * Extra
     */
#ifdef EXTRAKEY_ENABLE
    .Extra_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = EXTRA_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 1,

            .Class                  = HID_CSCP_HIDClass,
            .SubClass               = HID_CSCP_NonBootSubclass,
            .Protocol               = HID_CSCP_NonBootProtocol,

            .InterfaceStrIndex      = NO_DESCRIPTOR
        },

    .Extra_HID =
        {
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},

            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = HID_DTYPE_Report,
            .HIDReportLength        = sizeof(ExtraReport)
        },

    .Extra_INEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | EXTRA_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = EXTRA_EPSIZE,
            .PollingIntervalMS      = 0x01
        },
#endif
};


/*******************************************************************************
 * String Descriptors
 ******************************************************************************/
const USB_Descriptor_String_t PROGMEM LanguageString =
{
    .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},

    .UnicodeString          = {LANGUAGE_ID_ENG}
};

const USB_Descriptor_String_t PROGMEM ManufacturerString =
{
    .Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},

    .UnicodeString          = LSTR(MANUFACTURER)
};

const USB_Descriptor_String_t PROGMEM ProductString =
{
    .Header                 = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String},

    .UnicodeString          = LSTR(PRODUCT)
};


/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
 *  documentation) by the application code so that the address and size of a requested descriptor can be given
 *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
 *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
 *  USB host.
 */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                                    const uint8_t wIndex,
                                    const void** const DescriptorAddress)
{
    const uint8_t  DescriptorType   = (wValue >> 8);
    const uint8_t  DescriptorIndex  = (wValue & 0xFF);

    const void* Address = NULL;
    uint16_t    Size    = NO_DESCRIPTOR;

    switch (DescriptorType)
    {
        case DTYPE_Device:
            Address = &DeviceDescriptor;
            Size    = sizeof(USB_Descriptor_Device_t);
            break;
        case DTYPE_Configuration:
            Address = &ConfigurationDescriptor;
            Size    = sizeof(USB_Descriptor_Configuration_t);
            break;
        case DTYPE_String:
            switch (DescriptorIndex )
            {
                case 0x00:
                    Address = &LanguageString;
                    Size    = pgm_read_byte(&LanguageString.Header.Size);
                    break;
                case 0x01:
                    Address = &ManufacturerString;
                    Size    = pgm_read_byte(&ManufacturerString.Header.Size);
                    break;
                case 0x02:
                    Address = &ProductString;
                    Size    = pgm_read_byte(&ProductString.Header.Size);
                    break;
            }
            break;
        case HID_DTYPE_HID:
            switch (wIndex) {
            case KEYBOARD_INTERFACE:
                Address = &ConfigurationDescriptor.Keyboard_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
#ifdef MOUSE_ENABLE
            case MOUSE_INTERFACE:
                Address = &ConfigurationDescriptor.Mouse_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
#endif
            case CONSOLE_INTERFACE:
                Address = &ConfigurationDescriptor.Console_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
#ifdef EXTRAKEY_ENABLE
            case EXTRA_INTERFACE:
                Address = &ConfigurationDescriptor.Extra_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
#endif
            }
            break;
        case HID_DTYPE_Report:
            switch (wIndex) {
            case KEYBOARD_INTERFACE:
                Address = &KeyboardReport;
                Size    = sizeof(KeyboardReport);
                break;
#ifdef MOUSE_ENABLE
            case MOUSE_INTERFACE:
                Address = &MouseReport;
                Size    = sizeof(MouseReport);
                break;
#endif
            case CONSOLE_INTERFACE:
                Address = &ConsoleReport;
                Size    = sizeof(ConsoleReport);
                break;
#ifdef EXTRAKEY_ENABLE
            case EXTRA_INTERFACE:
                Address = &ExtraReport;
                Size    = sizeof(ExtraReport);
                break;
#endif
            }
            break;
    }

    *DescriptorAddress = Address;
    return Size;
}
Commit	Line	Data
3969ec09	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
effa5914	39	#include "util.h"
3d81d522	40	#include "report.h"
effa5914	41	#include "descriptor.h"
3969ec09	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),
3969ec09	57	HID_RI_REPORT_COUNT(8, 0x08),
f2ebac10	58	HID_RI_REPORT_SIZE(8, 0x01),
3969ec09	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),
3969ec09	72	HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
3969ec09	73	HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
f2ebac10	74	HID_RI_USAGE_MAXIMUM(8, 0xFF), /* Keyboard Application */
	75	HID_RI_LOGICAL_MINIMUM(8, 0x00),
	76	HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
3969ec09	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 */
3d81d522	90
3969ec09	91	HID_RI_USAGE_PAGE(8, 0x09), /* Button */
3d81d522	92	HID_RI_USAGE_MINIMUM(8, 0x01), /* Button 1 */
3d81d522	93	HID_RI_USAGE_MAXIMUM(8, 0x05), /* Button 5 */
3969ec09	94	HID_RI_LOGICAL_MINIMUM(8, 0x00),
3969ec09	95	HID_RI_LOGICAL_MAXIMUM(8, 0x01),
3d81d522	96	HID_RI_REPORT_COUNT(8, 0x05),
3969ec09	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),
3d81d522	100	HID_RI_REPORT_SIZE(8, 0x03),
3969ec09	101	HID_RI_INPUT(8, HID_IOF_CONSTANT),
3d81d522	102
3969ec09	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 */
3d81d522	106	HID_RI_LOGICAL_MINIMUM(8, -127),
3d81d522	107	HID_RI_LOGICAL_MAXIMUM(8, 127),
3969ec09	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),
3d81d522	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
3969ec09	127	HID_RI_END_COLLECTION(0),
	128	HID_RI_END_COLLECTION(0),
	129	};
	130
a9a3610d	131	const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
3969ec09	132	{
52011f08	133	HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
52011f08	134	HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
3d81d522	135	HID_RI_COLLECTION(8, 0x01), /* Application */
f2ebac10	136	HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
3969ec09	137	HID_RI_LOGICAL_MINIMUM(8, 0x00),
3969ec09	138	HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
3d81d522	139	HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
f2ebac10	140	HID_RI_REPORT_SIZE(8, 0x08),
3969ec09	141	HID_RI_INPUT(8, HID_IOF_DATA \| HID_IOF_VARIABLE \| HID_IOF_ABSOLUTE),
f2ebac10	142	HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
3969ec09	143	HID_RI_LOGICAL_MINIMUM(8, 0x00),
3969ec09	144	HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
3d81d522	145	HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
f2ebac10	146	HID_RI_REPORT_SIZE(8, 0x08),
3969ec09	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
f2ebac10	151	#ifdef EXTRAKEY_ENABLE
3d81d522	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),
ab89bfce	158	HID_RI_LOGICAL_MINIMUM(16, 0x0001),
3d81d522	159	HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
ab89bfce	160	HID_RI_USAGE_MINIMUM(16, 0x0001), /* System Power Down */
3d81d522	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),
ab89bfce	171	HID_RI_LOGICAL_MINIMUM(16, 0x0001),
3d81d522	172	HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
ab89bfce	173	HID_RI_USAGE_MINIMUM(16, 0x0001), /* +10 */
3d81d522	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	};
f2ebac10	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_SIZE8-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
3969ec09	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
effa5914	231	.VendorID = VENDOR_ID,
	232	.ProductID = PRODUCT_ID,
	233	.ReleaseNumber = DEVICE_VER,
3969ec09	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),
3d81d522	252	.TotalInterfaces = TOTAL_INTERFACES,
3969ec09	253
	254	.ConfigurationNumber = 1,
	255	.ConfigurationStrIndex = NO_DESCRIPTOR,
	256
effa5914	257	.ConfigAttributes = (USB_CONFIG_ATTR_RESERVED \| USB_CONFIG_ATTR_REMOTEWAKEUP),
3969ec09	258
	259	.MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
	260	},
	261
3d81d522	262	/*
	263	* Keyboard
	264	*/
a9a3610d	265	.Keyboard_Interface =
3969ec09	266	{
	267	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	268
effa5914	269	.InterfaceNumber = KEYBOARD_INTERFACE,
3969ec09	270	.AlternateSetting = 0x00,
3969ec09	271
effa5914	272	.TotalEndpoints = 1,
3969ec09	273
	274	.Class = HID_CSCP_HIDClass,
	275	.SubClass = HID_CSCP_BootSubclass,
	276	.Protocol = HID_CSCP_KeyboardBootProtocol,
	277
	278	.InterfaceStrIndex = NO_DESCRIPTOR
	279	},
	280
a9a3610d	281	.Keyboard_HID =
3969ec09	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
a9a3610d	292	.Keyboard_INEndpoint =
3969ec09	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),
3d81d522	298	.EndpointSize = KEYBOARD_EPSIZE,
3969ec09	299	.PollingIntervalMS = 0x01
	300	},
	301
3969ec09	302	/*
	303	* Mouse
	304	*/
f2ebac10	305	#ifdef MOUSE_ENABLE
a9a3610d	306	.Mouse_Interface =
3969ec09	307	{
	308	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	309
effa5914	310	.InterfaceNumber = MOUSE_INTERFACE,
3969ec09	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
a9a3610d	322	.Mouse_HID =
3969ec09	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
a9a3610d	333	.Mouse_INEndpoint =
3969ec09	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),
3d81d522	339	.EndpointSize = MOUSE_EPSIZE,
3969ec09	340	.PollingIntervalMS = 0x01
3969ec09	341	},
f2ebac10	342	#endif
3969ec09	343
3969ec09	344	/*
a9a3610d	345	* Console
3969ec09	346	*/
a9a3610d	347	.Console_Interface =
3969ec09	348	{
	349	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	350
3d81d522	351	.InterfaceNumber = CONSOLE_INTERFACE,
3969ec09	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
a9a3610d	363	.Console_HID =
3969ec09	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,
a9a3610d	371	.HIDReportLength = sizeof(ConsoleReport)
3969ec09	372	},
3969ec09	373
a9a3610d	374	.Console_INEndpoint =
3969ec09	375	{
	376	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	377
3d81d522	378	.EndpointAddress = (ENDPOINT_DIR_IN \| CONSOLE_IN_EPNUM),
3969ec09	379	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	380	.EndpointSize = CONSOLE_EPSIZE,
3969ec09	381	.PollingIntervalMS = 0x01
	382	},
	383
a9a3610d	384	.Console_OUTEndpoint =
3969ec09	385	{
	386	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	387
3d81d522	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	*/
f2ebac10	397	#ifdef EXTRAKEY_ENABLE
3d81d522	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),
3969ec09	430	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	431	.EndpointSize = EXTRA_EPSIZE,
3969ec09	432	.PollingIntervalMS = 0x01
3d81d522	433	},
f2ebac10	434	#endif
3969ec09	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
effa5914	452	.UnicodeString = LSTR(MANUFACTURER)
3969ec09	453	};
	454
	455	const USB_Descriptor_String_t PROGMEM ProductString =
	456	{
	457	.Header = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String},
	458
effa5914	459	.UnicodeString = LSTR(PRODUCT)
3969ec09	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) {
effa5914	508	case KEYBOARD_INTERFACE:
a9a3610d	509	Address = &ConfigurationDescriptor.Keyboard_HID;
3969ec09	510	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	511	break;
f2ebac10	512	#ifdef MOUSE_ENABLE
effa5914	513	case MOUSE_INTERFACE:
a9a3610d	514	Address = &ConfigurationDescriptor.Mouse_HID;
3969ec09	515	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	516	break;
f2ebac10	517	#endif
3d81d522	518	case CONSOLE_INTERFACE:
a9a3610d	519	Address = &ConfigurationDescriptor.Console_HID;
3969ec09	520	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	521	break;
f2ebac10	522	#ifdef EXTRAKEY_ENABLE
3d81d522	523	case EXTRA_INTERFACE:
	524	Address = &ConfigurationDescriptor.Extra_HID;
	525	Size = sizeof(USB_HID_Descriptor_HID_t);
	526	break;
f2ebac10	527	#endif
3969ec09	528	}
	529	break;
	530	case HID_DTYPE_Report:
	531	switch (wIndex) {
effa5914	532	case KEYBOARD_INTERFACE:
3969ec09	533	Address = &KeyboardReport;
	534	Size = sizeof(KeyboardReport);
	535	break;
f2ebac10	536	#ifdef MOUSE_ENABLE
effa5914	537	case MOUSE_INTERFACE:
3969ec09	538	Address = &MouseReport;
	539	Size = sizeof(MouseReport);
	540	break;
f2ebac10	541	#endif
3d81d522	542	case CONSOLE_INTERFACE:
a9a3610d	543	Address = &ConsoleReport;
a9a3610d	544	Size = sizeof(ConsoleReport);
3969ec09	545	break;
f2ebac10	546	#ifdef EXTRAKEY_ENABLE
3d81d522	547	case EXTRA_INTERFACE:
	548	Address = &ExtraReport;
	549	Size = sizeof(ExtraReport);
	550	break;
f2ebac10	551	#endif
3969ec09	552	}
	553	break;
	554	}
	555
	556	*DescriptorAddress = Address;
	557	return Size;
	558	}