USB_HostRequest renamed to USB_ControlRequest, entire control request header is now read into USB_ControlRequest in Device mode rather than having the library pass only partially read header data to the application.

The USB_UnhandledControlPacket event has had its parameters removed, in favour of accessing the new USB_ControlRequest structure.

The Endpoint control stream functions now correctly send a ZLP to the host when less data than requested is sent.

12 files changed, 104 insertions, 113 deletions

diff --git a/LUFA/Drivers/USB/Class/ConfigDescriptor.c b/LUFA/Drivers/USB/Class/ConfigDescriptor.c
index dd782c81d..367b28ae3 100644
--- a/LUFA/Drivers/USB/Class/ConfigDescriptor.c
+++ b/LUFA/Drivers/USB/Class/ConfigDescriptor.c
@@ -35,7 +35,7 @@ uint8_t USB_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* Buffe
 {

 	uint8_t ErrorCode;

 

-	USB_HostRequest = (USB_Host_Request_Header_t)

+	USB_ControlRequest = (USB_Request_Header_t)

 		{

 			.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),

 			.bRequest      = REQ_GetDescriptor,

@@ -60,7 +60,7 @@ uint8_t USB_GetDeviceConfigDescriptor(uint16_t* const ConfigSizePtr, void* Buffe
 	}

 	else

 	{

-		USB_HostRequest.wLength = *ConfigSizePtr;

+		USB_ControlRequest.wLength = *ConfigSizePtr;

 		

 		ErrorCode      = USB_Host_SendControlRequest(BufferPtr);				

 	}

diff --git a/LUFA/Drivers/USB/HighLevel/Events.h b/LUFA/Drivers/USB/HighLevel/Events.h
index 9638afee3..73a804c35 100644
--- a/LUFA/Drivers/USB/HighLevel/Events.h
+++ b/LUFA/Drivers/USB/HighLevel/Events.h
@@ -305,7 +305,7 @@
 			 *        parameters (wValue, wIndex, wLength, and Data) remain in the control endpoint bank until

 			 *        read out by the user application for processing.

 			 */

-			void USB_UnhandledControlPacket(const uint8_t bRequest, const uint8_t bmRequestType);

+			void USB_UnhandledControlPacket(void);

 

 			/** Event for USB configuration number changed. This event fires when a the USB host changes the

 			 *  selected configuration number while in device mode. This event should be hooked in device

@@ -392,7 +392,7 @@
 			#endif

 			

 			#if defined(USB_CAN_BE_DEVICE)

-				#define USB_UnhandledControlPacket_P    (const uint8_t bRequest, const uint8_t bmRequestType)

+				#define USB_UnhandledControlPacket_P    (void)

 				#define USB_ConfigurationChanged_P      (void)

 				#define USB_Suspend_P                   (void)

 				#define USB_WakeUp_P                    (void)

diff --git a/LUFA/Drivers/USB/HighLevel/StdRequestType.h b/LUFA/Drivers/USB/HighLevel/StdRequestType.h
index 27c179497..6f214893b 100644
--- a/LUFA/Drivers/USB/HighLevel/StdRequestType.h
+++ b/LUFA/Drivers/USB/HighLevel/StdRequestType.h
@@ -135,6 +135,20 @@
 			 */

 			#define FEATURE_REMOTE_WAKEUP           0x01

 

+		/* Type Defines: */

+			/** Type define for a standard USB control request.

+			 *

+			 *  \see The USB 2.0 specification for more information on standard control requests.

+			 */

+			typedef struct

+			{

+				uint8_t  bmRequestType; /**< Type of the request. */

+				uint8_t  bRequest; /**< Request command code. */

+				uint16_t wValue; /**< wValue parameter of the request. */

+				uint16_t wIndex; /**< wIndex parameter of the request. */

+				uint16_t wLength; /**< Length of the data to transfer in bytes. */

+			} USB_Request_Header_t;

+

 		/* Enums: */

 			/** Enumeration for the various standard request commands. These commands are applicable when the

 			 *  request type is REQTYPE_STANDARD (with the exception of REQ_GetDescriptor, which is always

diff --git a/LUFA/Drivers/USB/HighLevel/USBTask.c b/LUFA/Drivers/USB/HighLevel/USBTask.c
index e1c065905..aa04c56ba 100644
--- a/LUFA/Drivers/USB/HighLevel/USBTask.c
+++ b/LUFA/Drivers/USB/HighLevel/USBTask.c
@@ -33,9 +33,10 @@
 #define  INCLUDE_FROM_USBTASK_C

 #include "USBTask.h"

 

-volatile bool      USB_IsSuspended;

-volatile bool      USB_IsConnected;

-volatile bool      USB_IsInitialized;

+volatile bool        USB_IsSuspended;

+volatile bool        USB_IsConnected;

+volatile bool        USB_IsInitialized;

+USB_Request_Header_t USB_ControlRequest;

 

 #if defined(USB_CAN_BE_HOST)

 volatile uint8_t   USB_HostState;

@@ -169,7 +170,7 @@ static void USB_HostTask(void)
 			USB_HostState = HOST_STATE_Default;

 			break;

 		case HOST_STATE_Default:

-			USB_HostRequest = (USB_Host_Request_Header_t)

+			USB_ControlRequest = (USB_Request_Header_t)

 				{

 					.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),

 					.bRequest      = REQ_GetDescriptor,

@@ -214,7 +215,7 @@ static void USB_HostTask(void)
 

 			Pipe_SetInfiniteINRequests();

 			

-			USB_HostRequest = (USB_Host_Request_Header_t)

+			USB_ControlRequest = (USB_Request_Header_t)

 				{

 					.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),

 					.bRequest      = REQ_SetAddress,

diff --git a/LUFA/Drivers/USB/HighLevel/USBTask.h b/LUFA/Drivers/USB/HighLevel/USBTask.h
index 833fd9ec7..7e88ce88b 100644
--- a/LUFA/Drivers/USB/HighLevel/USBTask.h
+++ b/LUFA/Drivers/USB/HighLevel/USBTask.h
@@ -40,6 +40,7 @@
 		

 		#include "../../../Scheduler/Scheduler.h"

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

+		#include "StdRequestType.h"

 		#include "USBMode.h"

 		#include "Events.h"

 		#include "StdDescriptors.h"

@@ -82,6 +83,14 @@
 			 */

 			extern volatile bool USB_IsInitialized;

 

+			/** Structure containing the last received Control request when in Device mode (for use in user-applications

+			 *  inside of the USB_UnhandledControlPacket() event, or for filling up with a control request to issue when

+			 *  in Host mode before calling USB_Host_SendControlRequest().

+			 *

+			 *  \ingroup Group_USBManagement

+			 */

+			 extern USB_Request_Header_t USB_ControlRequest;

+			

 			#if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)

 			/** Indicates if the USB interface is currently suspended by the host when in device mode. When suspended,

 			 *  the device should consume minimal power, and cannot communicate to the host. If Remote Wakeup is

diff --git a/LUFA/Drivers/USB/LowLevel/DevChapter9.c b/LUFA/Drivers/USB/LowLevel/DevChapter9.c
index 3f2805c5a..bf2b12761 100644
--- a/LUFA/Drivers/USB/LowLevel/DevChapter9.c
+++ b/LUFA/Drivers/USB/LowLevel/DevChapter9.c
@@ -41,17 +41,19 @@ bool    USB_CurrentlySelfPowered;
 

 void USB_Device_ProcessControlPacket(void)

 {

-	uint8_t bmRequestType  = Endpoint_Read_Byte();

-	uint8_t bRequest       = Endpoint_Read_Byte();

-	bool    RequestHandled = false;	

+	bool     RequestHandled = false;

+	uint8_t* RequestHeader  = (uint8_t*)&USB_ControlRequest;

 	

-	switch (bRequest)

+	for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)

+	  *(RequestHeader++) = Endpoint_Read_Byte();

+	

+	switch (USB_ControlRequest.bRequest)

 	{

 		case REQ_GetStatus:

-			if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||

-			    (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))

+			if ((USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||

+			    (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))

 			{

-				USB_Device_GetStatus(bmRequestType);

+				USB_Device_GetStatus();

 				RequestHandled = true;

 			}

 

@@ -59,16 +61,16 @@ void USB_Device_ProcessControlPacket(void)
 #if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)

 		case REQ_ClearFeature:

 		case REQ_SetFeature:

-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT))

+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT))

 			{

-				USB_Device_ClearSetFeature(bRequest, bmRequestType);

+				USB_Device_ClearSetFeature();

 				RequestHandled = true;

 			}

 

 			break;

 #endif

 		case REQ_SetAddress:

-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))

+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))

 			{

 				USB_Device_SetAddress();

 				RequestHandled = true;

@@ -76,8 +78,8 @@ void USB_Device_ProcessControlPacket(void)
 

 			break;

 		case REQ_GetDescriptor:

-			if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||

-			    (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))

+			if ((USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||

+			    (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))

 			{

 				USB_Device_GetDescriptor();

 				RequestHandled = true;

@@ -85,7 +87,7 @@ void USB_Device_ProcessControlPacket(void)
 			

 			break;

 		case REQ_GetConfiguration:

-			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))

+			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))

 			{

 				USB_Device_GetConfiguration();

 				RequestHandled = true;

@@ -93,7 +95,7 @@ void USB_Device_ProcessControlPacket(void)
 

 			break;

 		case REQ_SetConfiguration:

-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))

+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))

 			{

 				USB_Device_SetConfiguration();

 				RequestHandled = true;

@@ -103,7 +105,7 @@ void USB_Device_ProcessControlPacket(void)
 	}

 

 	if (!(RequestHandled))

-	  RAISE_EVENT(USB_UnhandledControlPacket, bRequest, bmRequestType);

+	  RAISE_EVENT(USB_UnhandledControlPacket);

 	  

 	if (Endpoint_IsSETUPReceived())

 	{

@@ -114,8 +116,6 @@ void USB_Device_ProcessControlPacket(void)
 

 static void USB_Device_SetAddress(void)

 {

-	uint8_t wValue_LSB = Endpoint_Read_Byte();

-

 	Endpoint_ClearSETUP();

 	

 	while (!(Endpoint_IsINReady()));

@@ -124,28 +124,27 @@ static void USB_Device_SetAddress(void)
 	

 	while (!(Endpoint_IsINReady()));

 

-	UDADDR = ((1 << ADDEN) | (wValue_LSB & 0x7F));

+	UDADDR = ((1 << ADDEN) | (USB_ControlRequest.wValue & 0x7F));

 

 	return;

 }

 

 static void USB_Device_SetConfiguration(void)

 {

-	uint8_t wValue_LSB        = Endpoint_Read_Byte();

 	bool    AlreadyConfigured = (USB_ConfigurationNumber != 0);

 

 #if defined(USE_SINGLE_DEVICE_CONFIGURATION)

-	if (wValue_LSB > 1)

+	if (USB_ControlRequest.wValue > 1)

 #else

 	USB_Descriptor_Device_t* DevDescriptorPtr;

 

 	if ((USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr) == NO_DESCRIPTOR) ||

 	#if defined(USE_RAM_DESCRIPTORS)

-	    (wValue_LSB > DevDescriptorPtr->NumberOfConfigurations))

+	    (USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations))

 	#elif defined (USE_EEPROM_DESCRIPTORS)

-	    (wValue_LSB > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))

+	    (USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))

 	#else

-	    (wValue_LSB > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))

+	    (USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))

 	#endif

 #endif

 	{

@@ -154,7 +153,7 @@ static void USB_Device_SetConfiguration(void)
 	

 	Endpoint_ClearSETUP();

 

-	USB_ConfigurationNumber = wValue_LSB;

+	USB_ConfigurationNumber = USB_ControlRequest.wValue;

 

 	Endpoint_ClearIN();

 

@@ -178,24 +177,23 @@ void USB_Device_GetConfiguration(void)
 

 static void USB_Device_GetDescriptor(void)

 {

-	uint16_t wValue  = Endpoint_Read_Word_LE();

-	uint16_t wIndex  = Endpoint_Read_Word_LE();

-	uint16_t wLength = Endpoint_Read_Word_LE();

-	

 	void*    DescriptorPointer;

 	uint16_t DescriptorSize;

 	

-	bool     SendZLP;

-	

-	if ((DescriptorSize = USB_GetDescriptor(wValue, wIndex, &DescriptorPointer)) == NO_DESCRIPTOR)

+	if ((DescriptorSize = USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex, &DescriptorPointer)) == NO_DESCRIPTOR)

 	  return;

 	

-	Endpoint_ClearSETUP();	

+	Endpoint_ClearSETUP();

+	

+	#if defined(USE_RAM_DESCRIPTORS)

+	Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);

+	#else

+	bool     SendZLP;

 	

-	if (wLength > DescriptorSize)

-	  wLength = DescriptorSize;

+	if (USB_ControlRequest.wLength > DescriptorSize)

+	  USB_ControlRequest.wLength = DescriptorSize;

 	

-	while (wLength)

+	while (USB_ControlRequest.wLength)

 	{

 		while (!(Endpoint_IsINReady()))

 		{

@@ -206,17 +204,15 @@ static void USB_Device_GetDescriptor(void)
 			}		

 		}

 		

-		while (wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))

+		while (USB_ControlRequest.wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))

 		{

-			#if defined(USE_RAM_DESCRIPTORS)

-			Endpoint_Write_Byte(*((uint8_t*)DescriptorPointer++));

-			#elif defined (USE_EEPROM_DESCRIPTORS)

+			#if defined (USE_EEPROM_DESCRIPTORS)

 			Endpoint_Write_Byte(eeprom_read_byte(DescriptorPointer++));			

 			#else

 			Endpoint_Write_Byte(pgm_read_byte(DescriptorPointer++));

 			#endif

 			

-			wLength--;

+			USB_ControlRequest.wLength--;

 		}

 		

 		SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);

@@ -230,20 +226,16 @@ static void USB_Device_GetDescriptor(void)
 	}

 

 	while (!(Endpoint_IsOUTReceived()));

+	#endif

+	

 	Endpoint_ClearOUT();

 }

 

-static void USB_Device_GetStatus(const uint8_t bmRequestType)

+static void USB_Device_GetStatus(void)

 {

 	uint8_t CurrentStatus = 0;

 

-	Endpoint_Discard_Word();

-

-#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)

-	uint8_t wIndex_LSB = Endpoint_Read_Byte();

-#endif

-	

-	switch (bmRequestType)

+	switch (USB_ControlRequest.bmRequestType)

 	{

 		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):

 			if (USB_CurrentlySelfPowered)

@@ -255,15 +247,16 @@ static void USB_Device_GetStatus(const uint8_t bmRequestType)
 			break;

 #if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)

 		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):

-			Endpoint_SelectEndpoint(wIndex_LSB);

+			Endpoint_SelectEndpoint(USB_ControlRequest.wIndex);

 

 			CurrentStatus = Endpoint_IsStalled();

 

+			Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);			  

+

 			break;

 #endif

 	}

-	

-	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);			  

+

 	Endpoint_ClearSETUP();

 

 	Endpoint_Write_Word_LE(CurrentStatus);

@@ -275,17 +268,14 @@ static void USB_Device_GetStatus(const uint8_t bmRequestType)
 }

 

 #if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)

-static void USB_Device_ClearSetFeature(const uint8_t bRequest, const uint8_t bmRequestType)

-{

-	uint16_t wValue = Endpoint_Read_Word_LE();

-	uint16_t wIndex = Endpoint_Read_Word_LE();

-	

-	switch (bmRequestType & CONTROL_REQTYPE_RECIPIENT)

+static void USB_Device_ClearSetFeature(void)

+{	

+	switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)

 	{

 		case REQREC_ENDPOINT:

-			if (wValue == FEATURE_ENDPOINT_HALT)

+			if (USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)

 			{

-				uint8_t EndpointIndex = (wIndex & ENDPOINT_EPNUM_MASK);

+				uint8_t EndpointIndex = (USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);

 				

 				if (EndpointIndex != ENDPOINT_CONTROLEP)

 				{

@@ -293,7 +283,7 @@ static void USB_Device_ClearSetFeature(const uint8_t bRequest, const uint8_t bmR
 

 					if (Endpoint_IsEnabled())

 					{				

-						if (bRequest == REQ_ClearFeature)

+						if (USB_ControlRequest.bRequest == REQ_ClearFeature)

 						{

 							Endpoint_ClearStall();

 							Endpoint_ResetFIFO(EndpointIndex);

diff --git a/LUFA/Drivers/USB/LowLevel/DevChapter9.h b/LUFA/Drivers/USB/LowLevel/DevChapter9.h
index 23b7b4620..10a91937f 100644
--- a/LUFA/Drivers/USB/LowLevel/DevChapter9.h
+++ b/LUFA/Drivers/USB/LowLevel/DevChapter9.h
@@ -39,6 +39,7 @@
 		#include "../HighLevel/StdDescriptors.h"

 		#include "../HighLevel/Events.h"

 		#include "../HighLevel/StdRequestType.h"

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

 		#include "LowLevel.h"

 

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

@@ -118,9 +119,9 @@
 				static void USB_Device_SetConfiguration(void);

 				static void USB_Device_GetConfiguration(void);

 				static void USB_Device_GetDescriptor(void);

-				static void USB_Device_GetStatus(const uint8_t bmRequestType);

+				static void USB_Device_GetStatus(void);

 				#if !defined(FEATURELESS_CONTROL_ONLY_DEVICE)

-				static void USB_Device_ClearSetFeature(const uint8_t bRequest, const uint8_t bmRequestType);

+				static void USB_Device_ClearSetFeature(void);

 				#endif

 			#endif

 	#endif

diff --git a/LUFA/Drivers/USB/LowLevel/Endpoint.c b/LUFA/Drivers/USB/LowLevel/Endpoint.c
index e196b6aee..efa1a2db4 100644
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.c
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.c
@@ -292,8 +292,9 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
 

 uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length)

 {

-	uint8_t* DataStream = (uint8_t*)Buffer;

-	bool     SendZLP    = true;

+	uint8_t* DataStream    = (uint8_t*)Buffer;

+	bool     LastPacketFull = false;

+	bool     ShortTransfer = (Length < USB_ControlRequest.wLength);

 	

 	while (Length && !(Endpoint_IsOUTReceived()))

 	{

@@ -306,14 +307,14 @@ uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length)
 			Length--;

 		}

 		

-		SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);

+		LastPacketFull = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);

 		Endpoint_ClearIN();

 	}

 	

 	if (Endpoint_IsOUTReceived())

 	  return ENDPOINT_RWCSTREAM_ERROR_HostAborted;

 	

-	if (SendZLP)

+	if (LastPacketFull || ShortTransfer)

 	{

 		while (!(Endpoint_IsINReady()));

 		Endpoint_ClearIN();

@@ -326,8 +327,9 @@ uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length)
 

 uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length)

 {

-	uint8_t* DataStream = (uint8_t*)(Buffer + Length - 1);

-	bool     SendZLP    = true;

+	uint8_t* DataStream     = (uint8_t*)(Buffer + Length - 1);

+	bool     LastPacketFull = false;

+	bool     ShortTransfer  = (Length < USB_ControlRequest.wLength);

 	

 	while (Length && !(Endpoint_IsOUTReceived()))

 	{

@@ -340,14 +342,14 @@ uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length)
 			Length--;

 		}

 		

-		SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);

+		LastPacketFull = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);

 		Endpoint_ClearIN();

 	}

 	

 	if (Endpoint_IsOUTReceived())

 	  return ENDPOINT_RWCSTREAM_ERROR_HostAborted;

 	

-	if (SendZLP)

+	if (LastPacketFull || ShortTransfer)

 	{

 		while (!(Endpoint_IsINReady()));

 		Endpoint_ClearIN();

diff --git a/LUFA/Drivers/USB/LowLevel/HostChapter9.c b/LUFA/Drivers/USB/LowLevel/HostChapter9.c
index dfc3f4483..ee51cf3ae 100644
--- a/LUFA/Drivers/USB/LowLevel/HostChapter9.c
+++ b/LUFA/Drivers/USB/LowLevel/HostChapter9.c
@@ -35,15 +35,13 @@
 #define  INCLUDE_FROM_HOSTCHAPTER9_C

 #include "HostChapter9.h"

 

-USB_Host_Request_Header_t USB_HostRequest;

-

 uint8_t USB_Host_SendControlRequest(void* BufferPtr)

 {

-	uint8_t* HeaderStream   = (uint8_t*)&USB_HostRequest;

+	uint8_t* HeaderStream   = (uint8_t*)&USB_ControlRequest;

 	uint8_t* DataStream     = (uint8_t*)BufferPtr;

 	bool     BusSuspended   = USB_Host_IsBusSuspended();

 	uint8_t  ReturnStatus   = HOST_SENDCONTROL_Successful;

-	uint16_t DataLen        = USB_HostRequest.wLength;

+	uint16_t DataLen        = USB_ControlRequest.wLength;

 

 	USB_Host_ResumeBus();

 	

@@ -55,7 +53,7 @@ uint8_t USB_Host_SendControlRequest(void* BufferPtr)
 

 	Pipe_Unfreeze();

 

-	for (uint8_t HeaderByte = 0; HeaderByte < sizeof(USB_Host_Request_Header_t); HeaderByte++)

+	for (uint8_t HeaderByte = 0; HeaderByte < sizeof(USB_Request_Header_t); HeaderByte++)

 	  Pipe_Write_Byte(*(HeaderStream++));

 

 	Pipe_ClearSETUP();

@@ -68,7 +66,7 @@ uint8_t USB_Host_SendControlRequest(void* BufferPtr)
 	if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)

 	  goto End_Of_Control_Send;

 

-	if ((USB_HostRequest.bmRequestType & CONTROL_REQTYPE_DIRECTION) == REQDIR_DEVICETOHOST)

+	if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_DIRECTION) == REQDIR_DEVICETOHOST)

 	{

 		Pipe_SetToken(PIPE_TOKEN_IN);

 		

diff --git a/LUFA/Drivers/USB/LowLevel/HostChapter9.h b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
index c2c4ece7a..cbb5ba5a8 100644
--- a/LUFA/Drivers/USB/LowLevel/HostChapter9.h
+++ b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
@@ -45,23 +45,6 @@
 		#endif

 

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

-		/* Type Defines: */

-			/** Type define for a standard USB control request.

-			 *

-			 *  \see StdRequestType.h for information on the request type and data.

-			 *  \see The USB 2.0 specification for more information on standard control requests.

-			 *

-			 *  \ingroup Group_PipeControlReq

-			 */

-			typedef struct

-			{

-				uint8_t  bmRequestType; /**< Type of the request. */

-				uint8_t  bRequest; /**< Request command code. */

-				uint16_t wValue; /**< wValue parameter of the request. */

-				uint16_t wIndex; /**< wIndex parameter of the request. */

-				uint16_t wLength; /**< Length of the data to transfer in bytes. */

-			} USB_Host_Request_Header_t;

-

 		/* Enums: */

 			/** Enum for the USB_Host_SendControlRequest() return code, indicating the reason for the error

 			 *  if the transfer of the request is unsuccessful.

@@ -81,17 +64,8 @@
 				HOST_SENDCONTROL_SoftwareTimeOut  = 4, /**< The request or data transfer timed out. */

 			};

 			

-		/* Global Variables: */

-			/** Global for the request to send via the USB_Host_SendControlRequest() function. This

-			 *  global should be filled with the correct control request data before sending the request to

-			 *  the attached device while in host mode.

-			 *

-			 *  \ingroup Group_PipeControlReq

-			 */

-			extern USB_Host_Request_Header_t USB_HostRequest;

-			

 		/* Function Prototypes: */

-			/** Sends the request stored in the USB_HostRequest global structure to the attached device,

+			/** Sends the request stored in the USB_ControlRequest global structure to the attached device,

 			 *  and transfers the data stored in the buffer to the device, or from the device to the buffer

 			 *  as requested. The transfer is made on the currently selected pipe.

 			 *

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.c b/LUFA/Drivers/USB/LowLevel/Pipe.c
index 5850fcf7c..ff4318c99 100644
--- a/LUFA/Drivers/USB/LowLevel/Pipe.c
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.c
@@ -37,7 +37,7 @@
 

 uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;

 

-bool Pipe_ConfigurePipe(const uint8_t  Number, const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber,

+bool Pipe_ConfigurePipe(const uint8_t Number, const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber,

 						const uint16_t Size, const uint8_t Banks)

 {

 	Pipe_SelectPipe(Number);

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.h b/LUFA/Drivers/USB/LowLevel/Pipe.h
index 3f512c0d2..25121cafa 100644
--- a/LUFA/Drivers/USB/LowLevel/Pipe.h
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.h
@@ -389,6 +389,8 @@
 				 *  is an IN direction and no packet (or an empty packet) has been received, or if the pipe is an OUT

 				 *  direction and the pipe bank is full.

 				 *

+				 *  \note This function is not valid on CONTROL type pipes.

+				 *

 				 *  \ingroup Group_PipePacketManagement

 				 *  

 				 *  \return Boolean true if the currently selected pipe may be read from or written to, depending on its direction