source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/arduino/avr/firmwares/atmegaxxu2/arduino-usbdfu/Descriptors.c @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 6.7 KB
Line 
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 */
45USB_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 */
72USB_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 */ 
122USB_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 */
133USB_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 */
152uint16_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}
Note: See TracBrowser for help on using the repository browser.