/* * This software is based on the LUFA library. Modifications of the * software are released under GPL but LUFA library itself is copyrigthed * by its creator Dean Camera. Refer to the license below on the usage of * LUFA library. * * Chris Boudacoff @ Olimex Ltd chris protonic co uk */ /* * LUFA Library Copyright (C) Dean Camera, 2015. * * dean [at] fourwalledcubicle [dot] com www.lufa-lib.org */ /* * Copyright 2015 Dean Camera (dean [at] fourwalledcubicle [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 disclaims 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. */ /** \file * * USB Device Descriptors, for library use when in USB device mode. Descriptors are special * computer-readable structures which the host requests upon device enumeration, to determine * the device's capabilities and functions. */ #include "Descriptors.h" /** HID class report descriptor. This is a special descriptor constructed with values from the * USBIF HID class specification to describe the reports and capabilities of the HID device. This * descriptor is parsed by the host and its contents used to determine what data (and in what encoding) * the device will send, and what it may be sent back from the host. Refer to the HID specification for * more details on HID report descriptors. * * This descriptor describes the mouse HID interface's report structure. */ const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] = { /* * Use the HID class driver's standard Mouse report. Min X/Y Axis * values: -1 Max X/Y Axis values: 1 Min physical X/Y Axis values * (used to determine resolution): -1 Max physical X/Y Axis values * (used to determine resolution): 1 Buttons: 3 Absolute screen * coordinates: false */ HID_DESCRIPTOR_WHEEL_MOUSE(-100, 100, -100, 100, 3, false) }; /** Same as the MouseReport structure, but defines the keyboard HID interface's report structure. */ const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] = { /* * Use the HID class driver's standard Keyboard report. Max * simultaneous keys: 6 */ HID_DESCRIPTOR_KEYBOARD(6) }; /** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall * device characteristics, including the supported USB version, control endpoint size and the * number of device configurations. The descriptor is read out by the USB host when the enumeration * process begins. */ const USB_Descriptor_Device_t PROGMEM DeviceDescriptor = { .Header = {.Size = sizeof(USB_Descriptor_Device_t),.Type = DTYPE_Device} , .USBSpecification = VERSION_BCD(1, 1, 0), .Class = USB_CSCP_NoDeviceClass, .SubClass = USB_CSCP_NoDeviceSubclass, .Protocol = USB_CSCP_NoDeviceProtocol, .Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE, .VendorID = 0x15ba, // Vendor: Olimex Ltd. .ProductID = 0x003c, .ReleaseNumber = VERSION_BCD(0, 0, 1), .ManufacturerStrIndex = STRING_ID_Manufacturer, .ProductStrIndex = STRING_ID_Product, .SerialNumStrIndex = USE_INTERNAL_SERIAL, .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS }; /** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage * of the device in one of its supported configurations, including information about any device interfaces * and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting * a configuration so that the host may correctly communicate with the USB device. */ 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 = 2, .ConfigurationNumber = 1, .ConfigurationStrIndex = NO_DESCRIPTOR, .ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_SELFPOWERED), .MaxPowerConsumption = USB_CONFIG_POWER_MA(100) } , .HID1_KeyboardInterface = { .Header = {.Size = sizeof (USB_Descriptor_Interface_t),. Type = DTYPE_Interface} , .InterfaceNumber = INTERFACE_ID_Keyboard, .AlternateSetting = 0x00, .TotalEndpoints = 1, .Class = HID_CSCP_HIDClass, .SubClass = HID_CSCP_BootSubclass, .Protocol = HID_CSCP_KeyboardBootProtocol, .InterfaceStrIndex = NO_DESCRIPTOR} , .HID1_KeyboardHID = { .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t),. Type = HID_DTYPE_HID} , .HIDSpec = VERSION_BCD(1, 1, 1), .CountryCode = 0x00, .TotalReportDescriptors = 1, .HIDReportType = HID_DTYPE_Report, .HIDReportLength = sizeof(KeyboardReport) } , .HID1_ReportINEndpoint = { .Header = {.Size = sizeof (USB_Descriptor_Endpoint_t),. Type = DTYPE_Endpoint} , .EndpointAddress = KEYBOARD_IN_EPADDR, .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = HID_EPSIZE, .PollingIntervalMS = 0x05} , .HID2_MouseInterface = { .Header = {.Size = sizeof(USB_Descriptor_Interface_t),. Type = DTYPE_Interface} , .InterfaceNumber = INTERFACE_ID_Mouse, .AlternateSetting = 0x00, .TotalEndpoints = 1, .Class = HID_CSCP_HIDClass, .SubClass = HID_CSCP_BootSubclass, .Protocol = HID_CSCP_MouseBootProtocol, .InterfaceStrIndex = NO_DESCRIPTOR} , .HID2_MouseHID = { .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t),.Type = HID_DTYPE_HID} , .HIDSpec = VERSION_BCD(1, 1, 1), .CountryCode = 0x00, .TotalReportDescriptors = 1, .HIDReportType = HID_DTYPE_Report, .HIDReportLength = sizeof(MouseReport) } , .HID2_ReportINEndpoint = { .Header = {.Size = sizeof (USB_Descriptor_Endpoint_t),. Type = DTYPE_Endpoint} , .EndpointAddress = MOUSE_IN_EPADDR, .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = HID_EPSIZE, .PollingIntervalMS = 0x05} }; /** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests * the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate * via the language ID table available at USB.org what languages the device supports for its string descriptors. */ const USB_Descriptor_String_t PROGMEM LanguageString = USB_STRING_DESCRIPTOR_ARRAY(LANGUAGE_ID_ENG); /** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable * form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device * Descriptor. */ const USB_Descriptor_String_t PROGMEM ManufacturerString = USB_STRING_DESCRIPTOR(L"Olimex Ltd."); /** Product descriptor string. This is a Unicode string containing the product's details in human readable form, * and is read out upon request by the host when the appropriate string ID is requested, listed in the Device * Descriptor. */ const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"TERES Keyboard+Touchpad"); /** 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 uint16_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 STRING_ID_Language: Address = &LanguageString; Size = pgm_read_byte(&LanguageString.Header.Size); break; case STRING_ID_Manufacturer: Address = &ManufacturerString; Size = pgm_read_byte(&ManufacturerString.Header.Size); break; case STRING_ID_Product: Address = &ProductString; Size = pgm_read_byte(&ProductString.Header.Size); break; } break; case HID_DTYPE_HID: switch (wIndex) { case INTERFACE_ID_Keyboard: Address = &ConfigurationDescriptor.HID1_KeyboardHID; Size = sizeof(USB_HID_Descriptor_HID_t); break; case INTERFACE_ID_Mouse: Address = &ConfigurationDescriptor.HID2_MouseHID; Size = sizeof(USB_HID_Descriptor_HID_t); break; } break; case HID_DTYPE_Report: switch (wIndex) { case INTERFACE_ID_Keyboard: Address = &KeyboardReport; Size = sizeof(KeyboardReport); break; case INTERFACE_ID_Mouse: Address = &MouseReport; Size = sizeof(MouseReport); break; } break; } *DescriptorAddress = Address; return Size; }