Added const modifiers to device mode class drivers.

Added parameter directions to function parameter documentation.

Added new experimental FAST_STREAM_FUNCTIONS compile time option to speed up stream transfers at the expense of a higher FLASH consumption (needs testing to verify improved throughput).

16 files changed, 132 insertions, 138 deletions

diff --git a/LUFA/Drivers/USB/Class/Common/Audio.h b/LUFA/Drivers/USB/Class/Common/Audio.h
index a55fd0d7c..33bc8980e 100644
--- a/LUFA/Drivers/USB/Class/Common/Audio.h
+++ b/LUFA/Drivers/USB/Class/Common/Audio.h
@@ -201,7 +201,7 @@
 

 		/** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.

 		 *

-		 *  \param freq  Required audio sampling frequency in HZ

+		 *  \param[in] freq  Required audio sampling frequency in HZ

 		 */

 		#define AUDIO_SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}

 		

diff --git a/LUFA/Drivers/USB/Class/Common/CDC.h b/LUFA/Drivers/USB/Class/Common/CDC.h
index 5138032da..69803150a 100644
--- a/LUFA/Drivers/USB/Class/Common/CDC.h
+++ b/LUFA/Drivers/USB/Class/Common/CDC.h
@@ -111,7 +111,7 @@
 		 *  a single typedef struct. A macro is used instead so that functional descriptors can be created

 		 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.

 		 *

-		 *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload

+		 *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload

 		 */

 		#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \

 		     struct                                        \

diff --git a/LUFA/Drivers/USB/Class/Common/MIDI.h b/LUFA/Drivers/USB/Class/Common/MIDI.h
index dfeadb05b..7dfb0e780 100644
--- a/LUFA/Drivers/USB/Class/Common/MIDI.h
+++ b/LUFA/Drivers/USB/Class/Common/MIDI.h
@@ -71,7 +71,7 @@
 		/** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel

 		 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.

 		 *

-		 *  \param channel  MIDI channel number to address

+		 *  \param[in] channel  MIDI channel number to address

 		 */

 		#define MIDI_CHANNEL(channel)        (channel - 1)

 		

diff --git a/LUFA/Drivers/USB/Class/Device/Audio.c b/LUFA/Drivers/USB/Class/Device/Audio.c
index e398f1c0e..d117bedf6 100644
--- a/LUFA/Drivers/USB/Class/Device/Audio.c
+++ b/LUFA/Drivers/USB/Class/Device/Audio.c
@@ -33,7 +33,7 @@
 

 #include "Audio.h"

 

-void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)

+void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)

 {

 	if (!(Endpoint_IsSETUPReceived()))

 	  return;

@@ -83,7 +83,7 @@ bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfac
 	return true;

 }

 

-void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)

+void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)

 {

 

 }

@@ -124,7 +124,7 @@ int32_t Audio_Device_ReadSample24(void)
 	return Sample;

 }

 

-void Audio_Device_WriteSample8(int8_t Sample)

+void Audio_Device_WriteSample8(const int8_t Sample)

 {

 	Endpoint_Write_Byte(Sample);

 

@@ -132,7 +132,7 @@ void Audio_Device_WriteSample8(int8_t Sample)
 	  Endpoint_ClearIN();

 }

 

-void Audio_Device_WriteSample16(int16_t Sample)

+void Audio_Device_WriteSample16(const int16_t Sample)

 {

 	Endpoint_Write_Word_LE(Sample);

 

@@ -140,7 +140,7 @@ void Audio_Device_WriteSample16(int16_t Sample)
 	  Endpoint_ClearIN();

 }

 

-void Audio_Device_WriteSample24(int32_t Sample)

+void Audio_Device_WriteSample24(const int32_t Sample)

 {

 	Endpoint_Write_Byte(Sample >> 16);

 	Endpoint_Write_Word_LE(Sample);

@@ -149,13 +149,13 @@ void Audio_Device_WriteSample24(int32_t Sample)
 	  Endpoint_ClearIN();

 }

 

-bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)

+bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)

 {

 	Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);

 	return Endpoint_IsOUTReceived();

 }

 

-bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)

+bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)

 {

 	Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);

 	return Endpoint_IsINReady();

diff --git a/LUFA/Drivers/USB/Class/Device/Audio.h b/LUFA/Drivers/USB/Class/Device/Audio.h
index faa9c9243..7ce062437 100644
--- a/LUFA/Drivers/USB/Class/Device/Audio.h
+++ b/LUFA/Drivers/USB/Class/Device/Audio.h
@@ -97,25 +97,25 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the

 			 *  given Audio interface is selected.

 			 *

-			 *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

+			 *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

-			bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);

+			bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);

 

 			/** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

+			 *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

 			 */

-			void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);

+			void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);

 

 			/** General management task for a given Audio class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

+			 *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

 			 */

-			void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);

+			void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);

 			

 			/** Reads the next 8-bit audio sample from the current audio interface.

 			 *

@@ -149,43 +149,43 @@
 			 *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that

 			 *        the correct endpoint is selected and ready for data.

 			 *

-			 *  \param Sample  Signed 8-bit audio sample

+			 *  \param[in] Sample  Signed 8-bit audio sample

 			 */

-			void Audio_Device_WriteSample8(int8_t Sample);

+			void Audio_Device_WriteSample8(const int8_t Sample);

 

 			/** Writes the next 16-bit audio sample to the current audio interface.

 			 *

 			 *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that

 			 *        the correct endpoint is selected and ready for data.

 			 *

-			 *  \param Sample  Signed 16-bit audio sample

+			 *  \param[in] Sample  Signed 16-bit audio sample

 			 */

-			void Audio_Device_WriteSample16(int16_t Sample);

+			void Audio_Device_WriteSample16(const int16_t Sample);

 

 			/** Writes the next 24-bit audio sample to the current audio interface.

 			 *

 			 *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that

 			 *        the correct endpoint is selected and ready for data.

 			 *

-			 *  \param Sample  Signed 24-bit audio sample

+			 *  \param[in] Sample  Signed 24-bit audio sample

 			 */

-			void Audio_Device_WriteSample24(int32_t Sample);

+			void Audio_Device_WriteSample24(const int32_t Sample);

 

 			/** Determines if the given audio interface is ready for a sample to be read from it.

 			 *

-			 *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

+			 *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

 			 *

 			 *  \return Boolean true if the given Audio interface has a sample to be read, false otherwise

 			 */

-			bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);

+			bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);

 

 			/** Determines if the given audio interface is ready to accept the next sample to be written to it.

 			 *

-			 *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

+			 *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.

 			 *

 			 *  \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise

 			 */

-			bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);

+			bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);

 

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

 		#if defined(__cplusplus)

diff --git a/LUFA/Drivers/USB/Class/Device/CDC.c b/LUFA/Drivers/USB/Class/Device/CDC.c
index fc6ea93fb..07c05141b 100644
--- a/LUFA/Drivers/USB/Class/Device/CDC.c
+++ b/LUFA/Drivers/USB/Class/Device/CDC.c
@@ -131,7 +131,7 @@ void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 	Endpoint_ClearIN();

 }

 

-void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length)

+void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)

 {

 	if (!(USB_IsConnected))

 	  return;

@@ -140,7 +140,7 @@ void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* D
 	Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);

 }

 

-void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data)

+void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data)

 {

 	if (!(USB_IsConnected))

 	  return;

@@ -156,7 +156,7 @@ void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t D
 	Endpoint_Write_Byte(Data);	

 }

 

-uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)

+uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)

 {

 	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);

 

@@ -178,7 +178,7 @@ uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 	return DataByte;

 }

 

-void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)

+void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)

 {

 	if (!(USB_IsConnected))

 	  return;

diff --git a/LUFA/Drivers/USB/Class/Device/CDC.h b/LUFA/Drivers/USB/Class/Device/CDC.h
index 157b35003..7b232fc89 100644
--- a/LUFA/Drivers/USB/Class/Device/CDC.h
+++ b/LUFA/Drivers/USB/Class/Device/CDC.h
@@ -108,34 +108,34 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the

 			 *  given CDC interface is selected.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

-			bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 

 			/** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 */

-			void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 

 			/** General management task for a given CDC class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 */

-			void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 

 			/** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a

 			 *  line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the

 			 *  user program by declaring a handler function with the same name and parameters listed here. The new line encoding

 			 *  settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 */

-			void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 			

 			/** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a

 			 *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the

@@ -143,62 +143,62 @@
 			 *  are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as

 			 *  a mask of CDC_CONTROL_LINE_OUT_* masks.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 */		

-			void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 

 			/** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the

 			 *  string is discarded.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

-			 *  \param Data  Pointer to the string to send to the host

-			 *  \param Length  Size in bytes of the string to send to the host

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in] Data  Pointer to the string to send to the host

+			 *  \param[in] Length  Size in bytes of the string to send to the host

 			 */

-			void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length);

+			void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length);

 			

 			/** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the

 			 *  byte is discarded.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

-			 *  \param Data  Byte of data to send to the host

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in] Data  Byte of data to send to the host

 			 */

-			void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data);

+			void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data);

 			

 			/** Determines the number of bytes received by the CDC interface from the host, waiting to be read.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 *

 			 *  \return Total number of buffered bytes received from the host

 			 */

-			uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 			

 			/** Reads a byte of data from the host. If no data is waiting to be read of if a USB host is not connected, the function

 			 *  returns 0. The USB_CDC_BytesReceived() function should be queried before data is recieved to ensure that no data

 			 *  underflow occurs.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 *

 			 *  \return Next received byte from the host, or 0 if no data received

 			 */

-			uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 			

 			/** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial

 			 *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist

 			 *  until they are cleared via a second notification. This should be called each time the CDC class driver's 

 			 *  ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.

 			 *

-			 *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.

 			 */

-			void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);

+			void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);

 

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

 	#if !defined(__DOXYGEN__)

 		/* Function Prototypes: */

 			#if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)

 				void CDC_Device_Event_Stub(void);

-				void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)

+				void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)

 														  ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);

-				void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)

+				void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)

 															 ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);

 			#endif

 

diff --git a/LUFA/Drivers/USB/Class/Device/HID.c b/LUFA/Drivers/USB/Class/Device/HID.c
index c37dc5d5c..d0320868f 100644
--- a/LUFA/Drivers/USB/Class/Device/HID.c
+++ b/LUFA/Drivers/USB/Class/Device/HID.c
@@ -33,7 +33,7 @@
 

 #include "HID.h"

 

-void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)

+void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)

 {

 	if (!(Endpoint_IsSETUPReceived()))

 	  return;

@@ -130,7 +130,7 @@ void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInf
 	}

 }

 

-bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)

+bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)

 {

 	HIDInterfaceInfo->State.UsingReportProtocol = true;

 

@@ -143,7 +143,7 @@ bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
 	return true;

 }

 		

-void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)

+void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)

 {

 	if (!(USB_IsConnected))

 	  return;

diff --git a/LUFA/Drivers/USB/Class/Device/HID.h b/LUFA/Drivers/USB/Class/Device/HID.h
index 61e5eed28..984078c3e 100644
--- a/LUFA/Drivers/USB/Class/Device/HID.h
+++ b/LUFA/Drivers/USB/Class/Device/HID.h
@@ -89,7 +89,7 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration

 			 *  containing the given HID interface is selected.

 			 *

-			 *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

+			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

@@ -98,14 +98,14 @@
 			/** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

+			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

 			 */		

 			void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);

 

 			/** General management task for a given HID class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

+			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

 			 */

 			void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);

 			

@@ -113,11 +113,11 @@
 			 *  HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the

 			 *  user is responsible for the creation of the next HID input report to be sent to the host.

 			 *

-			 *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

-			 *  \param ReportID  If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should

-			 *                   be set to the report ID of the generated HID input report. If multiple reports are not sent via the

-			 *                   given HID interface, this parameter should be ignored.

-			 *  \param ReportData  Pointer to a buffer where the generated HID report should be stored.

+			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

+			 *  \param[in,out] ReportID  If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should

+			 *                 be set to the report ID of the generated HID input report. If multiple reports are not sent via the

+			 *                 given HID interface, this parameter should be ignored.

+			 *  \param[out] ReportData  Pointer to a buffer where the generated HID report should be stored.

 			 *

 			 *  \return  Number of bytes in the generated input report, or zero if no report is to be sent

 			 */

@@ -127,14 +127,14 @@
 			 *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback

 			 *  the user is responsible for the processing of the received HID output report from the host.

 			 *

-			 *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

-			 *  \param ReportID  Report ID of the received output report. If multiple reports are not received via the given HID

+			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.

+			 *  \param[in] ReportID  Report ID of the received output report. If multiple reports are not received via the given HID

 			 *                   interface, this parameter should be ignored.

-			 *  \param ReportData  Pointer to a buffer where the received HID report is stored.

-			 *  \param ReportSize  Size in bytes of the received report from the host.

+			 *  \param[in] ReportData  Pointer to a buffer where the received HID report is stored.

+			 *  \param[in] ReportSize  Size in bytes of the received report from the host.

 			 */

-			void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, void* ReportData,

-													  uint16_t ReportSize);

+			void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,

+			                                          const void* ReportData, const uint16_t ReportSize);

 

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

 		#if defined(__cplusplus)

diff --git a/LUFA/Drivers/USB/Class/Device/MIDI.c b/LUFA/Drivers/USB/Class/Device/MIDI.c
index 0dcc94db9..da33bdb61 100644
--- a/LUFA/Drivers/USB/Class/Device/MIDI.c
+++ b/LUFA/Drivers/USB/Class/Device/MIDI.c
@@ -33,12 +33,12 @@
 

 #include "MIDI.h"

 

-void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)

+void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)

 {

 

 }

 

-bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)

+bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)

 {

 	if (MIDIInterfaceInfo->Config.DataINEndpointNumber)

 	{

@@ -63,12 +63,12 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceIn
 	return true;

 }

 

-void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)

+void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)

 {

 

 }

 

-void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)

+void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)

 {

 	if (!(USB_IsConnected))

 	  return;

@@ -82,7 +82,7 @@ void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo,
 	}

 }

 

-bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)

+bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)

 {

 	if (!(USB_IsConnected))

 	  return false;

diff --git a/LUFA/Drivers/USB/Class/Device/MIDI.h b/LUFA/Drivers/USB/Class/Device/MIDI.h
index e81089c93..19ff5d463 100644
--- a/LUFA/Drivers/USB/Class/Device/MIDI.h
+++ b/LUFA/Drivers/USB/Class/Device/MIDI.h
@@ -54,12 +54,6 @@
 

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

 		/* Type Define: */

-			/** Configuration information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */

-			typedef  USB_ClassInfo_MIDI_Device_Config_t;

-	

-			/** Current State information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */

-			typedef  USB_ClassInfo_MIDI_Device_State_t;

-	

 			/** Class state structure. An instance of this structure should be made for each MIDI interface

 			 *  within the user application, and passed to each of the MIDI class driver functions as the

 			 *  MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.

@@ -92,41 +86,41 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration

 			 *  containing the given MIDI interface is selected.

 			 *

-			 *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

+			 *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

-			bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);

+			bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);

 			

 			/** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

+			 *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

 			 */		

-			void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);

+			void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);

 

 			/** General management task for a given MIDI class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

+			 *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

 			 */

-			void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);

+			void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);

 

 			/** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.

 			 *

-			 *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

-			 *  \param Event  Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send

+			 *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

+			 *  \param[in] Event  Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send

 			 */

-			void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);

+			void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);

 

 			/** Receives a MIDI event packet from the host.

 			 *

-			 *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

-			 *  \param Event  Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed

+			 *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.

+			 *  \param[out] Event  Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed

 			 *

 			 *  \return Boolean true if a MIDI event packet was received, false otherwise

 			 */

-			bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);

+			bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);

 

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

 		#if defined(__cplusplus)

diff --git a/LUFA/Drivers/USB/Class/Device/MassStorage.c b/LUFA/Drivers/USB/Class/Device/MassStorage.c
index aedab106f..9d73989b7 100644
--- a/LUFA/Drivers/USB/Class/Device/MassStorage.c
+++ b/LUFA/Drivers/USB/Class/Device/MassStorage.c
@@ -36,7 +36,7 @@
 

 static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;

 

-void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)

+void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

 {

 	if (!(Endpoint_IsSETUPReceived()))

 	  return;

@@ -75,7 +75,7 @@ void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 	}

 }

 

-bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)

+bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

 {

 	if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,

 							         ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,

@@ -94,7 +94,7 @@ bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 	return true;

 }

 

-void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)

+void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

 {

 	if (!(USB_IsConnected))

 	  return;

@@ -138,7 +138,7 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 	MSInterfaceInfo->State.IsMassStoreReset = false;

 }

 

-static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)

+static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

 {

 	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);

 

@@ -171,7 +171,7 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceI
 	return true;

 }

 

-static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)

+static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

 {

 	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);

 

diff --git a/LUFA/Drivers/USB/Class/Device/MassStorage.h b/LUFA/Drivers/USB/Class/Device/MassStorage.h
index 15be00e09..6b139ad5e 100644
--- a/LUFA/Drivers/USB/Class/Device/MassStorage.h
+++ b/LUFA/Drivers/USB/Class/Device/MassStorage.h
@@ -95,43 +95,43 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration

 			 *  containing the given Mass Storage interface is selected.

 			 *

-			 *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

+			 *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

-			bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

+			bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

 			

 			/** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

+			 *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

 			 */		

-			void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

+			void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

 

 			/** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.

+			 *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.

 			 */

-			void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

+			void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

 			

 			/** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the

 			 *  host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible

 			 *  for the processing of the received SCSI command from the host. The SCSI command is available in the CommandBlock structure

 			 *  inside the Mass Storage class state structure passed as a parameter to the callback function.

 			 *

-			 *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

+			 *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.

 			 *

 			 *  \return Boolean true if the SCSI command was successfully processed, false otherwise

 			 */

-			bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

+			bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

 		

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

 	#if !defined(__DOXYGEN__)

 		/* Function Prototypes: */

 			#if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)

-				static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

-				static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);

+				static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

+				static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

 				static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);

 			#endif

 		

diff --git a/LUFA/Drivers/USB/Class/Device/RNDIS.c b/LUFA/Drivers/USB/Class/Device/RNDIS.c
index bf753bf99..1b2da6ff3 100644
--- a/LUFA/Drivers/USB/Class/Device/RNDIS.c
+++ b/LUFA/Drivers/USB/Class/Device/RNDIS.c
@@ -65,7 +65,7 @@ static const uint32_t PROGMEM AdapterSupportedOIDList[]  =
 		OID_802_3_XMIT_MORE_COLLISIONS,

 	};

 

-void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)

+void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)

 {

 	if (!(Endpoint_IsSETUPReceived()))

 	  return;

@@ -110,7 +110,7 @@ void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterf
 	}

 }

 

-bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)

+bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)

 {

 	if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,

 							         ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,

@@ -136,7 +136,7 @@ bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfac
 	return true;

 }

 

-void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)

+void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)

 {

 	if (!(USB_IsConnected))

 	  return;

@@ -208,7 +208,7 @@ void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
 	}

 }							

 

-void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)

+void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)

 {

 	/* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of

 	         this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */

@@ -331,9 +331,9 @@ void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDIS
 	}

 }

 

-static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,

-                                          uint32_t OId, void* QueryData, uint16_t QuerySize,

-                                          void* ResponseData, uint16_t* ResponseSize)

+static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,

+                                          const uint32_t OId, void* const QueryData, const uint16_t QuerySize,

+                                          void* ResponseData, uint16_t* const ResponseSize)

 {

 	switch (OId)

 	{

@@ -443,8 +443,8 @@ static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInt
 	}

 }

 

-static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId, void* SetData,

-                                        uint16_t SetSize)

+static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, void* SetData,

+                                        const uint16_t SetSize)

 {

 	switch (OId)

 	{

diff --git a/LUFA/Drivers/USB/Class/Device/RNDIS.h b/LUFA/Drivers/USB/Class/Device/RNDIS.h
index 21fb09400..a4c2050e9 100644
--- a/LUFA/Drivers/USB/Class/Device/RNDIS.h
+++ b/LUFA/Drivers/USB/Class/Device/RNDIS.h
@@ -103,36 +103,36 @@
 			 *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration

 			 *  containing the given HID interface is selected.

 			 *

-			 *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

+			 *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

 			 *

 			 *  \return Boolean true if the endpoints were sucessfully configured, false otherwise

 			 */

-			bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);

+			bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);

 

 			/** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be

 			 *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.

 			 *

-			 *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

+			 *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

 			 */		

-			void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);

+			void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);

 			

 			/** General management task for a given HID class interface, required for the correct operation of the interface. This should

 			 *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().

 			 *

-			 *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

+			 *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.

 			 */

-			void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);

+			void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);

 		

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

 	#if !defined(__DOXYGEN__)

 		/* Function Prototypes: */

 		#if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)

-			static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);

-			static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, 

-			                                          uint32_t OId, void* QueryData, uint16_t QuerySize,

-										              void* ResponseData, uint16_t* ResponseSize);

-			static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId,

-			                                        void* SetData, uint16_t SetSize);	

+			static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);

+			static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, 

+			                                          const uint32_t OId, void* const QueryData, const uint16_t QuerySize,

+										              void* ResponseData, uint16_t* const ResponseSize);

+			static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,

+			                                        void* SetData, const uint16_t SetSize);	

 		#endif

 		

 	#endif

diff --git a/LUFA/Drivers/USB/Class/Host/HIDParser.h b/LUFA/Drivers/USB/Class/Host/HIDParser.h
index 4acce2462..f878aa167 100644
--- a/LUFA/Drivers/USB/Class/Host/HIDParser.h
+++ b/LUFA/Drivers/USB/Class/Host/HIDParser.h
@@ -209,9 +209,9 @@
 			/** Function to process a given HID report returned from an attached device, and store it into a given

 			 *  \ref HID_ReportInfo_t structure.

 			 *

-			 *  \param ReportData  Buffer containing the device's HID report table

-			 *  \param ReportSize  Size in bytes of the HID report table

-			 *  \param ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output

+			 *  \param[in] ReportData  Buffer containing the device's HID report table

+			 *  \param[in] ReportSize  Size in bytes of the HID report table

+			 *  \param[out] ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output

 			 *

 			 *  \return A value in the \ref HID_Parse_ErrorCodes_t enum

 			 */

@@ -221,8 +221,8 @@
 			/** 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 \ref HID_ReportItem_t structure.

 			 *

-			 *  \param ReportData  Buffer containing an IN or FEATURE report from an attached device

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

+			 *  \param[in] ReportData  Buffer containing an IN or FEATURE report from an attached device

+			 *  \param[in,out] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array

 			 *

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

 			 */

@@ -236,8 +236,8 @@
 			 *

 			 *  If the device has multiple HID reports, the report ID is set to the report ID of the given item.

 			 *

-			 *  \param ReportData  Buffer holding the current OUT report data

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

+			 *  \param[out] ReportData  Buffer holding the current OUT report data

+			 *  \param[in] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array

 			 */

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

 			                              ATTR_NON_NULL_PTR_ARG(1, 2);