[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_SIZE(8, 0x01),
        HID_RI_REPORT_COUNT(8, 0x08),
        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_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0x65),
        HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
        HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
        HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */
        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, 0x02), /* Vendor Usage 2 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
        HID_RI_USAGE(8, 0x03), /* Vendor Usage 3 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
    HID_RI_END_COLLECTION(0),
};

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, 0x0081),
        HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
        HID_RI_USAGE_MINIMUM(16, 0x0081), /* 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, 0x0010),
        HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
        HID_RI_USAGE_MINIMUM(16, 0x0010), /* +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),
};

/*******************************************************************************
 * 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
     */
    .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
        },

    /*
     * 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
     */
    .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
        },
};


/*******************************************************************************
 * 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;
            case MOUSE_INTERFACE:
                Address = &ConfigurationDescriptor.Mouse_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            case CONSOLE_INTERFACE:
                Address = &ConfigurationDescriptor.Console_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            case EXTRA_INTERFACE:
                Address = &ConfigurationDescriptor.Extra_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            }
            break;
        case HID_DTYPE_Report:
            switch (wIndex) {
            case KEYBOARD_INTERFACE:
                Address = &KeyboardReport;
                Size    = sizeof(KeyboardReport);
                break;
            case MOUSE_INTERFACE:
                Address = &MouseReport;
                Size    = sizeof(MouseReport);
                break;
            case CONSOLE_INTERFACE:
                Address = &ConsoleReport;
                Size    = sizeof(ConsoleReport);
                break;
            case EXTRA_INTERFACE:
                Address = &ExtraReport;
                Size    = sizeof(ExtraReport);
                break;
            }
            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),
	57	HID_RI_REPORT_SIZE(8, 0x01),
	58	HID_RI_REPORT_COUNT(8, 0x08),
	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_LOGICAL_MINIMUM(8, 0x00),
	73	HID_RI_LOGICAL_MAXIMUM(8, 0x65),
	74	HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
	75	HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
	76	HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */
	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 */
3969ec09	136	HID_RI_USAGE(8, 0x02), /* Vendor Usage 2 */
	137	HID_RI_LOGICAL_MINIMUM(8, 0x00),
	138	HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
	139	HID_RI_REPORT_SIZE(8, 0x08),
3d81d522	140	HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
3969ec09	141	HID_RI_INPUT(8, HID_IOF_DATA \| HID_IOF_VARIABLE \| HID_IOF_ABSOLUTE),
	142	HID_RI_USAGE(8, 0x03), /* Vendor Usage 3 */
	143	HID_RI_LOGICAL_MINIMUM(8, 0x00),
	144	HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
	145	HID_RI_REPORT_SIZE(8, 0x08),
3d81d522	146	HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
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
3d81d522	151	const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtraReport[] =
	152	{
	153	HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
	154	HID_RI_USAGE(8, 0x80), /* System Control */
	155	HID_RI_COLLECTION(8, 0x01), /* Application */
	156	HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
	157	HID_RI_LOGICAL_MINIMUM(16, 0x0081),
	158	HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
	159	HID_RI_USAGE_MINIMUM(16, 0x0081), /* System Power Down */
	160	HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
	161	HID_RI_REPORT_SIZE(8, 16),
	162	HID_RI_REPORT_COUNT(8, 1),
	163	HID_RI_INPUT(8, HID_IOF_DATA \| HID_IOF_ARRAY \| HID_IOF_ABSOLUTE),
	164	HID_RI_END_COLLECTION(0),
	165
	166	HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
	167	HID_RI_USAGE(8, 0x01), /* Consumer Control */
	168	HID_RI_COLLECTION(8, 0x01), /* Application */
	169	HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
	170	HID_RI_LOGICAL_MINIMUM(16, 0x0010),
	171	HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
	172	HID_RI_USAGE_MINIMUM(16, 0x0010), /* +10 */
	173	HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
	174	HID_RI_REPORT_SIZE(8, 16),
	175	HID_RI_REPORT_COUNT(8, 1),
	176	HID_RI_INPUT(8, HID_IOF_DATA \| HID_IOF_ARRAY \| HID_IOF_ABSOLUTE),
	177	HID_RI_END_COLLECTION(0),
	178	};
3969ec09	179
	180	/*******************************************************************************
	181	* Device Descriptors
	182	******************************************************************************/
	183	const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
	184	{
	185	.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
	186
	187	.USBSpecification = VERSION_BCD(01.10),
	188	.Class = USB_CSCP_NoDeviceClass,
	189	.SubClass = USB_CSCP_NoDeviceSubclass,
	190	.Protocol = USB_CSCP_NoDeviceProtocol,
	191
	192	.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
	193
effa5914	194	.VendorID = VENDOR_ID,
	195	.ProductID = PRODUCT_ID,
	196	.ReleaseNumber = DEVICE_VER,
3969ec09	197
	198	.ManufacturerStrIndex = 0x01,
	199	.ProductStrIndex = 0x02,
	200	.SerialNumStrIndex = NO_DESCRIPTOR,
	201
	202	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
	203	};
	204
	205	/*******************************************************************************
	206	* Configuration Descriptors
	207	******************************************************************************/
	208	const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
	209	{
	210	.Config =
	211	{
	212	.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
	213
	214	.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
3d81d522	215	.TotalInterfaces = TOTAL_INTERFACES,
3969ec09	216
	217	.ConfigurationNumber = 1,
	218	.ConfigurationStrIndex = NO_DESCRIPTOR,
	219
effa5914	220	.ConfigAttributes = (USB_CONFIG_ATTR_RESERVED \| USB_CONFIG_ATTR_REMOTEWAKEUP),
3969ec09	221
	222	.MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
	223	},
	224
3d81d522	225	/*
	226	* Keyboard
	227	*/
a9a3610d	228	.Keyboard_Interface =
3969ec09	229	{
	230	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	231
effa5914	232	.InterfaceNumber = KEYBOARD_INTERFACE,
3969ec09	233	.AlternateSetting = 0x00,
3969ec09	234
effa5914	235	.TotalEndpoints = 1,
3969ec09	236
	237	.Class = HID_CSCP_HIDClass,
	238	.SubClass = HID_CSCP_BootSubclass,
	239	.Protocol = HID_CSCP_KeyboardBootProtocol,
	240
	241	.InterfaceStrIndex = NO_DESCRIPTOR
	242	},
	243
a9a3610d	244	.Keyboard_HID =
3969ec09	245	{
	246	.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
	247
	248	.HIDSpec = VERSION_BCD(01.11),
	249	.CountryCode = 0x00,
	250	.TotalReportDescriptors = 1,
	251	.HIDReportType = HID_DTYPE_Report,
	252	.HIDReportLength = sizeof(KeyboardReport)
	253	},
	254
a9a3610d	255	.Keyboard_INEndpoint =
3969ec09	256	{
	257	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	258
	259	.EndpointAddress = (ENDPOINT_DIR_IN \| KEYBOARD_IN_EPNUM),
	260	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	261	.EndpointSize = KEYBOARD_EPSIZE,
3969ec09	262	.PollingIntervalMS = 0x01
	263	},
	264
3969ec09	265	/*
	266	* Mouse
	267	*/
a9a3610d	268	.Mouse_Interface =
3969ec09	269	{
	270	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	271
effa5914	272	.InterfaceNumber = MOUSE_INTERFACE,
3969ec09	273	.AlternateSetting = 0x00,
	274
	275	.TotalEndpoints = 1,
	276
	277	.Class = HID_CSCP_HIDClass,
	278	.SubClass = HID_CSCP_BootSubclass,
	279	.Protocol = HID_CSCP_MouseBootProtocol,
	280
	281	.InterfaceStrIndex = NO_DESCRIPTOR
	282	},
	283
a9a3610d	284	.Mouse_HID =
3969ec09	285	{
	286	.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
	287
	288	.HIDSpec = VERSION_BCD(01.11),
	289	.CountryCode = 0x00,
	290	.TotalReportDescriptors = 1,
	291	.HIDReportType = HID_DTYPE_Report,
	292	.HIDReportLength = sizeof(MouseReport)
	293	},
	294
a9a3610d	295	.Mouse_INEndpoint =
3969ec09	296	{
	297	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	298
	299	.EndpointAddress = (ENDPOINT_DIR_IN \| MOUSE_IN_EPNUM),
	300	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	301	.EndpointSize = MOUSE_EPSIZE,
3969ec09	302	.PollingIntervalMS = 0x01
	303	},
	304
	305	/*
a9a3610d	306	* Console
3969ec09	307	*/
a9a3610d	308	.Console_Interface =
3969ec09	309	{
	310	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	311
3d81d522	312	.InterfaceNumber = CONSOLE_INTERFACE,
3969ec09	313	.AlternateSetting = 0x00,
	314
	315	.TotalEndpoints = 2,
	316
	317	.Class = HID_CSCP_HIDClass,
	318	.SubClass = HID_CSCP_NonBootSubclass,
	319	.Protocol = HID_CSCP_NonBootProtocol,
	320
	321	.InterfaceStrIndex = NO_DESCRIPTOR
	322	},
	323
a9a3610d	324	.Console_HID =
3969ec09	325	{
	326	.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
	327
	328	.HIDSpec = VERSION_BCD(01.11),
	329	.CountryCode = 0x00,
	330	.TotalReportDescriptors = 1,
	331	.HIDReportType = HID_DTYPE_Report,
a9a3610d	332	.HIDReportLength = sizeof(ConsoleReport)
3969ec09	333	},
3969ec09	334
a9a3610d	335	.Console_INEndpoint =
3969ec09	336	{
	337	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	338
3d81d522	339	.EndpointAddress = (ENDPOINT_DIR_IN \| CONSOLE_IN_EPNUM),
3969ec09	340	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	341	.EndpointSize = CONSOLE_EPSIZE,
3969ec09	342	.PollingIntervalMS = 0x01
	343	},
	344
a9a3610d	345	.Console_OUTEndpoint =
3969ec09	346	{
	347	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	348
3d81d522	349	.EndpointAddress = (ENDPOINT_DIR_OUT \| CONSOLE_OUT_EPNUM),
	350	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
	351	.EndpointSize = CONSOLE_EPSIZE,
	352	.PollingIntervalMS = 0x01
	353	},
	354
	355	/*
	356	* Extra
	357	*/
	358	.Extra_Interface =
	359	{
	360	.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
	361
	362	.InterfaceNumber = EXTRA_INTERFACE,
	363	.AlternateSetting = 0x00,
	364
	365	.TotalEndpoints = 1,
	366
	367	.Class = HID_CSCP_HIDClass,
	368	.SubClass = HID_CSCP_NonBootSubclass,
	369	.Protocol = HID_CSCP_NonBootProtocol,
	370
	371	.InterfaceStrIndex = NO_DESCRIPTOR
	372	},
	373
	374	.Extra_HID =
	375	{
	376	.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
	377
	378	.HIDSpec = VERSION_BCD(01.11),
	379	.CountryCode = 0x00,
	380	.TotalReportDescriptors = 1,
	381	.HIDReportType = HID_DTYPE_Report,
	382	.HIDReportLength = sizeof(ExtraReport)
	383	},
	384
	385	.Extra_INEndpoint =
	386	{
	387	.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
	388
	389	.EndpointAddress = (ENDPOINT_DIR_IN \| EXTRA_IN_EPNUM),
3969ec09	390	.Attributes = (EP_TYPE_INTERRUPT \| ENDPOINT_ATTR_NO_SYNC \| ENDPOINT_USAGE_DATA),
3d81d522	391	.EndpointSize = EXTRA_EPSIZE,
3969ec09	392	.PollingIntervalMS = 0x01
3d81d522	393	},
3969ec09	394	};
	395
	396
	397	/*******************************************************************************
	398	* String Descriptors
	399	******************************************************************************/
	400	const USB_Descriptor_String_t PROGMEM LanguageString =
	401	{
	402	.Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
	403
	404	.UnicodeString = {LANGUAGE_ID_ENG}
	405	};
	406
	407	const USB_Descriptor_String_t PROGMEM ManufacturerString =
	408	{
	409	.Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
	410
effa5914	411	.UnicodeString = LSTR(MANUFACTURER)
3969ec09	412	};
	413
	414	const USB_Descriptor_String_t PROGMEM ProductString =
	415	{
	416	.Header = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String},
	417
effa5914	418	.UnicodeString = LSTR(PRODUCT)
3969ec09	419	};
	420
	421
	422	/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
	423	* documentation) by the application code so that the address and size of a requested descriptor can be given
	424	* to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
	425	* is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
	426	* USB host.
	427	*/
	428	uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
	429	const uint8_t wIndex,
	430	const void** const DescriptorAddress)
	431	{
	432	const uint8_t DescriptorType = (wValue >> 8);
	433	const uint8_t DescriptorIndex = (wValue & 0xFF);
	434
	435	const void* Address = NULL;
	436	uint16_t Size = NO_DESCRIPTOR;
	437
	438	switch (DescriptorType)
	439	{
	440	case DTYPE_Device:
	441	Address = &DeviceDescriptor;
	442	Size = sizeof(USB_Descriptor_Device_t);
	443	break;
	444	case DTYPE_Configuration:
	445	Address = &ConfigurationDescriptor;
	446	Size = sizeof(USB_Descriptor_Configuration_t);
	447	break;
	448	case DTYPE_String:
	449	switch (DescriptorIndex )
	450	{
	451	case 0x00:
	452	Address = &LanguageString;
	453	Size = pgm_read_byte(&LanguageString.Header.Size);
	454	break;
	455	case 0x01:
	456	Address = &ManufacturerString;
	457	Size = pgm_read_byte(&ManufacturerString.Header.Size);
	458	break;
	459	case 0x02:
	460	Address = &ProductString;
	461	Size = pgm_read_byte(&ProductString.Header.Size);
	462	break;
	463	}
	464	break;
	465	case HID_DTYPE_HID:
	466	switch (wIndex) {
effa5914	467	case KEYBOARD_INTERFACE:
a9a3610d	468	Address = &ConfigurationDescriptor.Keyboard_HID;
3969ec09	469	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	470	break;
effa5914	471	case MOUSE_INTERFACE:
a9a3610d	472	Address = &ConfigurationDescriptor.Mouse_HID;
3969ec09	473	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	474	break;
3d81d522	475	case CONSOLE_INTERFACE:
a9a3610d	476	Address = &ConfigurationDescriptor.Console_HID;
3969ec09	477	Size = sizeof(USB_HID_Descriptor_HID_t);
3969ec09	478	break;
3d81d522	479	case EXTRA_INTERFACE:
	480	Address = &ConfigurationDescriptor.Extra_HID;
	481	Size = sizeof(USB_HID_Descriptor_HID_t);
	482	break;
3969ec09	483	}
	484	break;
	485	case HID_DTYPE_Report:
	486	switch (wIndex) {
effa5914	487	case KEYBOARD_INTERFACE:
3969ec09	488	Address = &KeyboardReport;
	489	Size = sizeof(KeyboardReport);
	490	break;
effa5914	491	case MOUSE_INTERFACE:
3969ec09	492	Address = &MouseReport;
	493	Size = sizeof(MouseReport);
	494	break;
3d81d522	495	case CONSOLE_INTERFACE:
a9a3610d	496	Address = &ConsoleReport;
a9a3610d	497	Size = sizeof(ConsoleReport);
3969ec09	498	break;
3d81d522	499	case EXTRA_INTERFACE:
	500	Address = &ExtraReport;
	501	Size = sizeof(ExtraReport);
	502	break;
3969ec09	503	}
	504	break;
	505	}
	506
	507	*DescriptorAddress = Address;
	508	return Size;
	509	}