/home/ron/Desktop/Downloads/project/QlightRead_hw/Descriptors.c

Go to the documentation of this file.

#include "Descriptors.h"

        USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
        {
                .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},

                .USBSpecification       = VERSION_BCD(02.00),
                .Class                  = CDC_CSCP_CDCClass,
                .SubClass               = CDC_CSCP_NoSpecificSubclass,
                .Protocol               = CDC_CSCP_NoSpecificProtocol,

                .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,

                .VendorID               = 0x03EB,
                .ProductID              = 0x0666,
                .ReleaseNumber          = VERSION_BCD(01.00),

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

                .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
        };

        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        = 1, //pamo war vorher 2

                                .ConfigurationNumber    = 1,
                                .ConfigurationStrIndex  = NO_DESCRIPTOR,

                                .ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),

                                .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
                        },

                .CDC_DCI_Interface =
                        {
                                .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

                                .InterfaceNumber        = 0,
                                .AlternateSetting       = 0,

                                .TotalEndpoints         = 2,

                                .Class                  = CDC_CSCP_CDCDataClass,
                                .SubClass               = CDC_CSCP_NoDataSubclass,
                                .Protocol               = CDC_CSCP_NoDataProtocol,

                                .InterfaceStrIndex      = NO_DESCRIPTOR
                        },

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

                                .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_OUT | DATAOUTEP),
                                .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
                                .EndpointSize           = DATAOUTSIZE,
                                .PollingIntervalMS      = 0x01
                        },

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

                                .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_IN | DATAINEP),
                                .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
                                .EndpointSize           = DATAINSIZE,
                                .PollingIntervalMS      = 0x01
                        }
        };

        USB_Descriptor_String_t PROGMEM LanguageString =
        {
                .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},

                .UnicodeString          = {LANGUAGE_ID_ENG}
        };

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

                .UnicodeString          = L"Ron Ablinger <trilog_studios@nerdshack.com> QlightRead Harware extension powered by Atmel®"
        };

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

                .UnicodeString          = L"QlightRead Hardware"
        };



        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  DescriptorNumber = (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 (DescriptorNumber)
                                {
                                        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;
                }

                *DescriptorAddress = Address;
                return Size;
        }