Fix compile and Doxygen errors due to the spell-check changes in the source code.

[pub/USBasp.git] / Projects / AVRISP-MKII / Descriptors.c

diff --git a/Projects/AVRISP-MKII/Descriptors.c b/Projects/AVRISP-MKII/Descriptors.c
index a2765d3..a57ad06 100644 (file)
--- a/Projects/AVRISP-MKII/Descriptors.c
+++ b/Projects/AVRISP-MKII/Descriptors.c
@@ -1,216 +1,219 @@
-/*\r
-             LUFA Library\r
-     Copyright (C) Dean Camera, 2009.\r
-              \r
-  dean [at] fourwalledcubicle [dot] com\r
-      www.fourwalledcubicle.com\r
-*/\r
-\r
-/*\r
-  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
-\r
-  Permission to use, copy, modify, and distribute this software\r
-  and its documentation for any purpose and without fee is hereby\r
-  granted, provided that the above copyright notice appear in all\r
-  copies and that both that the copyright notice and this\r
-  permission notice and warranty disclaimer appear in supporting\r
-  documentation, and that the name of the author not be used in\r
-  advertising or publicity pertaining to distribution of the\r
-  software without specific, written prior permission.\r
-\r
-  The author disclaim all warranties with regard to this\r
-  software, including all implied warranties of merchantability\r
-  and fitness.  In no event shall the author be liable for any\r
-  special, indirect or consequential damages or any damages\r
-  whatsoever resulting from loss of use, data or profits, whether\r
-  in an action of contract, negligence or other tortious action,\r
-  arising out of or in connection with the use or performance of\r
-  this software.\r
-*/\r
-\r
-/** \file\r
- *\r
- *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special \r
- *  computer-readable structures which the host requests upon device enumeration, to determine\r
- *  the device's capabilities and functions.  \r
- */\r
-\r
-#include "Descriptors.h"\r
-\r
-/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall\r
- *  device characteristics, including the supported USB version, control endpoint size and the\r
- *  number of device configurations. The descriptor is read out by the USB host when the enumeration\r
- *  process begins.\r
- */\r
-USB_Descriptor_Device_t PROGMEM DeviceDescriptor =\r
-{\r
-       .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},\r
-               \r
-       .USBSpecification       = VERSION_BCD(01.10),\r
-       .Class                  = 0xFF,\r
-       .SubClass               = 0x00,\r
-       .Protocol               = 0x00,\r
-                               \r
-       .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,\r
-               \r
-       .VendorID               = 0x03EB,\r
-       .ProductID              = 0x2104,\r
-       .ReleaseNumber          = VERSION_BCD(02.00),\r
-               \r
-       .ManufacturerStrIndex   = 0x01,\r
-       .ProductStrIndex        = 0x02,\r
-       .SerialNumStrIndex      = 0x03,\r
-               \r
-       .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS\r
-};\r
-\r
-/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage\r
- *  of the device in one of its supported configurations, including information about any device interfaces\r
- *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting\r
- *  a configuration so that the host may correctly communicate with the USB device.\r
- */\r
-USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =\r
-{\r
-       .Config = \r
-               {\r
-                       .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},\r
-\r
-                       .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),\r
-                       .TotalInterfaces        = 1,\r
-                               \r
-                       .ConfigurationNumber    = 1,\r
-                       .ConfigurationStrIndex  = NO_DESCRIPTOR,\r
-                               \r
-                       .ConfigAttributes       = USB_CONFIG_ATTR_SELFPOWERED,\r
-                       \r
-                       .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)\r
-               },\r
-\r
-       .AVRISPInterface = \r
-               {\r
-                       .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},\r
-\r
-                       .InterfaceNumber        = 0,\r
-                       .AlternateSetting       = 0,\r
-                       \r
-                       .TotalEndpoints         = 2,\r
-                               \r
-                       .Class                  = 0xFF,\r
-                       .SubClass               = 0x00,\r
-                       .Protocol               = 0x00,\r
-                               \r
-                       .InterfaceStrIndex      = NO_DESCRIPTOR\r
-               },\r
-\r
-       .DataInEndpoint = \r
-               {\r
-                       .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},\r
-                       \r
-                       .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_IN | AVRISP_DATA_EPNUM),\r
-                       .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),\r
-                       .EndpointSize           = AVRISP_DATA_EPSIZE,\r
-                       .PollingIntervalMS      = 0x00\r
-               },\r
-
-       .DataOutEndpoint =\r
-               {\r
-                       .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},\r
-                       \r
-                       .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_OUT | AVRISP_DATA_EPNUM),\r
-                       .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),\r
-                       .EndpointSize           = AVRISP_DATA_EPSIZE,\r
-                       .PollingIntervalMS      = 0x00\r
+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  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 disclaim 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"
+
+/** 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.
+ */
+USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
+{
+       .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
+               
+       .USBSpecification       = VERSION_BCD(01.10),
+       .Class                  = 0xFF,
+       .SubClass               = 0x00,
+       .Protocol               = 0x00,
+                               
+       .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
+               
+       .VendorID               = 0x03EB,
+       .ProductID              = 0x2104,
+       .ReleaseNumber          = VERSION_BCD(02.00),
+               
+       .ManufacturerStrIndex   = 0x01,
+       .ProductStrIndex        = 0x02,
+       .SerialNumStrIndex      = 0x03,
+               
+       .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.
+ */
+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,
+                               
+                       .ConfigurationNumber    = 1,
+                       .ConfigurationStrIndex  = NO_DESCRIPTOR,
+                               
+                       .ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
+                       
+                       .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
+               },
+
+       .AVRISP_Interface = 
+               {
+                       .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+                       .InterfaceNumber        = 0,
+                       .AlternateSetting       = 0,
+                       
+                       .TotalEndpoints         = 2,
+                               
+                       .Class                  = 0xFF,
+                       .SubClass               = 0x00,
+                       .Protocol               = 0x00,
+                               
+                       .InterfaceStrIndex      = NO_DESCRIPTOR

                },
                },

-};\r
-\r
-/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests\r
- *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate\r
- *  via the language ID table available at USB.org what languages the device supports for its string descriptors.\r
- */\r
-USB_Descriptor_String_t PROGMEM LanguageString =\r
-{\r
-       .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},\r
-               \r
-       .UnicodeString          = {LANGUAGE_ID_ENG}\r
-};\r
-\r
-/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable\r
- *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device\r
- *  Descriptor.\r
- */\r
-USB_Descriptor_String_t PROGMEM ManufacturerString =\r
-{\r
-       .Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},\r
-               \r
-       .UnicodeString          = L"Dean Camera"\r
-};\r
-\r
-/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,\r
- *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device\r
- *  Descriptor.\r
- */\r
-USB_Descriptor_String_t PROGMEM ProductString =\r
-{\r
-       .Header                 = {.Size = USB_STRING_LEN(33), .Type = DTYPE_String},\r
-               \r
-       .UnicodeString          = L"LUFA AVRISP MkII Clone Programmer"\r
-};\r
-\r
-USB_Descriptor_String_t PROGMEM SerialString =\r
-{\r
-       .Header                 = {.Size = USB_STRING_LEN(13), .Type = DTYPE_String},\r
-               \r
-       .UnicodeString          = L"0000A00128255"\r
-};\r
-\r
-/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"\r
- *  documentation) by the application code so that the address and size of a requested descriptor can be given\r
- *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function\r
- *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the\r
- *  USB host.\r
- */\r
-uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)\r
-{\r
-       const uint8_t  DescriptorType   = (wValue >> 8);\r
-       const uint8_t  DescriptorNumber = (wValue & 0xFF);\r
-\r
-       void*    Address = NULL;\r
-       uint16_t Size    = NO_DESCRIPTOR;\r
-       \r
-       switch (DescriptorType)\r
-       {\r
-               case DTYPE_Device: \r
-                       Address = (void*)&DeviceDescriptor;\r
-                       Size    = sizeof(USB_Descriptor_Device_t);\r
-                       break;\r
-               case DTYPE_Configuration: \r
-                       Address = (void*)&ConfigurationDescriptor;\r
-                       Size    = sizeof(USB_Descriptor_Configuration_t);\r
-                       break;\r
-               case DTYPE_String: \r
-                       switch (DescriptorNumber)\r
-                       {\r
-                               case 0x00: \r
-                                       Address = (void*)&LanguageString;\r
-                                       Size    = pgm_read_byte(&LanguageString.Header.Size);\r
-                                       break;\r
-                               case 0x01: \r
-                                       Address = (void*)&ManufacturerString;\r
-                                       Size    = pgm_read_byte(&ManufacturerString.Header.Size);\r
-                                       break;\r
-                               case 0x02: \r
-                                       Address = (void*)&ProductString;\r
-                                       Size    = pgm_read_byte(&ProductString.Header.Size);\r
-                                       break;\r
-                               case 0x03:\r
-                                       Address = (void*)&SerialString;\r
-                                       Size    = pgm_read_byte(&SerialString.Header.Size);\r
-                                       break;                                  \r
-                       }\r
-                       \r
-                       break;\r
-       }\r
-       \r
-       *DescriptorAddress = Address;\r
-       return Size;\r
-}\r
+
+       .AVRISP_DataInEndpoint = 
+               {
+                       .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+                       
+                       .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_IN | AVRISP_DATA_IN_EPNUM),
+                       .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+                       .EndpointSize           = AVRISP_DATA_EPSIZE,
+                       .PollingIntervalMS      = 0x00
+               },
+
+       .AVRISP_DataOutEndpoint =
+               {
+                       .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+                       
+                       .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_OUT | AVRISP_DATA_OUT_EPNUM),
+                       .Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+                       .EndpointSize           = AVRISP_DATA_EPSIZE,
+                       .PollingIntervalMS      = 0x00
+               },
+};
+
+/** 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.
+ */
+USB_Descriptor_String_t PROGMEM LanguageString =
+{
+       .Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
+               
+       .UnicodeString          = {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.
+ */
+USB_Descriptor_String_t PROGMEM ManufacturerString =
+{
+       .Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
+               
+       .UnicodeString          = L"Dean Camera"
+};
+
+/** 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.
+ */
+USB_Descriptor_String_t PROGMEM ProductString =
+{
+       .Header                 = {.Size = USB_STRING_LEN(22), .Type = DTYPE_String},
+               
+       .UnicodeString          = L"LUFA AVRISP MkII Clone"
+};
+
+/** Serial number string. This is a Unicode string containing the device's unique serial number, expressed as a
+ *  series of uppercase hexadecimal digits.
+ */
+USB_Descriptor_String_t PROGMEM SerialString =
+{
+       .Header                 = {.Size = USB_STRING_LEN(13), .Type = DTYPE_String},
+               
+       .UnicodeString          = L"0000A00128255"
+};
+
+/** 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 uint8_t wIndex, void** const DescriptorAddress)
+{
+       const uint8_t  DescriptorType   = (wValue >> 8);
+       const uint8_t  DescriptorNumber = (wValue & 0xFF);
+
+       void*    Address = NULL;
+       uint16_t Size    = NO_DESCRIPTOR;
+       
+       switch (DescriptorType)
+       {
+               case DTYPE_Device: 
+                       Address = (void*)&DeviceDescriptor;
+                       Size    = sizeof(USB_Descriptor_Device_t);
+                       break;
+               case DTYPE_Configuration: 
+                       Address = (void*)&ConfigurationDescriptor;
+                       Size    = sizeof(USB_Descriptor_Configuration_t);
+                       break;
+               case DTYPE_String: 
+                       switch (DescriptorNumber)
+                       {
+                               case 0x00: 
+                                       Address = (void*)&LanguageString;
+                                       Size    = pgm_read_byte(&LanguageString.Header.Size);
+                                       break;
+                               case 0x01: 
+                                       Address = (void*)&ManufacturerString;
+                                       Size    = pgm_read_byte(&ManufacturerString.Header.Size);
+                                       break;
+                               case 0x02: 
+                                       Address = (void*)&ProductString;
+                                       Size    = pgm_read_byte(&ProductString.Header.Size);
+                                       break;
+                               case 0x03:
+                                       Address = (void*)&SerialString;
+                                       Size    = pgm_read_byte(&SerialString.Header.Size);
+                                       break;                                  
+                       }
+                       
+                       break;
+       }
+       
+       *DescriptorAddress = Address;
+       return Size;
+}