comparison: sanguino/firmwares/arduino-usbdfu/Descriptors.c
sanguino/firmwares/arduino-usbdfu/Descriptors.c
- changeset 2
- b373b0288715
equal
deleted
inserted
replaced
| 1:b584642d4f58 | 2:b373b0288715 |
|---|---|
| 1 /* | |
| 2 LUFA Library | |
| 3 Copyright (C) Dean Camera, 2010. | |
| 4 | |
| 5 dean [at] fourwalledcubicle [dot] com | |
| 6 www.fourwalledcubicle.com | |
| 7 */ | |
| 8 | |
| 9 /* | |
| 10 Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com) | |
| 11 | |
| 12 Permission to use, copy, modify, distribute, and sell this | |
| 13 software and its documentation for any purpose is hereby granted | |
| 14 without fee, provided that the above copyright notice appear in | |
| 15 all copies and that both that the copyright notice and this | |
| 16 permission notice and warranty disclaimer appear in supporting | |
| 17 documentation, and that the name of the author not be used in | |
| 18 advertising or publicity pertaining to distribution of the | |
| 19 software without specific, written prior permission. | |
| 20 | |
| 21 The author disclaim all warranties with regard to this | |
| 22 software, including all implied warranties of merchantability | |
| 23 and fitness. In no event shall the author be liable for any | |
| 24 special, indirect or consequential damages or any damages | |
| 25 whatsoever resulting from loss of use, data or profits, whether | |
| 26 in an action of contract, negligence or other tortious action, | |
| 27 arising out of or in connection with the use or performance of | |
| 28 this software. | |
| 29 */ | |
| 30 | |
| 31 /** \file | |
| 32 * | |
| 33 * USB Device Descriptors, for library use when in USB device mode. Descriptors are special | |
| 34 * computer-readable structures which the host requests upon device enumeration, to determine | |
| 35 * the device's capabilities and functions. | |
| 36 */ | |
| 37 | |
| 38 #include "Descriptors.h" | |
| 39 | |
| 40 /** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall | |
| 41 * device characteristics, including the supported USB version, control endpoint size and the | |
| 42 * number of device configurations. The descriptor is read out by the USB host when the enumeration | |
| 43 * process begins. | |
| 44 */ | |
| 45 USB_Descriptor_Device_t DeviceDescriptor = | |
| 46 { | |
| 47 .Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device}, | |
| 48 | |
| 49 .USBSpecification = VERSION_BCD(01.10), | |
| 50 .Class = 0x00, | |
| 51 .SubClass = 0x00, | |
| 52 .Protocol = 0x00, | |
| 53 | |
| 54 .Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE, | |
| 55 | |
| 56 .VendorID = 0x03EB, // Atmel | |
| 57 .ProductID = PRODUCT_ID_CODE, // MCU-dependent | |
| 58 .ReleaseNumber = 0x0000, | |
| 59 | |
| 60 .ManufacturerStrIndex = NO_DESCRIPTOR, | |
| 61 .ProductStrIndex = 0x01, | |
| 62 .SerialNumStrIndex = NO_DESCRIPTOR, | |
| 63 | |
| 64 .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS | |
| 65 }; | |
| 66 | |
| 67 /** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage | |
| 68 * of the device in one of its supported configurations, including information about any device interfaces | |
| 69 * and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting | |
| 70 * a configuration so that the host may correctly communicate with the USB device. | |
| 71 */ | |
| 72 USB_Descriptor_Configuration_t ConfigurationDescriptor = | |
| 73 { | |
| 74 .Config = | |
| 75 { | |
| 76 .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration}, | |
| 77 | |
| 78 .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t), | |
| 79 .TotalInterfaces = 1, | |
| 80 | |
| 81 .ConfigurationNumber = 1, | |
| 82 .ConfigurationStrIndex = NO_DESCRIPTOR, | |
| 83 | |
| 84 .ConfigAttributes = USB_CONFIG_ATTR_BUSPOWERED, | |
| 85 | |
| 86 .MaxPowerConsumption = USB_CONFIG_POWER_MA(100) | |
| 87 }, | |
| 88 | |
| 89 .DFU_Interface = | |
| 90 { | |
| 91 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, | |
| 92 | |
| 93 .InterfaceNumber = 0, | |
| 94 .AlternateSetting = 0, | |
| 95 | |
| 96 .TotalEndpoints = 0, | |
| 97 | |
| 98 .Class = 0xFE, | |
| 99 .SubClass = 0x01, | |
| 100 .Protocol = 0x02, | |
| 101 | |
| 102 .InterfaceStrIndex = NO_DESCRIPTOR | |
| 103 }, | |
| 104 | |
| 105 .DFU_Functional = | |
| 106 { | |
| 107 .Header = {.Size = sizeof(USB_DFU_Functional_Descriptor_t), .Type = DTYPE_DFUFunctional}, | |
| 108 | |
| 109 .Attributes = (ATTR_CAN_UPLOAD | ATTR_CAN_DOWNLOAD), | |
| 110 | |
| 111 .DetachTimeout = 0x0000, | |
| 112 .TransferSize = 0x0c00, | |
| 113 | |
| 114 .DFUSpecification = VERSION_BCD(01.01) | |
| 115 } | |
| 116 }; | |
| 117 | |
| 118 /** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests | |
| 119 * the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate | |
| 120 * via the language ID table available at USB.org what languages the device supports for its string descriptors. | |
| 121 */ | |
| 122 USB_Descriptor_String_t LanguageString = | |
| 123 { | |
| 124 .Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String}, | |
| 125 | |
| 126 .UnicodeString = {LANGUAGE_ID_ENG} | |
| 127 }; | |
| 128 | |
| 129 /** Product descriptor string. This is a Unicode string containing the product's details in human readable form, | |
| 130 * and is read out upon request by the host when the appropriate string ID is requested, listed in the Device | |
| 131 * Descriptor. | |
| 132 */ | |
| 133 USB_Descriptor_String_t ProductString = | |
| 134 { | |
| 135 #if (ARDUINO_MODEL_PID == ARDUINO_UNO_PID) | |
| 136 .Header = {.Size = USB_STRING_LEN(15), .Type = DTYPE_String}, | |
| 137 | |
| 138 .UnicodeString = L"Arduino Uno DFU" | |
| 139 #elif (ARDUINO_MODEL_PID == ARDUINO_MEGA2560_PID) | |
| 140 .Header = {.Size = USB_STRING_LEN(21), .Type = DTYPE_String}, | |
| 141 | |
| 142 .UnicodeString = L"Arduino Mega 2560 DFU" | |
| 143 #endif | |
| 144 }; | |
| 145 | |
| 146 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors" | |
| 147 * documentation) by the application code so that the address and size of a requested descriptor can be given | |
| 148 * to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function | |
| 149 * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the | |
| 150 * USB host. | |
| 151 */ | |
| 152 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, | |
| 153 const uint8_t wIndex, | |
| 154 void** const DescriptorAddress) | |
| 155 { | |
| 156 const uint8_t DescriptorType = (wValue >> 8); | |
| 157 const uint8_t DescriptorNumber = (wValue & 0xFF); | |
| 158 | |
| 159 void* Address = NULL; | |
| 160 uint16_t Size = NO_DESCRIPTOR; | |
| 161 | |
| 162 switch (DescriptorType) | |
| 163 { | |
| 164 case DTYPE_Device: | |
| 165 Address = &DeviceDescriptor; | |
| 166 Size = sizeof(USB_Descriptor_Device_t); | |
| 167 break; | |
| 168 case DTYPE_Configuration: | |
| 169 Address = &ConfigurationDescriptor; | |
| 170 Size = sizeof(USB_Descriptor_Configuration_t); | |
| 171 break; | |
| 172 case DTYPE_String: | |
| 173 if (!(DescriptorNumber)) | |
| 174 { | |
| 175 Address = &LanguageString; | |
| 176 Size = LanguageString.Header.Size; | |
| 177 } | |
| 178 else | |
| 179 { | |
| 180 Address = &ProductString; | |
| 181 Size = ProductString.Header.Size; | |
| 182 } | |
| 183 | |
| 184 break; | |
| 185 } | |
| 186 | |
| 187 *DescriptorAddress = Address; | |
| 188 return Size; | |
| 189 } |
