Removed "Host_" section of the function names in ConfigDescriptor.h, as most of the routines can now be used in device mode on the device descriptor.

Renamed functions in the HID parser to have a "USB_" prefix and the acronym "HID" in the name.

Further module-level documentation updates.

7 files changed, 150 insertions, 139 deletions

diff --git a/LUFA/ChangeLog.txt b/LUFA/ChangeLog.txt
index e504c39a6..7e23243a4 100644
--- a/LUFA/ChangeLog.txt
+++ b/LUFA/ChangeLog.txt
@@ -49,6 +49,9 @@
   *  - Removed the ButtLoadTag.h header file, as no one used for its intended purpose anyway

   *  - Renamed the main Drivers/AT90USBXXX directory to Drivers/Peripheral, renamed the Serial_Stream driver to SerialStream

   *  - Fixed CDC and USBtoSerial demos freezing where buffers were full while still transmitting or receiving (thanks to Peter Hand)

+  *  - Removed "Host_" section of the function names in ConfigDescriptor.h, as most of the routines can now be used in device mode on the

+  *    device descriptor

+  *  - Renamed functions in the HID parser to have a "USB_" prefix and the acronym "HID" in the name

   *    

   *

   *  \section Sec_ChangeLog090401 Version 090401

diff --git a/LUFA/CompileTimeTokens.txt b/LUFA/CompileTimeTokens.txt
index 53cf9e41e..371c2c790 100644
--- a/LUFA/CompileTimeTokens.txt
+++ b/LUFA/CompileTimeTokens.txt
@@ -14,21 +14,21 @@
  *  \section Sec_SummaryNonUSBTokens Non USB Related Tokens

  *  This section describes compile tokens which affect non-USB sections of the LUFA library.

  *

- *  <b>DISABLE_TERMINAL_CODES</b> - TerminalCodes.h \n

+ *  <b>DISABLE_TERMINAL_CODES</b> - ( \ref Group_Terminal ) \n

  *  If an application contains ANSI terminal control codes listed in TerminalCodes.h, it might be desired to remove them

  *  at compile time for use with a terminal which is non-ANSI control code aware, without modifying the source code. If

  *  this token is defined, all ANSI control codes in the application code from the TerminalCodes.h header are removed from

  *  the source code at compile time.

  *

- *  <b>NUM_BLOCKS</b> - DynAlloc.h \n

+ *  <b>NUM_BLOCKS</b> - ( \ref Group_MemoryAllocator ) \n

  *  Sets the number of allocable blocks in the psudo-heap of the dynamic memory allocation driver. This should be

  *  defined as a constant larger than zero.

  *

- *  <b>BLOCK_SIZE</b> - DynAlloc.h \n

+ *  <b>BLOCK_SIZE</b> - ( \ref Group_MemoryAllocator ) \n

  *  Sets the size of each allocable block in the psudo-heap of the dynamic memory allocation driver. This should be

  *  defined as a constant larger than zero.

  *

- *  <b>NUM_HANDLES</b> - DynAlloc.h \n

+ *  <b>NUM_HANDLES</b> - ( \ref Group_MemoryAllocator ) \n

  *  Sets the maximum number of managed memory handles which can be handed out by the dynamic memory allocation driver

  *  simultaneously, before a handle (and its associated allocated memory) must be freed.

  *

@@ -36,38 +36,38 @@
  *  \section Sec_SummaryUSBClassTokens USB Class Driver Related Tokens

  *  This section describes compile tokens which affect USB class-specific drivers in the LUFA library.

  *

- *  <b>HID_ENABLE_FEATURE_PROCESSING</b> - HIDParser.h \n

+ *  <b>HID_ENABLE_FEATURE_PROCESSING</b> - ( \ref Group_HIDParser ) \n

  *  Define this token to enable the processing of FEATURE HID report items, if any, into the processed HID structure.

  *  By default FEATURE items (which are device features settable by the host but not directly visible by the user) are

  *  skipped when processing a device HID report.

  *

- *  <b>HID_INCLUDE_CONSTANT_DATA_ITEMS</b> - HIDParser.h \n

+ *  <b>HID_INCLUDE_CONSTANT_DATA_ITEMS</b> - ( \ref Group_HIDParser ) \n

  *  By default, constant data items (usually used as spacers to align seperate report items to a byte or word boundary)

  *  in the HID report are skipped during report processing. It is highly unusual for an application to make any use of

  *  constant data items (as they do not carry any useful data and only occupy limited RAM) however if required defining

  *  this switch will put constant data items into the processed HID report structure.

  *

- *  <b>HID_STATETABLE_STACK_DEPTH</b> - HIDParser.h \n

+ *  <b>HID_STATETABLE_STACK_DEPTH</b> - ( \ref Group_HIDParser ) \n

  *  HID reports may contain PUSH and POP elements, to store and retrieve the current HID state table onto a stack. This

  *  allows for reports to save the state table before modifying it slightly for a data item, and then restore the previous

  *  state table in a compact manner. This token may be defined to a non-zero value to give the maximum depth of the state

  *  table stack. If not defined, this defaults to the value indicated in the HID.h file documentation.

  *

- *  <b>HID_USAGE_STACK_DEPTH</b> - HIDParser.h \n

+ *  <b>HID_USAGE_STACK_DEPTH</b> - ( \ref Group_HIDParser ) \n

  *  HID reports generally contain many USAGE elements, which are assigned to INPUT, OUTPUT and FEATURE items in succession

  *  when multiple items are defined at once (via REPORT COUNT elements). This allows for several items to be defined with

  *  different usages in a compact manner. This token may be defined to a non-zero value to set the maximum depth of the

  *  usage stack, indicating the maximum number of USAGE items which can be stored tempoarily until the next INPUT, OUTPUT

  *  and FEATURE item. If not defined, this defaults to the value indicated in the HID.h file documentation.

  *

- *  <b>HID_MAX_COLLECTIONS</b> - HIDParser.h \n

+ *  <b>HID_MAX_COLLECTIONS</b> - ( \ref Group_HIDParser ) \n

  *  HID reports generally contain several COLLECTION elements, used to group related data items together. Collection information

  *  is stored seperately in the processed usage structure (and referred to by the data elements in the structure) to save space.

  *  This token may be defined to a non-zero value to set the maximum number of COLLECTION items which can be processed by the

  *  parser into the resultant processed report structure. If not defined, this defaults to the value indicated in the HID.h file

  *  documentation.

  *

- *  <b>HID_MAX_REPORTITEMS</b> - HIDParser.h \n

+ *  <b>HID_MAX_REPORTITEMS</b> - ( \ref Group_HIDParser ) \n

  *  All HID reports contain one or more INPUT, OUTPUT and/or FEATURE items describing the data which can be sent to and from the HID

  *  device. Each item has associated usages, bit offsets in the item reports and other associated data indicating the manner in which

  *  the report data should be interpreted by the host. This token may be defined to a non-zero value to set the maximum number of

@@ -79,28 +79,28 @@
  *  \section Sec_SummaryUSBTokens USB Driver Related Tokens

  *  This section describes compile tokens which affect USB driver stack as a whole in the LUFA library.

  *

- *  <b>USE_RAM_DESCRIPTORS</b> - StdDescriptors.h \n

+ *  <b>USE_RAM_DESCRIPTORS</b> - ( \ref Group_Descriptors ) \n

  *  Define this token to indicate to the USB driver that device descriptors are stored in RAM, rather than the default of

  *  the AVR's flash. RAM descriptors may be desirable in applications where speed or minimizing flash usage is more important

  *  than RAM usage, or applications where the descriptors need to be modified at runtime.

  *

- *  <b>USE_EEPROM_DESCRIPTORS</b> - StdDescriptors.h \n

+ *  <b>USE_EEPROM_DESCRIPTORS</b> - ( \ref Group_Descriptors ) \n

  *  Similar to USE_RAM_DESCRIPTORS, but descriptors are stored in the AVR's EEPROM memory rather than RAM.

  *

- *  <b>USE_NONSTANDARD_DESCRIPTOR_NAMES</b> - StdDescriptors.h \n

+ *  <b>USE_NONSTANDARD_DESCRIPTOR_NAMES</b> - ( \ref Group_Descriptors ) \n

  *  The USB 2.0 standard gives some rather obscure names for the elements in the standard descriptor types (device, configuration,

  *  string, endpoint, etc.). By default the LUFA library uses these names in its predefined descriptor structure types for

  *  compatibility. If this token is defined, the structure element names are switched to the LUFA-specific but more descriptive

  *  names documented in the StdDescriptors.h source file.

  *

- *  <b>FIXED_CONTROL_ENDPOINT_SIZE</b> - Endpoint.h \n

+ *  <b>FIXED_CONTROL_ENDPOINT_SIZE</b> - ( \ref Group_EndpointManagement ) \n

  *  By default, the library determines the size of the control endpoint (when in device mode) by reading the device descriptor.

  *  Normally this reduces the amount of configuration required for the library, allows the value to change dynamically (if

  *  descriptors are stored in EEPROM or RAM rather than flash memory) and reduces code maintenance. However, this token can be

  *  defined to a non-zero value instead to give the size in bytes of the control endpoint, to reduce the size of the compiled

  *  binary at the expense of flexibility.

  *

- *  <b>STATIC_ENDPOINT_CONFIGURATION</b> - Endpoint.h \n

+ *  <b>STATIC_ENDPOINT_CONFIGURATION</b> - ( \ref Group_EndpointManagement ) \n

  *  By default, the endpoint configuration routine is designed to accept dynamic inputs, so that the endpoints can be configured

  *  using variable values known only at runtime. This allows for a great deal of flexibility, however uses a small amount of binary

  *  space which may be wasted if all endpoint configurations are static and known at compile time. Define this token via the -D switch

@@ -108,18 +108,18 @@
  *  flexibility. Note that with this option dynamic values may still be used, but will result in many times more code to be generated than

  *  if the option was disabled. This is designed to be used only if the FIXED_CONTROL_ENDPOINT_SIZE option is also used.

  *

- *  <b>USE_SINGLE_DEVICE_CONFIGURATION</b> - DevChapter9.h \n

+ *  <b>USE_SINGLE_DEVICE_CONFIGURATION</b> - ( \ref Group_Device ) \n

  *  By default, the library determines the number of configurations a USB device supports by reading the device descriptor. This reduces

  *  the amount of configuration required to set up the library, and allows the value to change dynamically (if descriptors are stored in

  *  EEPROM or RAM rather than flash memory) and reduces code maintenance. However, many USB device projects use only a single configuration.

  *  Defining this token enables single-configuration mode, reducing the compiled size of the binary at the expense of flexibility.

  *

- *  <b>FEATURELESS_CONTROL_ONLY_DEVICE</b> - DevChapter9.h \n

+ *  <b>FEATURELESS_CONTROL_ONLY_DEVICE</b> \n

  *  In some limited USB device applications, device features (other than self-power) and endpoints other than the control endpoint aren't

  *  used. In such limited situations, this token may be defined to remove the handling of the Set Feature Chapter 9 request entirely and

- *  parts of the Get Feature chapter 9 request to save space. Generally, this is usually only useful in (some) bootloaders.

+ *  parts of the Get Feature chapter 9 request to save space. Generally, this is usually only useful in (some) bootloaders and is best avoided.

  *

- *  <b>NO_STREAM_CALLBACKS</b> - Endpoint.h, Pipe.h \n

+ *  <b>NO_STREAM_CALLBACKS</b> - ( \ref Group_EndpointPacketManagement , \ref Group_PipePacketManagement )\n

  *  Both the endpoint and the pipe driver code contains stream functions, allowing for arrays of data to be sent to or from the

  *  host easily via a single function call (rather than complex routines worrying about sending full packets, waiting for the endpoint/

  *  pipe to become ready, etc.). By default, these stream functions require a callback function which is executed after each byte processed,

@@ -127,39 +127,39 @@
  *  by defining this token, reducing the compiled binary size. When removed, the stream functions no longer accept a callback function as

  *  a parameter.

  *

- *  <b>USB_HOST_TIMEOUT_MS</b> - Host.h \n

+ *  <b>USB_HOST_TIMEOUT_MS</b> - ( \ref Group_Host ) \n

  *  When a control transfer is initiated in host mode to an attached device, a timeout is used to abort the transfer if the attached

  *  device fails to respond within the timeout period. This token may be defined to a non-zero value to set the timeout period for

  *  control transfers, specified in milliseconds. If not defined, the default value specified in Host.h is used instead.

  *

- *  <b>HOST_DEVICE_SETTLE_DELAY_MS</b> - Host.h \n

+ *  <b>HOST_DEVICE_SETTLE_DELAY_MS</b> - ( \ref Group_Host ) \n

  *  Some devices require a delay of up to 5 seconds after they are connected to VBUS before the enumeration process can be started, or

  *  they will fail to enumerate correctly. By placing a delay before the enumeration process, it can be ensured that the bus has settled

  *  back to a known idle state before communications occur with the device. This token may be defined to a non-zero value to set the

  *  device settle period, specified in milliseconds. If not defined, the default value specified in Host.h is used instead.

  *

- *  <b>USE_STATIC_OPTIONS</b> - LowLevel.h \n

+ *  <b>USE_STATIC_OPTIONS</b> - ( \ref Group_USBManagement ) \n

  *  By default, the USB_Init() function accepts dynamic options at runtime to alter the library behaviour, including whether the USB pad

  *  voltage regulator is enabled, and the device speed when in device mode. By defining this token to a mask comprised of the USB options

  *  mask defines usually passed as the Options parameter to USB_Init(), the resulting compiled binary can be decreased in size by removing

  *  the dynamic options code, and replacing it with the statically set options. When defined, the USB_Init() function no longer accepts an

  *  Options parameter.

  *

- *  <b>USB_DEVICE_ONLY</b> - LowLevel.h \n

+ *  <b>USB_DEVICE_ONLY</b> - ( \ref Group_USBManagement ) \n

  *  For the USB AVR models supporting both device and host USB modes, the USB_Init() function contains a Mode parameter which specifies the

  *  mode the library should be initialized to. If only device mode is required, the code for USB host mode can be removed from the binary to

  *  save space. When defined, the USB_Init() function no longer accepts a Mode parameter. This define is irrelevent on smaller USB AVRs which

  *  do not support host mode.

  *

- *  <b>USB_HOST_ONLY</b> - LowLevel.h \n

+ *  <b>USB_HOST_ONLY</b> - ( \ref Group_USBManagement ) \n

  *  Same as USB_DEVICE_ONLY, except the library is fixed to USB host mode rather than USB device mode. Not available on some USB AVR models.

  *

- *  <b>USB_STREAM_TIMEOUT_MS</b> - LowLevel.h \n

+ *  <b>USB_STREAM_TIMEOUT_MS</b> - ( \ref Group_USBManagement ) \n

  *  When endpoint and/or pipe stream functions are used, by default there is a timeout between each transfer which the connected device or host

  *  must satisfy, or the stream function aborts the remaining data transfer. This token may be defined to a non-zero value to set the timeout

  *  period for stream transfers, specified in milliseconds. If not defined, the default value specified in LowLevel.h is used instead.

  *

- *  <b>NO_LIMITED_CONTROLLER_CONNECT</b> - Events.h \n

+ *  <b>NO_LIMITED_CONTROLLER_CONNECT</b> - ( \ref Group_Events ) \n

  *  On the smaller USB AVRs, the USB controller lacks VBUS events to determine the physical connection state of the USB bus to a host. In lieu of

  *  VBUS events, the library attempts to determine the connection state via the bus suspension and wake up events instead. This however may be

  *  slightly inaccurate due to the possibility of the host suspending the bus while the device is still connected. If accurate connection status is

diff --git a/LUFA/Drivers/USB/Class/ConfigDescriptor.c b/LUFA/Drivers/USB/Class/ConfigDescriptor.c
index ecd58791c..61a5c445c 100644
--- a/LUFA/Drivers/USB/Class/ConfigDescriptor.c
+++ b/LUFA/Drivers/USB/Class/ConfigDescriptor.c
@@ -28,13 +28,10 @@
   this software.

 */

 

-#include "../HighLevel/USBMode.h"

-

-#if defined(USB_CAN_BE_HOST)

-

 #include "ConfigDescriptor.h"

 

-uint8_t USB_Host_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* BufferPtr)

+#if defined(USB_CAN_BE_HOST)

+uint8_t USB_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* BufferPtr)

 {

 	uint8_t ErrorCode;

 

@@ -70,28 +67,29 @@ uint8_t USB_Host_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void*
 

 	return ErrorCode;

 }

+#endif

 

-void USB_Host_GetNextDescriptorOfType(uint16_t* const BytesRem,

-                                      uint8_t** const CurrConfigLoc,

-                                      const uint8_t Type)

+void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,

+                                 uint8_t** const CurrConfigLoc,

+                                 const uint8_t Type)

 {

 	while (*BytesRem)

 	{

-		USB_Host_GetNextDescriptor(BytesRem, CurrConfigLoc);	  

+		USB_GetNextDescriptor(BytesRem, CurrConfigLoc);	  

 

 		if (DESCRIPTOR_TYPE(*CurrConfigLoc) == Type)

 		  return;

 	}

 }

 

-void USB_Host_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,

-                                            uint8_t** const CurrConfigLoc,

-                                            const uint8_t Type,

-                                            const uint8_t BeforeType)

+void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,

+                                       uint8_t** const CurrConfigLoc,

+                                       const uint8_t Type,

+                                       const uint8_t BeforeType)

 {

 	while (*BytesRem)

 	{

-		USB_Host_GetNextDescriptor(BytesRem, CurrConfigLoc);

+		USB_GetNextDescriptor(BytesRem, CurrConfigLoc);

 

 		if (DESCRIPTOR_TYPE(*CurrConfigLoc) == Type)

 		{

@@ -105,19 +103,18 @@ void USB_Host_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,
 	}

 }

 

-void USB_Host_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,

-                                           uint8_t** const CurrConfigLoc,

-                                           const uint8_t Type,

-                                           const uint8_t AfterType)

+void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,

+                                      uint8_t** const CurrConfigLoc,

+                                      const uint8_t Type,

+                                      const uint8_t AfterType)

 {

-	USB_Host_GetNextDescriptorOfType(BytesRem, CurrConfigLoc, AfterType);

+	USB_GetNextDescriptorOfType(BytesRem, CurrConfigLoc, AfterType);

 	

 	if (*BytesRem)

-	  USB_Host_GetNextDescriptorOfType(BytesRem, CurrConfigLoc, Type);

+	  USB_GetNextDescriptorOfType(BytesRem, CurrConfigLoc, Type);

 }

 			

-uint8_t USB_Host_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfigLoc,

-                                         uint8_t (* const ComparatorRoutine)(void*))

+uint8_t USB_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfigLoc, ComparatorPtr_t ComparatorRoutine)

 {

 	uint8_t ErrorCode;

 		

@@ -126,7 +123,7 @@ uint8_t USB_Host_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfi
 		uint8_t*  PrevDescLoc = *CurrConfigLoc;

 		uint16_t  PrevBytesRem = *BytesRem;

 

-		USB_Host_GetNextDescriptor(BytesRem, CurrConfigLoc);

+		USB_GetNextDescriptor(BytesRem, CurrConfigLoc);

 

 		if ((ErrorCode = ComparatorRoutine(*CurrConfigLoc)) != Descriptor_Search_NotFound)

 		{

@@ -142,5 +139,3 @@ uint8_t USB_Host_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfi
 	

 	return Descriptor_Search_Comp_EndOfDescriptor;

 }

-

-#endif

diff --git a/LUFA/Drivers/USB/Class/ConfigDescriptor.h b/LUFA/Drivers/USB/Class/ConfigDescriptor.h
index d5fcbb0bb..7a1d53118 100644
--- a/LUFA/Drivers/USB/Class/ConfigDescriptor.h
+++ b/LUFA/Drivers/USB/Class/ConfigDescriptor.h
@@ -50,6 +50,7 @@
 		#include <avr/io.h>

 		

 		#include "../../../Common/Common.h"

+		#include "../HighLevel/USBMode.h"

 		#include "../LowLevel/HostChapter9.h"

 		#include "../HighLevel/StdDescriptors.h"

 		

@@ -58,7 +59,7 @@
 			extern "C" {

 		#endif

 

-	/* Public Interface - May be used in end-application: */

+	/* Public Interface - May be used in end-application: */	

 		/* Macros: */

 			/** Mask for determining the type of an endpoint from an endpoint descriptor. This should then be compared

 			 *  with the EP_TYPE_* masks to determine the exact type of the endpoint.

@@ -121,42 +122,49 @@
 			 */

 			#define DESCRIPTOR_COMPARATOR(name)           uint8_t DCOMP_##name (void* const CurrentDescriptor)

 

-			/** Searches for the next descriptor in the given configuration descriptor using a premade comparator

-			 *  function. The routine updates the position and remaining configuration descriptor bytes values

-			 *  automatically. If a comparator routine fails a search, the descriptor pointer is retreated back

-			 *  so that the next descriptor search invocation will start from the descriptor which first caused the

-			 *  original search to fail. This behaviour allows for one comparator to be used immediately after another

-			 *  has failed, starting the second search from the descriptor which failed the first.

-			 *

-			 *  \param DSize    Pointer to an int storing the remaining bytes in the configuration descriptor

-			 *  \param DPos     Pointer to the current position in the configuration descriptor

-			 *  \param DSearch  Name of the comparator search function to use on the configuration descriptor

-			 *

-			 *  \return Value of one of the members of the DSearch_Comp_Return_ErrorCodes_t enum

-			 *

-			 *  Usage Example:

-			 *  \code

-			 *  DESCRIPTOR_COMPARATOR(EndpointSearcher); // Comparator Prototype

-			 *

-			 *  DESCRIPTOR_COMPARATOR(EndpointSearcher)

-			 *  {

-			 *     if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)

-			 *         return Descriptor_Search_Found;

-			 *     else

-			 *         return Descriptor_Search_NotFound;

-			 *  }

-			 *

-			 *  //...

-			 *  // After retrieving configuration descriptor:

-			 *  if (USB_Host_GetNextDescriptorComp(&BytesRemaining, &ConfigDescriptorData, EndpointSearcher) ==

-			 *      Descriptor_Search_Comp_Found)

-			 *  {

-			 *      // Do something with the endpoint descriptor

-			 *  }

-			 *  \endcode

-			 */

-			#define USB_Host_GetNextDescriptorComp(DSize, DPos, DSearch) \

-			                                              USB_Host_GetNextDescriptorComp_P(DSize, DPos, DCOMP_##DSearch)

+		/* Psuedo-Functions: */

+			#if defined(__DOXYGEN__)

+				/** Searches for the next descriptor in the given configuration descriptor using a premade comparator

+				 *  function. The routine updates the position and remaining configuration descriptor bytes values

+				 *  automatically. If a comparator routine fails a search, the descriptor pointer is retreated back

+				 *  so that the next descriptor search invocation will start from the descriptor which first caused the

+				 *  original search to fail. This behaviour allows for one comparator to be used immediately after another

+				 *  has failed, starting the second search from the descriptor which failed the first.

+				 *

+				 *  \note This function is available in USB Host mode only.

+				 *

+				 *  \param BytesRem  Pointer to an int storing the remaining bytes in the configuration descriptor

+				 *  \param CurrConfigLoc  Pointer to the current position in the configuration descriptor

+				 *  \param ComparatorRoutine  Name of the comparator search function to use on the configuration descriptor

+				 *

+				 *  \return Value of one of the members of the DSearch_Comp_Return_ErrorCodes_t enum

+				 *

+				 *  Usage Example:

+				 *  \code

+				 *  DESCRIPTOR_COMPARATOR(EndpointSearcher); // Comparator Prototype

+				 *

+				 *  DESCRIPTOR_COMPARATOR(EndpointSearcher)

+				 *  {

+				 *     if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)

+				 *         return Descriptor_Search_Found;

+				 *     else

+				 *         return Descriptor_Search_NotFound;

+				 *  }

+				 *

+				 *  //...

+				 *  // After retrieving configuration descriptor:

+				 *  if (USB_Host_GetNextDescriptorComp(&BytesRemaining, &ConfigDescriptorData, EndpointSearcher) ==

+				 *      Descriptor_Search_Comp_Found)

+				 *  {

+				 *      // Do something with the endpoint descriptor

+				 *  }

+				 *  \endcode

+				 */

+				uint8_t USB_GetNextDescriptorComp(uint16_t* BytesRem, uint8_t** CurrConfigLoc, ComparatorPtr_t ComparatorRoutine);

+			#else

+				#define USB_GetNextDescriptorComp(DSize, DPos, DSearch) USB_GetNextDescriptorComp_P(DSize, DPos, DCOMP_##DSearch)

+			#endif

+			

 		/* Enums: */

 			/** Enum for return values of a descriptor comparator made with DESCRIPTOR_COMPARATOR. */

 			enum DSearch_Return_ErrorCodes_t

@@ -166,7 +174,7 @@
 				Descriptor_Search_NotFound             = 2, /**< Current descriptor does not match comparator criteria. */

 			};

 

-			/** Enum for return values of USB_Host_GetNextDescriptorComp() */

+			/** Enum for return values of USB_GetNextDescriptorComp(). */

 			enum DSearch_Comp_Return_ErrorCodes_t

 			{

 				Descriptor_Search_Comp_Found           = 0, /**< Configuration descriptor now points to descriptor which matches

@@ -187,31 +195,8 @@
 			 *                    of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded

 			 *                    into the buffer

 			 */

-			uint8_t USB_Host_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* BufferPtr)

-			                                           ATTR_NON_NULL_PTR_ARG(1);

-

-		/* Inline Functions: */

-			/** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then

-			    points to the next sub-descriptor. The bytes remaining value is automatically decremented.

-			 *

-			 * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor

-			 * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor

-			 */

-			static inline void USB_Host_GetNextDescriptor(uint16_t* const BytesRem,

-			                                              uint8_t** const CurrConfigLoc) 

-														  ATTR_NON_NULL_PTR_ARG(1, 2);									  

-			static inline void USB_Host_GetNextDescriptor(uint16_t* const BytesRem,

-			                                              uint8_t** const CurrConfigLoc)

-			{

-				#if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)

-				uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).Size;

-				#else

-				uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).bLength;				

-				#endif

-

-				*CurrConfigLoc += CurrDescriptorSize;

-				*BytesRem      -= CurrDescriptorSize;

-			}

+			uint8_t USB_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* BufferPtr)

+			                                      ATTR_NON_NULL_PTR_ARG(1);

 

 			/** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value.

 			 *  The bytes remaining value is automatically decremented.

@@ -220,10 +205,10 @@
 			 * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor

 			 * \param Type  Descriptor type value to search for

 			 */

-			void USB_Host_GetNextDescriptorOfType(uint16_t* const BytesRem,

-			                                      uint8_t** const CurrConfigLoc,

-			                                      const uint8_t Type)

-			                                      ATTR_NON_NULL_PTR_ARG(1, 2);

+			void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,

+			                                 uint8_t** const CurrConfigLoc,

+			                                 const uint8_t Type)

+			                                 ATTR_NON_NULL_PTR_ARG(1, 2);

 

 			/** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value,

 			 *  which must come before a descriptor of the second given type value. If the BeforeType type

@@ -235,11 +220,11 @@
 			 * \param Type  Descriptor type value to search for

 			 * \param BeforeType  Descriptor type value which must not be reached before the given Type descriptor

 			 */

-			void USB_Host_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,

-			                                            uint8_t** const CurrConfigLoc,

-			                                            const uint8_t Type,

-			                                            const uint8_t BeforeType)

-			                                            ATTR_NON_NULL_PTR_ARG(1, 2);

+			void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,

+			                                       uint8_t** const CurrConfigLoc,

+			                                       const uint8_t Type,

+			                                       const uint8_t BeforeType)

+			                                       ATTR_NON_NULL_PTR_ARG(1, 2);

 

 			/** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value,

 			 *  which must come after a descriptor of the second given type value. The bytes remaining value is

@@ -250,17 +235,42 @@
 			 * \param Type  Descriptor type value to search for

 			 * \param AfterType  Descriptor type value which must be reached before the given Type descriptor

 			 */

-			void USB_Host_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,

-			                                           uint8_t** const CurrConfigLoc,

-			                                           const uint8_t Type,

-			                                           const uint8_t AfterType)

-			                                           ATTR_NON_NULL_PTR_ARG(1, 2);

+			void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,

+			                                      uint8_t** const CurrConfigLoc,

+			                                      const uint8_t Type,

+			                                      const uint8_t AfterType)

+			                                      ATTR_NON_NULL_PTR_ARG(1, 2);

+

+		/* Inline Functions: */

+			/** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then

+			    points to the next sub-descriptor. The bytes remaining value is automatically decremented.

+			 *

+			 * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor

+			 * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor

+			 */

+			static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,

+			                                         uint8_t** const CurrConfigLoc) 

+			                                         ATTR_NON_NULL_PTR_ARG(1, 2);									  

+			static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,

+			                                         uint8_t** const CurrConfigLoc)

+			{

+				#if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)

+				uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).Size;

+				#else

+				uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).bLength;				

+				#endif

+

+				*CurrConfigLoc += CurrDescriptorSize;

+				*BytesRem      -= CurrDescriptorSize;

+			}

 			

 	/* Private Interface - For use in library only: */

 	#if !defined(__DOXYGEN__)

+		/* Type Defines: */

+			typedef uint8_t (* const ComparatorPtr_t)(void* const);

+

 		/* Function Prototypes: */

-			uint8_t USB_Host_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfigLoc,

-                                                     uint8_t (* const ComparatorRoutine)(void* const));

+			uint8_t USB_GetNextDescriptorComp_P(uint16_t* BytesRem, uint8_t** CurrConfigLoc, ComparatorPtr_t ComparatorRoutine);

 	#endif

 			

 	/* Disable C linkage for C++ Compilers: */

diff --git a/LUFA/Drivers/USB/Class/HIDParser.h b/LUFA/Drivers/USB/Class/HIDParser.h
index 4d9f9db7a..f02f1fd09 100644
--- a/LUFA/Drivers/USB/Class/HIDParser.h
+++ b/LUFA/Drivers/USB/Class/HIDParser.h
@@ -215,8 +215,8 @@
 			 *

 			 *  \return A value in the HID_Parse_ErrorCodes_t enum

 			 */

-			uint8_t ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)

-			                         ATTR_NON_NULL_PTR_ARG(1, 3);

+			uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)

+			                             ATTR_NON_NULL_PTR_ARG(1, 3);

 

 			/** Extracts the given report item's value out of the given HID report and places it into the Value

 			 *  member of the report item's HID_ReportItem_t structure.

@@ -226,8 +226,8 @@
 			 *

 			 *  \returns Boolean true if the item to retrieve was located in the given report, false otherwise

 			 */

-			bool GetReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem)

-			                       ATTR_NON_NULL_PTR_ARG(1, 2);

+			bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem)

+			                              ATTR_NON_NULL_PTR_ARG(1, 2);

 

 			/** Retrieves the given report item's value out of the Value member of the report item's

 			 *  HID_ReportItem_t structure and places it into the correct position in the HID report

@@ -239,8 +239,8 @@
 			 *  \param ReportData  Buffer holding the current OUT report data

 			 *  \param ReportItem  Pointer to the report item of interest in a HID_ReportInfo_t ReportItem array

 			 */

-			void SetReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)

-			                       ATTR_NON_NULL_PTR_ARG(1, 2);

+			void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)

+			                              ATTR_NON_NULL_PTR_ARG(1, 2);

 

 	/* Private Interface - For use in library only: */

 	#if !defined(__DOXYGEN__)

diff --git a/LUFA/Drivers/USB/HighLevel/USBInterrupt.h b/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
index 56297e3d4..c5b0a8358 100644
--- a/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
+++ b/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
@@ -31,9 +31,9 @@
 /** \ingroup Group_USB

  *  @defgroup Group_USBInterrupt Endpoint and Pipe Interrupts

  *

- *  Main USB interrupt vector handler. This file manages the main USB interrupt vector, for handling such

- *  events as VBUS interrupts (on supported USB AVR models), device connections and disconnections, etc.

- *  as well as providing easy to use macros for the management of the Endpoint/Pipe interrupt vector.

+ *  This module manages the main USB interrupt vector, for handling such events as VBUS interrupts

+ *  (on supported USB AVR models), device connections and disconnections, etc. as well as providing

+ *  easy to use macros for the management of the unified Endpoint/Pipe interrupt vector.

  *

  *  @{

  */

diff --git a/LUFA/MigrationInformation.txt b/LUFA/MigrationInformation.txt
index f0930a55e..f7e986046 100644
--- a/LUFA/MigrationInformation.txt
+++ b/LUFA/MigrationInformation.txt
@@ -57,6 +57,9 @@
  *    - The Pipe_Ignore_Word() function has been renamed to Pipe_Discard_Word() to remain consistent with the rest of the pipe API.

  *    - It is no longer needed to manually include the headers from LUFA/Drivers/USB/Class, as they are now included along with the rest

  *      of the USB headers when LUFA/Drivers/USB/USB.h is included.

+ *    - Functions in the ConfigDescriptor.h header file no longer have "Host_" as part of their names.

+ *    - The ProcessHIDReport() has been renamed to USB_ProcessHIDReport(), GetReportItemInfo() has been renamed to USB_GetHIDReportItemInfo()

+ *      and SetReportItemInfo() has been renamed to USB_GetHIDReportItemInfo().

  *

  *

  * \section Sec_Migration090401 Migrating from 090209 to 090401