root / arduino-1.0 / hardware / arduino / firmwares / arduino-usbdfu / Descriptors.c @ 58d82c77
History | View | Annotate | Download (6.7 KB)
1 | 58d82c77 | Tom Mullins | /*
|
---|---|---|---|
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 | } |