31 files changed, 353 insertions, 833 deletions

diff --git a/LUFA/Drivers/USB/Class/Common/MIDIClassCommon.h b/LUFA/Drivers/USB/Class/Common/MIDIClassCommon.h
index 60b0908f3..25b80b7d4 100644
--- a/LUFA/Drivers/USB/Class/Common/MIDIClassCommon.h
+++ b/LUFA/Drivers/USB/Class/Common/MIDIClassCommon.h
@@ -84,8 +84,20 @@
 		 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.
 		 *
 		 *  \param[in] channel  MIDI channel number to address.
+		 *
+		 *  \return Constructed MIDI channel ID.
 		 */
 		#define MIDI_CHANNEL(channel)        ((channel) - 1)
+		
+		/** Constructs a MIDI event ID from a given MIDI command and a virtual MIDI cable index. This can then be
+		 *  used to create and decode \ref MIDI_EventPacket_t MIDI event packets.
+		 *
+		 *  \param[in] virtualcable  Index of the virtual MIDI cable the event relates to
+		 *  \param[in] command       MIDI command to send through the virtual MIDI cable
+		 *
+		 *  \return Constructed MIDI event ID.
+		 */
+		#define MIDI_EVENT(virtualcable, command) ((virtualcable << 4) | (command >> 4))
 
 	/* Enums: */
 		/** Enum for the possible MIDI jack types in a MIDI device jack descriptor. */
@@ -290,8 +302,7 @@
 		 */
 		typedef struct
 		{
-			unsigned Command     : 4; /**< Upper nibble of the MIDI command being sent or received in the event packet. */
-			unsigned CableNumber : 4; /**< Virtual cable number of the event being sent or received in the given MIDI interface. */
+			uint8_t Event; /**< MIDI event type, constructed with the \ref MIDI_EVENT() macro. */
 
 			uint8_t  Data1; /**< First byte of data in the MIDI event. */
 			uint8_t  Data2; /**< Second byte of data in the MIDI event. */
diff --git a/LUFA/Drivers/USB/Class/Device/AudioClassDevice.c b/LUFA/Drivers/USB/Class/Device/AudioClassDevice.c
index 15fcd588d..ad79e9b2b 100644
--- a/LUFA/Drivers/USB/Class/Device/AudioClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/AudioClassDevice.c
@@ -48,15 +48,16 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 	
 		if ((InterfaceIndex != AudioInterfaceInfo->Config.ControlInterfaceNumber) &&
 		    (InterfaceIndex != AudioInterfaceInfo->Config.StreamingInterfaceNumber))
-		
-		  return;
+		{
+			return;
+		}
 	}
 	else if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) == REQREC_ENDPOINT)
 	{
-		uint8_t EndpointIndex = (USB_ControlRequest.wIndex & 0xFF);
+		uint8_t EndpointAddress = (USB_ControlRequest.wIndex & 0xFF);
 	
-		if ((EndpointIndex != (ENDPOINT_DIR_IN  | AudioInterfaceInfo->Config.DataINEndpointNumber)) &&
-		    (EndpointIndex != (ENDPOINT_DIR_OUT | AudioInterfaceInfo->Config.DataOUTEndpointNumber)))
+		if ((EndpointAddress != AudioInterfaceInfo->Config.DataINEndpoint.Address) &&
+		    (EndpointAddress != AudioInterfaceInfo->Config.DataOUTEndpoint.Address))
 		{
 			return;
 		}
@@ -88,7 +89,7 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 		case AUDIO_REQ_SetMinimum:
 		case AUDIO_REQ_SetMaximum:
 		case AUDIO_REQ_SetResolution:
-			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT))
+			if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) == REQREC_ENDPOINT)
 			{
 				uint8_t EndpointProperty = USB_ControlRequest.bRequest;
 				uint8_t EndpointAddress  = (uint8_t)USB_ControlRequest.wIndex;
@@ -108,7 +109,7 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 					                                             EndpointControl, &ValueLength, Value);
 				}
 			}
-			else if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
+			else if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) == REQREC_INTERFACE)
 			{
 				uint8_t  Property  = USB_ControlRequest.bRequest;
 				uint8_t  Entity    = (USB_ControlRequest.wIndex >> 8);
@@ -134,7 +135,7 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 		case AUDIO_REQ_GetMinimum:
 		case AUDIO_REQ_GetMaximum:
 		case AUDIO_REQ_GetResolution:
-			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
+			if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) == REQREC_ENDPOINT)
 			{
 				uint8_t  EndpointProperty = USB_ControlRequest.bRequest;
 				uint8_t  EndpointAddress  = (uint8_t)USB_ControlRequest.wIndex;
@@ -150,7 +151,7 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 					Endpoint_ClearOUT();
 				}
 			}
-			else if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
+			else if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT) == REQREC_INTERFACE)
 			{
 				uint8_t  Property    = USB_ControlRequest.bRequest;
 				uint8_t  Entity      = (USB_ControlRequest.wIndex >> 8);
@@ -174,39 +175,15 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
 bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
 {
 	memset(&AudioInterfaceInfo->State, 0x00, sizeof(AudioInterfaceInfo->State));
+	
+	AudioInterfaceInfo->Config.DataINEndpoint.Type  = EP_TYPE_ISOCHRONOUS;
+	AudioInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_ISOCHRONOUS;
 
-	for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Direction;
-		bool     DoubleBanked;
+	if (!(Endpoint_ConfigureEndpointTable(&AudioInterfaceInfo->Config.DataINEndpoint, 1)))
+	  return false;
 
-		if (EndpointNum == AudioInterfaceInfo->Config.DataINEndpointNumber)
-		{
-			Size         = AudioInterfaceInfo->Config.DataINEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_ISOCHRONOUS;
-			DoubleBanked = true;
-		}
-		else if (EndpointNum == AudioInterfaceInfo->Config.DataOUTEndpointNumber)
-		{
-			Size         = AudioInterfaceInfo->Config.DataOUTEndpointSize;
-			Direction    = ENDPOINT_DIR_OUT;
-			Type         = EP_TYPE_ISOCHRONOUS;
-			DoubleBanked = true;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
-		                                 DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-		{
-			return false;
-		}
-	}
+	if (!(Endpoint_ConfigureEndpointTable(&AudioInterfaceInfo->Config.DataOUTEndpoint, 1)))
+	  return false;
 
 	return true;
 }
diff --git a/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h b/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h
index 239126607..a8bfc7833 100644
--- a/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h
@@ -86,19 +86,8 @@
 														*   structure controls.
 														*/
 
-					uint8_t  DataINEndpointNumber; /**< Endpoint number of the incoming Audio Streaming data, if available
-													*   (zero if unused).
-													*/
-					uint16_t DataINEndpointSize; /**< Size in bytes of the incoming Audio Streaming data endpoint, if available
-												  *   (zero if unused).
-												  */
-
-					uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the outgoing Audio Streaming data, if available
-													 *   (zero if unused).
-													 */
-					uint16_t DataOUTEndpointSize; /**< Size in bytes of the outgoing Audio Streaming data endpoint, if available
-												   *   (zero if unused).
-												   */
+					USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */
+					USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -226,7 +215,7 @@
 				if ((USB_DeviceState != DEVICE_STATE_Configured) || !(AudioInterfaceInfo->State.InterfaceEnabled))
 				  return false;
 
-				Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);
+				Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpoint.Address);
 				return Endpoint_IsOUTReceived();
 			}
 
@@ -247,7 +236,7 @@
 				if ((USB_DeviceState != DEVICE_STATE_Configured) || !(AudioInterfaceInfo->State.InterfaceEnabled))
 				  return false;
 
-				Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);
+				Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpoint.Address);
 				return Endpoint_IsINReady();
 			}
 
@@ -341,7 +330,7 @@
 			{
 				Endpoint_Write_8(Sample);
 
-				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpointSize)
+				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpoint.Size)
 				  Endpoint_ClearIN();
 			}
 
@@ -360,7 +349,7 @@
 			{
 				Endpoint_Write_16_LE(Sample);
 
-				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpointSize)
+				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpoint.Size)
 				  Endpoint_ClearIN();
 			}
 
@@ -380,7 +369,7 @@
 				Endpoint_Write_16_LE(Sample);
 				Endpoint_Write_8(Sample >> 16);
 
-				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpointSize)
+				if (Endpoint_BytesInEndpoint() == AudioInterfaceInfo->Config.DataINEndpoint.Size)
 				  Endpoint_ClearIN();
 			}
 
diff --git a/LUFA/Drivers/USB/Class/Device/CDCClassDevice.c b/LUFA/Drivers/USB/Class/Device/CDCClassDevice.c
index 5b5343860..ff0f9bb55 100644
--- a/LUFA/Drivers/USB/Class/Device/CDCClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/CDCClassDevice.c
@@ -69,8 +69,12 @@ void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInter
 			{
 				Endpoint_ClearSETUP();
 
-				while (!(Endpoint_IsOUTReceived()));
-
+				while (!(Endpoint_IsOUTReceived()))
+				{
+					if (USB_DeviceState == DEVICE_STATE_Unattached)
+					  return;
+				}
+				
 				CDCInterfaceInfo->State.LineEncoding.BaudRateBPS = Endpoint_Read_32_LE();
 				CDCInterfaceInfo->State.LineEncoding.CharFormat  = Endpoint_Read_8();
 				CDCInterfaceInfo->State.LineEncoding.ParityType  = Endpoint_Read_8();
@@ -112,45 +116,18 @@ bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfac
 {
 	memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
 
-	for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Direction;
-		bool     DoubleBanked;
+	CDCInterfaceInfo->Config.DataINEndpoint.Type       = EP_TYPE_BULK;
+	CDCInterfaceInfo->Config.DataOUTEndpoint.Type      = EP_TYPE_BULK;
+	CDCInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
 
-		if (EndpointNum == CDCInterfaceInfo->Config.DataINEndpointNumber)
-		{
-			Size         = CDCInterfaceInfo->Config.DataINEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = CDCInterfaceInfo->Config.DataINEndpointDoubleBank;
-		}
-		else if (EndpointNum == CDCInterfaceInfo->Config.DataOUTEndpointNumber)
-		{
-			Size         = CDCInterfaceInfo->Config.DataOUTEndpointSize;
-			Direction    = ENDPOINT_DIR_OUT;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = CDCInterfaceInfo->Config.DataOUTEndpointDoubleBank;
-		}
-		else if (EndpointNum == CDCInterfaceInfo->Config.NotificationEndpointNumber)
-		{
-			Size         = CDCInterfaceInfo->Config.NotificationEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_INTERRUPT;
-			DoubleBanked = CDCInterfaceInfo->Config.NotificationEndpointDoubleBank;
-		}
-		else
-		{
-			continue;
-		}
+	if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataINEndpoint, 1)))
+	  return false;
 
-		if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
-		                                 DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-		{
-			return false;
-		}
-	}
+	if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.DataOUTEndpoint, 1)))
+	  return false;
+
+	if (!(Endpoint_ConfigureEndpointTable(&CDCInterfaceInfo->Config.NotificationEndpoint, 1)))
+	  return false;
 
 	return true;
 }
@@ -171,7 +148,7 @@ uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo
 	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return ENDPOINT_RWSTREAM_DeviceDisconnected;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 	return Endpoint_Write_Stream_LE(String, strlen(String), NULL);
 }
 
@@ -182,7 +159,7 @@ uint8_t CDC_Device_SendData(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return ENDPOINT_RWSTREAM_DeviceDisconnected;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 	return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
 }
 
@@ -192,7 +169,7 @@ uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
 	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return ENDPOINT_RWSTREAM_DeviceDisconnected;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 
 	if (!(Endpoint_IsReadWriteAllowed()))
 	{
@@ -215,7 +192,7 @@ uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 
 	uint8_t ErrorCode;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpoint.Address);
 
 	if (!(Endpoint_BytesInEndpoint()))
 	  return ENDPOINT_READYWAIT_NoError;
@@ -240,7 +217,7 @@ uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterface
 	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return 0;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 
 	if (Endpoint_IsOUTReceived())
 	{
@@ -267,7 +244,7 @@ int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInf
 
 	int16_t ReceivedByte = -1;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpoint.Address);
 
 	if (Endpoint_IsOUTReceived())
 	{
@@ -286,7 +263,7 @@ void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDC
 	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpoint.Address);
 
 	USB_Request_Header_t Notification = (USB_Request_Header_t)
 		{
diff --git a/LUFA/Drivers/USB/Class/Device/CDCClassDevice.h b/LUFA/Drivers/USB/Class/Device/CDCClassDevice.h
index cc0dd1b15..508c234d7 100644
--- a/LUFA/Drivers/USB/Class/Device/CDCClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/CDCClassDevice.h
@@ -99,19 +99,11 @@
 			{
 				struct
 				{
-					uint8_t  ControlInterfaceNumber; /**< Interface number of the CDC control interface within the device. */
-
-					uint8_t  DataINEndpointNumber; /**< Endpoint number of the CDC interface's IN data endpoint. */
-					uint16_t DataINEndpointSize; /**< Size in bytes of the CDC interface's IN data endpoint. */
-					bool     DataINEndpointDoubleBank; /**< Indicates if the CDC interface's IN data endpoint should use double banking. */
-
-					uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the CDC interface's OUT data endpoint. */
-					uint16_t DataOUTEndpointSize;  /**< Size in bytes of the CDC interface's OUT data endpoint. */
-					bool     DataOUTEndpointDoubleBank; /**< Indicates if the CDC interface's OUT data endpoint should use double banking. */
-
-					uint8_t  NotificationEndpointNumber; /**< Endpoint number of the CDC interface's IN notification endpoint, if used. */
-					uint16_t NotificationEndpointSize;  /**< Size in bytes of the CDC interface's IN notification endpoint, if used. */
-					bool     NotificationEndpointDoubleBank; /**< Indicates if the CDC interface's notification endpoint should use double banking. */
+					uint8_t ControlInterfaceNumber; /**< Interface number of the CDC control interface within the device. */
+					
+					USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */
+					USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */
+					USB_Endpoint_Table_t NotificationEndpoint; /**< Notification IN Endpoint configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
diff --git a/LUFA/Drivers/USB/Class/Device/HIDClassDevice.c b/LUFA/Drivers/USB/Class/Device/HIDClassDevice.c
index 5c8d878e7..e4b565327 100644
--- a/LUFA/Drivers/USB/Class/Device/HIDClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/HIDClassDevice.c
@@ -141,13 +141,11 @@ bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfac
 	HIDInterfaceInfo->State.UsingReportProtocol = true;
 	HIDInterfaceInfo->State.IdleCount           = 500;
 
-	if (!(Endpoint_ConfigureEndpoint(HIDInterfaceInfo->Config.ReportINEndpointNumber, EP_TYPE_INTERRUPT,
-									 ENDPOINT_DIR_IN, HIDInterfaceInfo->Config.ReportINEndpointSize,
-									 HIDInterfaceInfo->Config.ReportINEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-	{
-		return false;
-	}
+	HIDInterfaceInfo->Config.ReportINEndpoint.Type = EP_TYPE_INTERRUPT;
 
+	if (!(Endpoint_ConfigureEndpointTable(&HIDInterfaceInfo->Config.ReportINEndpoint, 1)))
+	  return false;	
+	
 	return true;
 }
 
@@ -159,7 +157,7 @@ void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
 	if (HIDInterfaceInfo->State.PrevFrameNum == USB_Device_GetFrameNumber())
 	  return;
 	  
-	Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpointNumber);
+	Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpoint.Address);
 
 	if (Endpoint_IsReadWriteAllowed())
 	{
@@ -184,7 +182,7 @@ void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
 		{
 			HIDInterfaceInfo->State.IdleMSRemaining = HIDInterfaceInfo->State.IdleCount;
 
-			Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpointNumber);
+			Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpoint.Address);
 
 			if (ReportID)
 			  Endpoint_Write_8(ReportID);
diff --git a/LUFA/Drivers/USB/Class/Device/HIDClassDevice.h b/LUFA/Drivers/USB/Class/Device/HIDClassDevice.h
index a6361c6b0..e358dec75 100644
--- a/LUFA/Drivers/USB/Class/Device/HIDClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/HIDClassDevice.h
@@ -85,9 +85,7 @@
 				{
 					uint8_t  InterfaceNumber; /**< Interface number of the HID interface within the device. */
 
-					uint8_t  ReportINEndpointNumber; /**< Endpoint number of the HID interface's IN report endpoint. */
-					uint16_t ReportINEndpointSize; /**< Size in bytes of the HID interface's IN report endpoint. */
-					bool     ReportINEndpointDoubleBank; /**< Indicates if the HID interface's IN report endpoint should use double banking. */
+					USB_Endpoint_Table_t ReportINEndpoint; /**< Data IN HID report endpoint configuration table. */
 
 					void*    PrevReportINBuffer; /**< Pointer to a buffer where the previously created HID input report can be
 					                              *  stored by the driver, for comparison purposes to detect report changes that
diff --git a/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.c b/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.c
index 9f0506e56..c9553a413 100644
--- a/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.c
@@ -41,38 +41,14 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInter
 {
 	memset(&MIDIInterfaceInfo->State, 0x00, sizeof(MIDIInterfaceInfo->State));
 
-	for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Direction;
-		bool     DoubleBanked;
-
-		if (EndpointNum == MIDIInterfaceInfo->Config.DataINEndpointNumber)
-		{
-			Size         = MIDIInterfaceInfo->Config.DataINEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = MIDIInterfaceInfo->Config.DataINEndpointDoubleBank;
-		}
-		else if (EndpointNum == MIDIInterfaceInfo->Config.DataOUTEndpointNumber)
-		{
-			Size         = MIDIInterfaceInfo->Config.DataOUTEndpointSize;
-			Direction    = ENDPOINT_DIR_OUT;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = MIDIInterfaceInfo->Config.DataOUTEndpointDoubleBank;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
-		                                 DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-		{
-			return false;
-		}
-	}
+	MIDIInterfaceInfo->Config.DataINEndpoint.Type  = EP_TYPE_BULK;
+	MIDIInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
+
+	if (!(Endpoint_ConfigureEndpointTable(&MIDIInterfaceInfo->Config.DataINEndpoint, 1)))
+	  return false;
+
+	if (!(Endpoint_ConfigureEndpointTable(&MIDIInterfaceInfo->Config.DataOUTEndpoint, 1)))
+	  return false;
 
 	return true;
 }
@@ -95,7 +71,7 @@ uint8_t MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInter
 
 	uint8_t ErrorCode;
 
-	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataINEndpoint.Address);
 
 	if ((ErrorCode = Endpoint_Write_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL)) != ENDPOINT_RWSTREAM_NoError)
 	  return ErrorCode;
@@ -113,7 +89,7 @@ uint8_t MIDI_Device_Flush(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
 
 	uint8_t ErrorCode;
 
-	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataINEndpoint.Address);
 
 	if (Endpoint_BytesInEndpoint())
 	{
@@ -132,7 +108,7 @@ bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInter
 	if (USB_DeviceState != DEVICE_STATE_Configured)
 	  return false;
 
-	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(MIDIInterfaceInfo->Config.DataOUTEndpoint.Address);
 
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  return false;
diff --git a/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.h b/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.h
index 4fe49af1f..2703600ea 100644
--- a/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/MIDIClassDevice.h
@@ -81,13 +81,8 @@
 				{
 					uint8_t  StreamingInterfaceNumber; /**< Index of the Audio Streaming interface within the device this structure controls. */
 
-					uint8_t  DataINEndpointNumber; /**< Endpoint number of the incoming MIDI IN data, if available (zero if unused). */
-					uint16_t DataINEndpointSize; /**< Size in bytes of the incoming MIDI IN data endpoint, if available (zero if unused). */
-					bool     DataINEndpointDoubleBank; /**< Indicates if the MIDI interface's IN data endpoint should use double banking. */
-
-					uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the outgoing MIDI OUT data, if available (zero if unused). */
-					uint16_t DataOUTEndpointSize; /**< Size in bytes of the outgoing MIDI OUT data endpoint, if available (zero if unused). */
-					bool     DataOUTEndpointDoubleBank; /**< Indicates if the MIDI interface's OUT data endpoint should use double banking. */
+					USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */
+					USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
diff --git a/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.c b/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.c
index 6294a0a94..153ebbc89 100644
--- a/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.c
@@ -75,38 +75,14 @@ bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 {
 	memset(&MSInterfaceInfo->State, 0x00, sizeof(MSInterfaceInfo->State));
 
-	for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Direction;
-		bool     DoubleBanked;
+	MSInterfaceInfo->Config.DataINEndpoint.Type  = EP_TYPE_BULK;
+	MSInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
 
-		if (EndpointNum == MSInterfaceInfo->Config.DataINEndpointNumber)
-		{
-			Size         = MSInterfaceInfo->Config.DataINEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = MSInterfaceInfo->Config.DataINEndpointDoubleBank;
-		}
-		else if (EndpointNum == MSInterfaceInfo->Config.DataOUTEndpointNumber)
-		{
-			Size         = MSInterfaceInfo->Config.DataOUTEndpointSize;
-			Direction    = ENDPOINT_DIR_OUT;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = MSInterfaceInfo->Config.DataOUTEndpointDoubleBank;
-		}
-		else
-		{
-			continue;
-		}
+	if (!(Endpoint_ConfigureEndpointTable(&MSInterfaceInfo->Config.DataINEndpoint, 1)))
+	  return false;
 
-		if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
-		                                 DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-		{
-			return false;
-		}
-	}
+	if (!(Endpoint_ConfigureEndpointTable(&MSInterfaceInfo->Config.DataOUTEndpoint, 1)))
+	  return false;
 
 	return true;
 }
@@ -116,14 +92,14 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 	if (USB_DeviceState != DEVICE_STATE_Configured)
 	  return;
 
-	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpoint.Address);
 
-	if (Endpoint_IsReadWriteAllowed())
+	if (Endpoint_IsOUTReceived())
 	{
 		if (MS_Device_ReadInCommandBlock(MSInterfaceInfo))
 		{
 			if (MSInterfaceInfo->State.CommandBlock.Flags & MS_COMMAND_DIR_DATA_IN)
-			  Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
+			  Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpoint.Address);
 
 			bool SCSICommandResult = CALLBACK_MS_Device_SCSICommandReceived(MSInterfaceInfo);
 
@@ -141,13 +117,13 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 
 	if (MSInterfaceInfo->State.IsMassStoreReset)
 	{
-		Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
-		Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
+		Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataOUTEndpoint.Address);
+		Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataINEndpoint.Address);
 
-		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
+		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpoint.Address);
 		Endpoint_ClearStall();
 		Endpoint_ResetDataToggle();
-		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
+		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpoint.Address);
 		Endpoint_ClearStall();
 		Endpoint_ResetDataToggle();
 
@@ -159,8 +135,8 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInte
 {
 	uint16_t BytesProcessed;
 
-	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
-
+	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpoint.Address);
+	
 	BytesProcessed = 0;
 	while (Endpoint_Read_Stream_LE(&MSInterfaceInfo->State.CommandBlock,
 	                               (sizeof(MS_CommandBlockWrapper_t) - 16), &BytesProcessed) ==
@@ -175,9 +151,9 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInte
 		(MSInterfaceInfo->State.CommandBlock.Flags              & 0x1F)                              ||
 		(MSInterfaceInfo->State.CommandBlock.SCSICommandLength == 0)                                 ||
 		(MSInterfaceInfo->State.CommandBlock.SCSICommandLength >  16))
-	{
+	{		
 		Endpoint_StallTransaction();
-		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
+		Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpoint.Address);
 		Endpoint_StallTransaction();
 
 		return false;
@@ -199,7 +175,7 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInte
 
 static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 {
-	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpoint.Address);
 
 	while (Endpoint_IsStalled())
 	{
@@ -211,7 +187,7 @@ static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInt
 		  return;
 	}
 
-	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpoint.Address);
 
 	while (Endpoint_IsStalled())
 	{
diff --git a/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.h b/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.h
index c2d536ce2..6b490eca1 100644
--- a/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/MassStorageClassDevice.h
@@ -81,13 +81,8 @@
 				{
 					uint8_t  InterfaceNumber; /**< Interface number of the Mass Storage interface within the device. */
 
-					uint8_t  DataINEndpointNumber; /**< Endpoint number of the Mass Storage interface's IN data endpoint. */
-					uint16_t DataINEndpointSize; /**< Size in bytes of the Mass Storage interface's IN data endpoint. */
-					bool     DataINEndpointDoubleBank; /**< Indicates if the Mass Storage interface's IN data endpoint should use double banking. */
-
-					uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the Mass Storage interface's OUT data endpoint. */
-					uint16_t DataOUTEndpointSize;  /**< Size in bytes of the Mass Storage interface's OUT data endpoint. */
-					bool     DataOUTEndpointDoubleBank; /**< Indicates if the Mass Storage interface's OUT data endpoint should use double banking. */
+					USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */
+					USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */
 
 					uint8_t  TotalLUNs; /**< Total number of logical drives in the Mass Storage interface. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
diff --git a/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c b/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c
index f78a5abf2..e5aa40cd0 100644
--- a/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c
+++ b/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c
@@ -115,45 +115,18 @@ bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISIn
 {
 	memset(&RNDISInterfaceInfo->State, 0x00, sizeof(RNDISInterfaceInfo->State));
 
-	for (uint8_t EndpointNum = 1; EndpointNum < ENDPOINT_TOTAL_ENDPOINTS; EndpointNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Direction;
-		bool     DoubleBanked;
-
-		if (EndpointNum == RNDISInterfaceInfo->Config.DataINEndpointNumber)
-		{
-			Size         = RNDISInterfaceInfo->Config.DataINEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = RNDISInterfaceInfo->Config.DataINEndpointDoubleBank;
-		}
-		else if (EndpointNum == RNDISInterfaceInfo->Config.DataOUTEndpointNumber)
-		{
-			Size         = RNDISInterfaceInfo->Config.DataOUTEndpointSize;
-			Direction    = ENDPOINT_DIR_OUT;
-			Type         = EP_TYPE_BULK;
-			DoubleBanked = RNDISInterfaceInfo->Config.DataOUTEndpointDoubleBank;
-		}
-		else if (EndpointNum == RNDISInterfaceInfo->Config.NotificationEndpointNumber)
-		{
-			Size         = RNDISInterfaceInfo->Config.NotificationEndpointSize;
-			Direction    = ENDPOINT_DIR_IN;
-			Type         = EP_TYPE_INTERRUPT;
-			DoubleBanked = RNDISInterfaceInfo->Config.NotificationEndpointDoubleBank;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Endpoint_ConfigureEndpoint(EndpointNum, Type, Direction, Size,
-		                                 DoubleBanked ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
-		{
-			return false;
-		}
-	}
+	RNDISInterfaceInfo->Config.DataINEndpoint.Type       = EP_TYPE_BULK;
+	RNDISInterfaceInfo->Config.DataOUTEndpoint.Type      = EP_TYPE_BULK;
+	RNDISInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
+
+	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.DataINEndpoint, 1)))
+	  return false;
+
+	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.DataOUTEndpoint, 1)))
+	  return false;
+
+	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.NotificationEndpoint, 1)))
+	  return false;
 
 	return true;
 }
@@ -163,7 +136,7 @@ void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo
 	if (USB_DeviceState != DEVICE_STATE_Configured)
 	  return;
 
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.NotificationEndpointNumber);
+	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.NotificationEndpoint.Address);
 
 	if (Endpoint_IsINReady() && RNDISInterfaceInfo->State.ResponseReady)
 	{
@@ -454,7 +427,7 @@ bool RNDIS_Device_IsPacketReceived(USB_ClassInfo_RNDIS_Device_t* const RNDISInte
 		return false;
 	}
 
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpoint.Address);
 	return Endpoint_IsOUTReceived();
 }
 
@@ -468,7 +441,7 @@ uint8_t RNDIS_Device_ReadPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfa
 		return ENDPOINT_RWSTREAM_DeviceDisconnected;
 	}
 
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpointNumber);
+	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpoint.Address);
 
 	*PacketLength = 0;
 
@@ -505,7 +478,7 @@ uint8_t RNDIS_Device_SendPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfa
 		return ENDPOINT_RWSTREAM_DeviceDisconnected;
 	}
 
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber);
+	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataINEndpoint.Address);
 
 	if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 	  return ErrorCode;
diff --git a/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.h b/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.h
index ccd20e38e..33b807da9 100644
--- a/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.h
+++ b/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.h
@@ -81,17 +81,9 @@
 				{
 					uint8_t  ControlInterfaceNumber; /**< Interface number of the RNDIS control interface within the device. */
 
-					uint8_t  DataINEndpointNumber; /**< Endpoint number of the RNDIS interface's IN data endpoint. */
-					uint16_t DataINEndpointSize; /**< Size in bytes of the RNDIS interface's IN data endpoint. */
-					bool     DataINEndpointDoubleBank; /**< Indicates if the RNDIS interface's IN data endpoint should use double banking. */
-
-					uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the RNDIS interface's OUT data endpoint. */
-					uint16_t DataOUTEndpointSize;  /**< Size in bytes of the RNDIS interface's OUT data endpoint. */
-					bool     DataOUTEndpointDoubleBank; /**< Indicates if the RNDIS interface's OUT data endpoint should use double banking. */
-
-					uint8_t  NotificationEndpointNumber; /**< Endpoint number of the RNDIS interface's IN notification endpoint, if used. */
-					uint16_t NotificationEndpointSize;  /**< Size in bytes of the RNDIS interface's IN notification endpoint, if used. */
-					bool     NotificationEndpointDoubleBank; /**< Indicates if the RNDIS interface's notification endpoint should use double banking. */
+					USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */
+					USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */
+					USB_Endpoint_Table_t NotificationEndpoint; /**< Notification IN Endpoint configuration table. */
 
 					char*         AdapterVendorDescription; /**< String description of the adapter vendor. */
 					MAC_Address_t AdapterMACAddress; /**< MAC address of the adapter. */
diff --git a/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.c b/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.c
index eb4c2530d..7c564e012 100644
--- a/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.c
@@ -89,45 +89,19 @@ uint8_t AOA_Host_ConfigurePipes(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo
 		  DataOUTEndpoint = EndpointData;

 	}

 

-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)

-	{

-		uint16_t Size;

-		uint8_t  Type;

-		uint8_t  Token;

-		uint8_t  EndpointAddress;

-		bool     DoubleBanked;

-

-		if (PipeNum == AOAInterfaceInfo->Config.DataINPipeNumber)

-		{

-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);

-			EndpointAddress = DataINEndpoint->EndpointAddress;

-			Token           = PIPE_TOKEN_IN;

-			Type            = EP_TYPE_BULK;

-			DoubleBanked    = AOAInterfaceInfo->Config.DataINPipeDoubleBank;

-

-			AOAInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;

-		}

-		else if (PipeNum == AOAInterfaceInfo->Config.DataOUTPipeNumber)

-		{

-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);

-			EndpointAddress = DataOUTEndpoint->EndpointAddress;

-			Token           = PIPE_TOKEN_OUT;

-			Type            = EP_TYPE_BULK;

-			DoubleBanked    = AOAInterfaceInfo->Config.DataOUTPipeDoubleBank;

-

-			AOAInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;

-		}

-		else

-		{

-			continue;

-		}

-		

-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,

-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))

-		{

-			return AOA_ENUMERROR_PipeConfigurationFailed;

-		}

-	}

+	AOAInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);

+	AOAInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;

+	AOAInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;

+	

+	AOAInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);

+	AOAInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;

+	AOAInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;

+	

+	if (!(Pipe_ConfigurePipeTable(&AOAInterfaceInfo->Config.DataINPipe, 1)))

+	  return false;

+	

+	if (!(Pipe_ConfigurePipeTable(&AOAInterfaceInfo->Config.DataOUTPipe, 1)))

+	  return false;

 

 	AOAInterfaceInfo->State.IsActive        = true;

 	AOAInterfaceInfo->State.InterfaceNumber = AOAInterface->InterfaceNumber;

@@ -260,7 +234,7 @@ uint8_t AOA_Host_SendData(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 

 	uint8_t ErrorCode;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipe.Address);

 

 	Pipe_Unfreeze();

 	ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL);

@@ -277,7 +251,7 @@ uint8_t AOA_Host_SendString(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 

 	uint8_t ErrorCode;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipe.Address);

 

 	Pipe_Unfreeze();

 	ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL);

@@ -294,7 +268,7 @@ uint8_t AOA_Host_SendByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 

 	uint8_t ErrorCode;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipe.Address);

 	Pipe_Unfreeze();

 

 	if (!(Pipe_IsReadWriteAllowed()))

@@ -316,7 +290,7 @@ uint16_t AOA_Host_BytesReceived(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo
 	if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))

 	  return 0;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipe.Address);

 	Pipe_Unfreeze();

 

 	if (Pipe_IsINReceived())

@@ -348,7 +322,7 @@ int16_t AOA_Host_ReceiveByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 

 	int16_t ReceivedByte = -1;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipe.Address);

 	Pipe_Unfreeze();

 

 	if (Pipe_IsINReceived())

@@ -372,7 +346,7 @@ uint8_t AOA_Host_Flush(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 

 	uint8_t ErrorCode;

 

-	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);

+	Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipe.Address);

 	Pipe_Unfreeze();

 

 	if (!(Pipe_BytesInPipe()))

diff --git a/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.h b/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.h
index 0ec44e715..678feda45 100644
--- a/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/AndroidAccessoryClassHost.h
@@ -85,11 +85,8 @@
 			{

 				struct

 				{

-					uint8_t  DataINPipeNumber; /**< Pipe number of the AOA interface's IN data pipe. */

-					bool     DataINPipeDoubleBank; /**< Indicates if the AOA interface's IN data pipe should use double banking. */

-

-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the AOA interface's OUT data pipe. */

-					bool     DataOUTPipeDoubleBank; /**< Indicates if the AOA interface's OUT data pipe should use double banking. */

+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */

+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */

 					

 					char*    PropertyStrings[AOA_STRING_TOTAL_STRINGS]; /**< Android Accessory property strings, sent to identify the accessory when the

 					                                                     *   Android device is switched into Open Accessory mode. */

@@ -103,9 +100,6 @@
 					                *   Configured state.

 					                */

 					uint8_t  InterfaceNumber; /**< Interface index of the AOA interface within the attached device. */

-

-					uint16_t DataINPipeSize; /**< Size in bytes of the AOA interface's IN data pipe. */

-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the AOA interface's OUT data pipe. */

 				} State; /**< State data for the USB class interface within the device. All elements in this section

 						  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when

 						  *   the interface is enumerated.

diff --git a/LUFA/Drivers/USB/Class/Host/AudioClassHost.c b/LUFA/Drivers/USB/Class/Host/AudioClassHost.c
index e5591ec1d..12783a6a0 100644
--- a/LUFA/Drivers/USB/Class/Host/AudioClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/AudioClassHost.c
@@ -51,8 +51,8 @@ uint8_t Audio_Host_ConfigurePipes(USB_ClassInfo_Audio_Host_t* const AudioInterfa
 	if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
 	  return AUDIO_ENUMERROR_InvalidConfigDescriptor;
 
-	while ((AudioInterfaceInfo->Config.DataINPipeNumber  && !(DataINEndpoint)) ||
-	       (AudioInterfaceInfo->Config.DataOUTPipeNumber && !(DataOUTEndpoint)))
+	while ((AudioInterfaceInfo->Config.DataINPipe.Address  && !(DataINEndpoint)) ||
+	       (AudioInterfaceInfo->Config.DataOUTPipe.Address && !(DataOUTEndpoint)))
 	{
 		if (!(AudioControlInterface) ||
 		    USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
@@ -93,45 +93,21 @@ uint8_t Audio_Host_ConfigurePipes(USB_ClassInfo_Audio_Host_t* const AudioInterfa
 		  DataOUTEndpoint = EndpointData;
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		bool     DoubleBanked;
-
-		if (PipeNum == AudioInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_ISOCHRONOUS;
-			DoubleBanked    = true;
-
-			AudioInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == AudioInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_ISOCHRONOUS;
-			DoubleBanked    = true;
-
-			AudioInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return AUDIO_ENUMERROR_PipeConfigurationFailed;
-		}
-	}
+	AudioInterfaceInfo->Config.DataINPipe.Size   = le16_to_cpu(DataINEndpoint->EndpointSize);
+	AudioInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	AudioInterfaceInfo->Config.DataINPipe.Type   = EP_TYPE_ISOCHRONOUS;
+	AudioInterfaceInfo->Config.DataINPipe.Banks  = 2;
+	
+	AudioInterfaceInfo->Config.DataOUTPipe.Size  = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	AudioInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	AudioInterfaceInfo->Config.DataOUTPipe.Type  = EP_TYPE_ISOCHRONOUS;
+	AudioInterfaceInfo->Config.DataOUTPipe.Banks = 2;
+	
+	if (!(Pipe_ConfigurePipeTable(&AudioInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&AudioInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
 
 	AudioInterfaceInfo->State.ControlInterfaceNumber    = AudioControlInterface->InterfaceNumber;
 	AudioInterfaceInfo->State.StreamingInterfaceNumber  = AudioStreamingInterface->InterfaceNumber;
diff --git a/LUFA/Drivers/USB/Class/Host/AudioClassHost.h b/LUFA/Drivers/USB/Class/Host/AudioClassHost.h
index a6e425d5f..2d39aa9ca 100644
--- a/LUFA/Drivers/USB/Class/Host/AudioClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/AudioClassHost.h
@@ -79,14 +79,8 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the Audio interface's IN data pipe. If this interface should not
-					                            *   bind to an IN endpoint, this may be set to 0 to disable audio input streaming for
-					                            *   this driver instance.
-					                            */
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the Audio interface's OUT data pipe. If this interface should not
-					                            *   bind to an OUT endpoint, this may be set to 0 to disable audio output streaming for
-					                            *   this driver instance.
-					                            */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -100,9 +94,6 @@
 					uint8_t StreamingInterfaceNumber; /**< Interface index of the Audio Streaming interface within the attached device. */
 
 					uint8_t EnabledStreamingAltIndex; /**< Alternative setting index of the Audio Streaming interface when the stream is enabled. */
-
-					uint16_t DataINPipeSize; /**< Size in bytes of the Audio interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the Audio interface's OUT data pipe. */
 				} State; /**< State data for the USB class interface within the device. All elements in this section
 						  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when
 						  *   the interface is enumerated.
@@ -201,7 +192,7 @@
 
 				bool SampleReceived = false;
 
-				Pipe_SelectPipe(AudioInterfaceInfo->Config.DataINPipeNumber);
+				Pipe_SelectPipe(AudioInterfaceInfo->Config.DataINPipe.Address);
 				Pipe_Unfreeze();
 				SampleReceived = Pipe_IsINReceived();
 				Pipe_Freeze();
@@ -226,7 +217,7 @@
 				if ((USB_HostState != HOST_STATE_Configured) || !(AudioInterfaceInfo->State.IsActive))
 				  return false;
 
-				Pipe_SelectPipe(AudioInterfaceInfo->Config.DataOUTPipeNumber);
+				Pipe_SelectPipe(AudioInterfaceInfo->Config.DataOUTPipe.Address);
 				return Pipe_IsOUTReady();
 			}
 
diff --git a/LUFA/Drivers/USB/Class/Host/CDCClassHost.c b/LUFA/Drivers/USB/Class/Host/CDCClassHost.c
index 63df6b0c5..8c79e9c22 100644
--- a/LUFA/Drivers/USB/Class/Host/CDCClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/CDCClassHost.c
@@ -99,62 +99,26 @@ uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo
 		}
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		uint8_t  InterruptPeriod;
-		bool     DoubleBanked;
-
-		if (PipeNum == CDCInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = CDCInterfaceInfo->Config.DataINPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			CDCInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == CDCInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = CDCInterfaceInfo->Config.DataOUTPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			CDCInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else if (PipeNum == CDCInterfaceInfo->Config.NotificationPipeNumber)
-		{
-			Size            = le16_to_cpu(NotificationEndpoint->EndpointSize);
-			EndpointAddress = NotificationEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_INTERRUPT;
-			DoubleBanked    = CDCInterfaceInfo->Config.NotificationPipeDoubleBank;
-			InterruptPeriod = NotificationEndpoint->PollingIntervalMS;
-
-			CDCInterfaceInfo->State.NotificationPipeSize = NotificationEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return CDC_ENUMERROR_PipeConfigurationFailed;
-		}
-
-		if (InterruptPeriod)
-		  Pipe_SetInterruptPeriod(InterruptPeriod);
-	}
+	CDCInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	CDCInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	CDCInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	CDCInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	CDCInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	CDCInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	CDCInterfaceInfo->Config.NotificationPipe.Size = le16_to_cpu(NotificationEndpoint->EndpointSize);
+	CDCInterfaceInfo->Config.NotificationPipe.EndpointAddress = NotificationEndpoint->EndpointAddress;
+	CDCInterfaceInfo->Config.NotificationPipe.Type = EP_TYPE_INTERRUPT;
+
+	if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
+
+	if (!(Pipe_ConfigurePipeTable(&CDCInterfaceInfo->Config.NotificationPipe, 1)))
+	  return false;
 
 	CDCInterfaceInfo->State.ControlInterfaceNumber = CDCControlInterface->InterfaceNumber;
 	CDCInterfaceInfo->State.ControlLineStates.HostToDevice = (CDC_CONTROL_LINE_OUT_RTS | CDC_CONTROL_LINE_OUT_DTR);
@@ -231,7 +195,7 @@ void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 	if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 	  return;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_IsINReceived())
@@ -321,7 +285,7 @@ uint8_t CDC_Host_SendData(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
 
 	Pipe_Unfreeze();
 	ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL);
@@ -338,7 +302,7 @@ uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
 
 	Pipe_Unfreeze();
 	ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL);
@@ -355,7 +319,7 @@ uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if (!(Pipe_IsReadWriteAllowed()))
@@ -377,7 +341,7 @@ uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo
 	if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
 	  return 0;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_IsINReceived())
@@ -409,7 +373,7 @@ int16_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 
 	int16_t ReceivedByte = -1;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_IsINReceived())
@@ -433,7 +397,7 @@ uint8_t CDC_Host_Flush(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(CDCInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if (!(Pipe_BytesInPipe()))
diff --git a/LUFA/Drivers/USB/Class/Host/CDCClassHost.h b/LUFA/Drivers/USB/Class/Host/CDCClassHost.h
index 5a8df2414..4d79ed951 100644
--- a/LUFA/Drivers/USB/Class/Host/CDCClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/CDCClassHost.h
@@ -81,14 +81,9 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the CDC interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the CDC interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the CDC interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the CDC interface's OUT data pipe should use double banking. */
-
-					uint8_t  NotificationPipeNumber; /**< Pipe number of the CDC interface's IN notification endpoint, if used. */
-					bool     NotificationPipeDoubleBank; /**< Indicates if the CDC interface's notification pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
+					USB_Pipe_Table_t NotificationPipe; /**< Notification IN Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -100,10 +95,6 @@
 					                */
 					uint8_t  ControlInterfaceNumber; /**< Interface index of the CDC-ACM control interface within the attached device. */
 
-					uint16_t DataINPipeSize; /**< Size in bytes of the CDC interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the CDC interface's OUT data pipe. */
-					uint16_t NotificationPipeSize;  /**< Size in bytes of the CDC interface's IN notification pipe, if used. */
-
 					struct
 					{
 						uint16_t HostToDevice; /**< Control line states from the host to device, as a set of \c CDC_CONTROL_LINE_OUT_*
diff --git a/LUFA/Drivers/USB/Class/Host/HIDClassHost.c b/LUFA/Drivers/USB/Class/Host/HIDClassHost.c
index f51bdf74f..dad6a5afc 100644
--- a/LUFA/Drivers/USB/Class/Host/HIDClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/HIDClassHost.c
@@ -94,55 +94,19 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
 		  DataOUTEndpoint = EndpointData;
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		uint8_t  InterruptPeriod;
-		bool     DoubleBanked;
-
-		if (PipeNum == HIDInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_INTERRUPT;
-			DoubleBanked    = HIDInterfaceInfo->Config.DataINPipeDoubleBank;
-			InterruptPeriod = DataINEndpoint->PollingIntervalMS;
-
-			HIDInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == HIDInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			if (DataOUTEndpoint == NULL)
-			  continue;
-
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_INTERRUPT;
-			DoubleBanked    = HIDInterfaceInfo->Config.DataOUTPipeDoubleBank;
-			InterruptPeriod = DataOUTEndpoint->PollingIntervalMS;
-
-			HIDInterfaceInfo->State.DataOUTPipeSize   = DataOUTEndpoint->EndpointSize;
-			HIDInterfaceInfo->State.DeviceUsesOUTPipe = true;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return HID_ENUMERROR_PipeConfigurationFailed;
-		}
-
-		if (InterruptPeriod)
-		  Pipe_SetInterruptPeriod(InterruptPeriod);
-	}
+	HIDInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	HIDInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	HIDInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_INTERRUPT;
+	
+	HIDInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	HIDInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	HIDInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_INTERRUPT;
+	
+	if (!(Pipe_ConfigurePipeTable(&HIDInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&HIDInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
 
 	HIDInterfaceInfo->State.InterfaceNumber      = HIDInterface->InterfaceNumber;
 	HIDInterfaceInfo->State.HIDReportSize        = LE16_TO_CPU(HIDDescriptor->HIDReportLength);
@@ -227,7 +191,7 @@ uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	uint16_t ReportSize;
@@ -277,7 +241,7 @@ uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
 	{
 		uint8_t ErrorCode;
 
-		Pipe_SelectPipe(HIDInterfaceInfo->Config.DataOUTPipeNumber);
+		Pipe_SelectPipe(HIDInterfaceInfo->Config.DataOUTPipe.Address);
 		Pipe_Unfreeze();
 
 		if (ReportID)
@@ -320,7 +284,7 @@ bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 
 	bool ReportReceived;
 
-	Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	ReportReceived = Pipe_IsINReceived();
diff --git a/LUFA/Drivers/USB/Class/Host/HIDClassHost.h b/LUFA/Drivers/USB/Class/Host/HIDClassHost.h
index 7bdaad18b..882cc31df 100644
--- a/LUFA/Drivers/USB/Class/Host/HIDClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/HIDClassHost.h
@@ -83,11 +83,8 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the HID interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the HID interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the HID interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the HID interface's OUT data pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
 
 					uint8_t  HIDInterfaceProtocol; /**< HID interface protocol value to match against if a specific
 					                                *   boot subclass protocol is required, a protocol value from the
@@ -112,9 +109,6 @@
 					                */
 					uint8_t InterfaceNumber; /**< Interface index of the HID interface within the attached device. */
 
-					uint16_t DataINPipeSize; /**< Size in bytes of the HID interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the HID interface's OUT data pipe. */
-
 					bool SupportsBootProtocol; /**< Indicates if the current interface instance supports the HID Boot
 					                            *   Protocol when enabled via \ref HID_Host_SetBootProtocol().
 					                            */
diff --git a/LUFA/Drivers/USB/Class/Host/MIDIClassHost.c b/LUFA/Drivers/USB/Class/Host/MIDIClassHost.c
index 5aadbcc7f..1300577fc 100644
--- a/LUFA/Drivers/USB/Class/Host/MIDIClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/MIDIClassHost.c
@@ -78,45 +78,19 @@ uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceI
 		  DataOUTEndpoint = EndpointData;
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		bool     DoubleBanked;
-
-		if (PipeNum == MIDIInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = MIDIInterfaceInfo->Config.DataINPipeDoubleBank;
-
-			MIDIInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == MIDIInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = MIDIInterfaceInfo->Config.DataOUTPipeDoubleBank;
-
-			MIDIInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return MIDI_ENUMERROR_PipeConfigurationFailed;
-		}
-	}
+	MIDIInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	MIDIInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	MIDIInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	MIDIInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	MIDIInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	MIDIInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	if (!(Pipe_ConfigurePipeTable(&MIDIInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&MIDIInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;	
 
 	MIDIInterfaceInfo->State.InterfaceNumber = MIDIInterface->InterfaceNumber;
 	MIDIInterfaceInfo->State.IsActive = true;
@@ -181,7 +155,7 @@ uint8_t MIDI_Host_Flush(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo)
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipe.Address);
 
 	if (Pipe_BytesInPipe())
 	{
@@ -202,7 +176,7 @@ uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterface
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipe.Address);
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL)) != PIPE_RWSTREAM_NoError)
 	  return ErrorCode;
@@ -218,18 +192,27 @@ bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterface
 {
 	if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
 	  return HOST_SENDCONTROL_DeviceDisconnected;
+	  
+	bool DataReady = false;
 
-	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataINPipeNumber);
-
-	if (!(Pipe_IsReadWriteAllowed()))
-	  return false;
+	Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataINPipe.Address);
+	Pipe_Unfreeze();
 
-	Pipe_Read_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL);
-
-	if (!(Pipe_IsReadWriteAllowed()))
-	  Pipe_ClearIN();
+	if (Pipe_IsINReceived())
+	{
+		if (Pipe_BytesInPipe())
+		{
+			Pipe_Read_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL);
+			DataReady = true;
+		}
 
-	return true;
+		if (!(Pipe_BytesInPipe()))
+		  Pipe_ClearIN();
+	}
+	
+	Pipe_Freeze();
+	
+	return DataReady;
 }
 
 #endif
diff --git a/LUFA/Drivers/USB/Class/Host/MIDIClassHost.h b/LUFA/Drivers/USB/Class/Host/MIDIClassHost.h
index e934ddacb..b9e861143 100644
--- a/LUFA/Drivers/USB/Class/Host/MIDIClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/MIDIClassHost.h
@@ -79,11 +79,8 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the MIDI interface's streaming IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the MIDI interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the MIDI interface's streaming OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the MIDI interface's OUT data pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -94,9 +91,6 @@
 					                    *   Configured state.
 					                    */
 					uint8_t  InterfaceNumber; /**< Interface index of the MIDI interface within the attached device. */
-
-					uint16_t DataINPipeSize; /**< Size in bytes of the MIDI Streaming Data interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the MIDI Streaming Data interface's OUT data pipe. */
 				} State; /**< State data for the USB class interface within the device. All elements in this section
 						  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when
 						  *   the interface is enumerated.
diff --git a/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.c b/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.c
index 24b4edc76..f145881fd 100644
--- a/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.c
@@ -78,45 +78,19 @@ uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
 		  DataOUTEndpoint = EndpointData;
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		bool     DoubleBanked;
-
-		if (PipeNum == MSInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = MSInterfaceInfo->Config.DataINPipeDoubleBank;
-
-			MSInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == MSInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = MSInterfaceInfo->Config.DataOUTPipeDoubleBank;
-
-			MSInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return MS_ENUMERROR_PipeConfigurationFailed;
-		}
-	}
+	MSInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	MSInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	MSInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	MSInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	MSInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	MSInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	if (!(Pipe_ConfigurePipeTable(&MSInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&MSInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
 
 	MSInterfaceInfo->State.InterfaceNumber = MassStorageInterface->InterfaceNumber;
 	MSInterfaceInfo->State.IsActive = true;
@@ -178,7 +152,7 @@ static uint8_t MS_Host_SendCommand(USB_ClassInfo_MS_Host_t* const MSInterfaceInf
 	SCSICommandBlock->Signature = CPU_TO_LE32(MS_CBW_SIGNATURE);
 	SCSICommandBlock->Tag       = cpu_to_le32(MSInterfaceInfo->State.TransactionTag);
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(MS_CommandBlockWrapper_t),
@@ -212,7 +186,7 @@ static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInte
 	uint16_t TimeoutMSRem        = MS_COMMAND_DATA_TIMEOUT_MS;
 	uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	while (!(Pipe_IsINReceived()))
@@ -228,7 +202,7 @@ static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInte
 		}
 
 		Pipe_Freeze();
-		Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
+		Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
 		Pipe_Unfreeze();
 
 		if (Pipe_IsStalled())
@@ -238,7 +212,7 @@ static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInte
 		}
 
 		Pipe_Freeze();
-		Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+		Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 		Pipe_Unfreeze();
 
 		if (Pipe_IsStalled())
@@ -251,10 +225,10 @@ static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInte
 		  return PIPE_RWSTREAM_DeviceDisconnected;
 	};
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Freeze();
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Freeze();
 
 	return PIPE_RWSTREAM_NoError;
@@ -275,7 +249,7 @@ static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfac
 			return ErrorCode;
 		}
 
-		Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+		Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 		Pipe_Unfreeze();
 
 		if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem, NULL)) != PIPE_RWSTREAM_NoError)
@@ -285,7 +259,7 @@ static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfac
 	}
 	else
 	{
-		Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
+		Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
 		Pipe_Unfreeze();
 
 		if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem, NULL)) != PIPE_RWSTREAM_NoError)
@@ -313,7 +287,7 @@ static uint8_t MS_Host_GetReturnedStatus(USB_ClassInfo_MS_Host_t* const MSInterf
 	if ((ErrorCode = MS_Host_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)
 	  return ErrorCode;
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(MS_CommandStatusWrapper_t),
@@ -349,12 +323,12 @@ uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
 	if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 	  return ErrorCode;
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipe.Address);
 
 	if ((ErrorCode = USB_Host_ClearEndpointStall(Pipe_GetBoundEndpointAddress())) != HOST_SENDCONTROL_Successful)
 	  return ErrorCode;
 
-	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipe.Address);
 
 	if ((ErrorCode = USB_Host_ClearEndpointStall(Pipe_GetBoundEndpointAddress())) != HOST_SENDCONTROL_Successful)
 	  return ErrorCode;
diff --git a/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.h b/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.h
index 25d7e1e5e..a8763dd5b 100644
--- a/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/MassStorageClassHost.h
@@ -83,11 +83,8 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the Mass Storage interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the Mass Storage interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the Mass Storage interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the Mass Storage interface's OUT data pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -99,9 +96,6 @@
 					                    */
 					uint8_t  InterfaceNumber; /**< Interface index of the Mass Storage interface within the attached device. */
 
-					uint16_t DataINPipeSize; /**< Size in bytes of the Mass Storage interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the Mass Storage interface's OUT data pipe. */
-
 					uint32_t TransactionTag; /**< Current transaction tag for data synchronizing of packets. */
 				} State; /**< State data for the USB class interface within the device. All elements in this section
 						  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when
diff --git a/LUFA/Drivers/USB/Class/Host/PrinterClassHost.c b/LUFA/Drivers/USB/Class/Host/PrinterClassHost.c
index 379ccb01c..dd33b115b 100644
--- a/LUFA/Drivers/USB/Class/Host/PrinterClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/PrinterClassHost.c
@@ -78,45 +78,19 @@ uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceI
 		  DataOUTEndpoint = EndpointData;
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		bool     DoubleBanked;
-
-		if (PipeNum == PRNTInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = PRNTInterfaceInfo->Config.DataINPipeDoubleBank;
-
-			PRNTInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == PRNTInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = PRNTInterfaceInfo->Config.DataOUTPipeDoubleBank;
-
-			PRNTInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return PRNT_ENUMERROR_PipeConfigurationFailed;
-		}
-	}
+	PRNTInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	PRNTInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	PRNTInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	PRNTInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	PRNTInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	PRNTInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	if (!(Pipe_ConfigurePipeTable(&PRNTInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&PRNTInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;	
 
 	PRNTInterfaceInfo->State.InterfaceNumber  = PrinterInterface->InterfaceNumber;
 	PRNTInterfaceInfo->State.AlternateSetting = PrinterInterface->AlternateSetting;
@@ -229,7 +203,7 @@ uint8_t PRNT_Host_Flush(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if (!(Pipe_BytesInPipe()))
@@ -260,7 +234,7 @@ uint8_t PRNT_Host_SendByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 
 	uint8_t ErrorCode;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if (!(Pipe_IsReadWriteAllowed()))
@@ -285,7 +259,7 @@ uint8_t PRNT_Host_SendString(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 	if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL)) != PIPE_RWSTREAM_NoError)
@@ -309,7 +283,7 @@ uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 	if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL)) != PIPE_RWSTREAM_NoError)
@@ -329,7 +303,7 @@ uint16_t PRNT_Host_BytesReceived(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceI
 	if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 	  return 0;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_IsINReceived())
@@ -361,7 +335,7 @@ int16_t PRNT_Host_ReceiveByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo
 
 	int16_t ReceivedByte = -1;
 
-	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_IsINReceived())
diff --git a/LUFA/Drivers/USB/Class/Host/PrinterClassHost.h b/LUFA/Drivers/USB/Class/Host/PrinterClassHost.h
index c8c997f74..25878276f 100644
--- a/LUFA/Drivers/USB/Class/Host/PrinterClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/PrinterClassHost.h
@@ -79,11 +79,8 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the Printer interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the Printer interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the Printer interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the Printer interface's OUT data pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -95,9 +92,6 @@
 					                */
 					uint8_t InterfaceNumber; /**< Interface index of the Printer interface within the attached device. */
 					uint8_t AlternateSetting; /**< Alternate setting within the Printer Interface in the attached device. */
-
-					uint16_t DataINPipeSize; /**< Size in bytes of the Printer interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the Printer interface's OUT data pipe. */
 				} State; /**< State data for the USB class interface within the device. All elements in this section
 						  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when
 						  *   the interface is enumerated.
diff --git a/LUFA/Drivers/USB/Class/Host/RNDISClassHost.c b/LUFA/Drivers/USB/Class/Host/RNDISClassHost.c
index a03011d64..e457b5dff 100644
--- a/LUFA/Drivers/USB/Class/Host/RNDISClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/RNDISClassHost.c
@@ -101,62 +101,26 @@ uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfa
 		}
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		uint8_t  InterruptPeriod;
-		bool     DoubleBanked;
-
-		if (PipeNum == RNDISInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = RNDISInterfaceInfo->Config.DataINPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			RNDISInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == RNDISInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = RNDISInterfaceInfo->Config.DataOUTPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			RNDISInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else if (PipeNum == RNDISInterfaceInfo->Config.NotificationPipeNumber)
-		{
-			Size            = le16_to_cpu(NotificationEndpoint->EndpointSize);
-			EndpointAddress = NotificationEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_INTERRUPT;
-			DoubleBanked    = RNDISInterfaceInfo->Config.NotificationPipeDoubleBank;
-			InterruptPeriod = NotificationEndpoint->PollingIntervalMS;
-
-			RNDISInterfaceInfo->State.NotificationPipeSize = NotificationEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return CDC_ENUMERROR_PipeConfigurationFailed;
-		}
+	RNDISInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	RNDISInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	RNDISInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	RNDISInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	RNDISInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	RNDISInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	RNDISInterfaceInfo->Config.NotificationPipe.Size = le16_to_cpu(NotificationEndpoint->EndpointSize);
+	RNDISInterfaceInfo->Config.NotificationPipe.EndpointAddress = NotificationEndpoint->EndpointAddress;
+	RNDISInterfaceInfo->Config.NotificationPipe.Type = EP_TYPE_INTERRUPT;
+
+	if (!(Pipe_ConfigurePipeTable(&RNDISInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&RNDISInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
 
-		if (InterruptPeriod)
-		  Pipe_SetInterruptPeriod(InterruptPeriod);
-	}
+	if (!(Pipe_ConfigurePipeTable(&RNDISInterfaceInfo->Config.NotificationPipe, 1)))
+	  return false;
 
 	RNDISInterfaceInfo->State.ControlInterfaceNumber = RNDISControlInterface->InterfaceNumber;
 	RNDISInterfaceInfo->State.IsActive = true;
@@ -419,7 +383,7 @@ bool RNDIS_Host_IsPacketReceived(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfac
 	if ((USB_HostState != HOST_STATE_Configured) || !(RNDISInterfaceInfo->State.IsActive))
 	  return false;
 
-	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipe.Address);
 
 	Pipe_Unfreeze();
 	PacketWaiting = Pipe_IsINReceived();
@@ -437,7 +401,7 @@ uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceIn
 	if ((USB_HostState != HOST_STATE_Configured) || !(RNDISInterfaceInfo->State.IsActive))
 	  return PIPE_READYWAIT_DeviceDisconnected;
 
-	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	if (!(Pipe_IsReadWriteAllowed()))
@@ -491,7 +455,7 @@ uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceIn
 	DeviceMessage.DataOffset    = CPU_TO_LE32(sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t));
 	DeviceMessage.DataLength    = cpu_to_le32(PacketLength);
 
-	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(&DeviceMessage, sizeof(RNDIS_Packet_Message_t),
diff --git a/LUFA/Drivers/USB/Class/Host/RNDISClassHost.h b/LUFA/Drivers/USB/Class/Host/RNDISClassHost.h
index 085bde22c..57087edf9 100644
--- a/LUFA/Drivers/USB/Class/Host/RNDISClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/RNDISClassHost.h
@@ -80,14 +80,9 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the RNDIS interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the RNDIS interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the RNDIS interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the RNDIS interface's OUT data pipe should use double banking. */
-
-					uint8_t  NotificationPipeNumber; /**< Pipe number of the RNDIS interface's IN notification endpoint, if used. */
-					bool     NotificationPipeDoubleBank; /**< Indicates if the RNDIS interface's notification pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
+					USB_Pipe_Table_t NotificationPipe; /**< Notification IN Pipe configuration table. */
 
 					uint32_t HostMaxPacketSize; /**< Maximum size of a packet which can be buffered by the host. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
@@ -101,10 +96,6 @@
 					                */
 					uint8_t ControlInterfaceNumber; /**< Interface index of the RNDIS control interface within the attached device. */
 
-					uint16_t DataINPipeSize; /**< Size in bytes of the RNDIS interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the RNDIS interface's OUT data pipe. */
-					uint16_t NotificationPipeSize;  /**< Size in bytes of the RNDIS interface's IN notification pipe, if used. */
-
 					uint32_t DeviceMaxPacketSize; /**< Maximum size of a packet which can be buffered by the attached RNDIS device. */
 
 					uint32_t RequestID; /**< Request ID counter to give a unique ID for each command/response pair. */
diff --git a/LUFA/Drivers/USB/Class/Host/StillImageClassHost.c b/LUFA/Drivers/USB/Class/Host/StillImageClassHost.c
index 2b5514a28..5c18d7503 100644
--- a/LUFA/Drivers/USB/Class/Host/StillImageClassHost.c
+++ b/LUFA/Drivers/USB/Class/Host/StillImageClassHost.c
@@ -87,63 +87,27 @@ uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 		}
 	}
 
-	for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
-	{
-		uint16_t Size;
-		uint8_t  Type;
-		uint8_t  Token;
-		uint8_t  EndpointAddress;
-		uint8_t  InterruptPeriod;
-		bool     DoubleBanked;
-
-		if (PipeNum == SIInterfaceInfo->Config.DataINPipeNumber)
-		{
-			Size            = DataINEndpoint->EndpointSize;
-			EndpointAddress = DataINEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = SIInterfaceInfo->Config.DataINPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			SIInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
-		}
-		else if (PipeNum == SIInterfaceInfo->Config.DataOUTPipeNumber)
-		{
-			Size            = DataOUTEndpoint->EndpointSize;
-			EndpointAddress = DataOUTEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_OUT;
-			Type            = EP_TYPE_BULK;
-			DoubleBanked    = SIInterfaceInfo->Config.DataOUTPipeDoubleBank;
-			InterruptPeriod = 0;
-
-			SIInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
-		}
-		else if (PipeNum == SIInterfaceInfo->Config.EventsPipeNumber)
-		{
-			Size            = EventsEndpoint->EndpointSize;
-			EndpointAddress = EventsEndpoint->EndpointAddress;
-			Token           = PIPE_TOKEN_IN;
-			Type            = EP_TYPE_INTERRUPT;
-			DoubleBanked    = SIInterfaceInfo->Config.EventsPipeDoubleBank;
-			InterruptPeriod = EventsEndpoint->PollingIntervalMS;
-
-			SIInterfaceInfo->State.EventsPipeSize = EventsEndpoint->EndpointSize;
-		}
-		else
-		{
-			continue;
-		}
-
-		if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
-		                         DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
-		{
-			return SI_ENUMERROR_PipeConfigurationFailed;
-		}
-
-		if (InterruptPeriod)
-		  Pipe_SetInterruptPeriod(InterruptPeriod);
-	}
+	SIInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
+	SIInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
+	SIInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_BULK;
+	
+	SIInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
+	SIInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
+	SIInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_BULK;
+	
+	SIInterfaceInfo->Config.EventsPipe.Size = le16_to_cpu(EventsEndpoint->EndpointSize);
+	SIInterfaceInfo->Config.EventsPipe.EndpointAddress = EventsEndpoint->EndpointAddress;
+	SIInterfaceInfo->Config.EventsPipe.Type = EP_TYPE_INTERRUPT;
+
+	if (!(Pipe_ConfigurePipeTable(&SIInterfaceInfo->Config.DataINPipe, 1)))
+	  return false;
+	
+	if (!(Pipe_ConfigurePipeTable(&SIInterfaceInfo->Config.DataOUTPipe, 1)))
+	  return false;
 
+	if (!(Pipe_ConfigurePipeTable(&SIInterfaceInfo->Config.EventsPipe, 1)))
+	  return false;
+	
 	SIInterfaceInfo->State.InterfaceNumber = StillImageInterface->InterfaceNumber;
 	SIInterfaceInfo->State.IsActive = true;
 
@@ -204,7 +168,7 @@ uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 	if (SIInterfaceInfo->State.IsSessionOpen)
 	  PIMAHeader->TransactionID = cpu_to_le32(SIInterfaceInfo->State.TransactionID++);
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NULL)) != PIPE_RWSTREAM_NoError)
@@ -233,7 +197,7 @@ uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
 	if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	while (!(Pipe_IsINReceived()))
@@ -249,7 +213,7 @@ uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
 		}
 
 		Pipe_Freeze();
-		Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
+		Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipe.Address);
 		Pipe_Unfreeze();
 
 		if (Pipe_IsStalled())
@@ -259,7 +223,7 @@ uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
 		}
 
 		Pipe_Freeze();
-		Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
+		Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipe.Address);
 		Pipe_Unfreeze();
 
 		if (Pipe_IsStalled())
@@ -298,7 +262,7 @@ uint8_t SI_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 	if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipe.Address);
 	Pipe_Unfreeze();
 
 	ErrorCode = Pipe_Write_Stream_LE(Buffer, Bytes, NULL);
@@ -318,7 +282,7 @@ uint8_t SI_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 	if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipe.Address);
 	Pipe_Unfreeze();
 
 	ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NULL);
@@ -335,7 +299,7 @@ bool SI_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 	if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 	  return false;
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipe.Address);
 	Pipe_Unfreeze();
 
 	if (Pipe_BytesInPipe())
@@ -354,7 +318,7 @@ uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
 	if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 	  return PIPE_RWSTREAM_DeviceDisconnected;
 
-	Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
+	Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipe.Address);
 	Pipe_Unfreeze();
 
 	ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(PIMA_Container_t), NULL);
diff --git a/LUFA/Drivers/USB/Class/Host/StillImageClassHost.h b/LUFA/Drivers/USB/Class/Host/StillImageClassHost.h
index 4cda70d2e..be616b459 100644
--- a/LUFA/Drivers/USB/Class/Host/StillImageClassHost.h
+++ b/LUFA/Drivers/USB/Class/Host/StillImageClassHost.h
@@ -83,14 +83,9 @@
 			{
 				struct
 				{
-					uint8_t  DataINPipeNumber; /**< Pipe number of the Still Image interface's IN data pipe. */
-					bool     DataINPipeDoubleBank; /**< Indicates if the Still Image interface's IN data pipe should use double banking. */
-
-					uint8_t  DataOUTPipeNumber; /**< Pipe number of the Still Image interface's OUT data pipe. */
-					bool     DataOUTPipeDoubleBank; /**< Indicates if the Still Image interface's OUT data pipe should use double banking. */
-
-					uint8_t  EventsPipeNumber; /**< Pipe number of the Still Image interface's IN events endpoint, if used. */
-					bool     EventsPipeDoubleBank; /**< Indicates if the Still Image interface's events data pipe should use double banking. */
+					USB_Pipe_Table_t DataINPipe; /**< Data IN Pipe configuration table. */
+					USB_Pipe_Table_t DataOUTPipe; /**< Data OUT Pipe configuration table. */
+					USB_Pipe_Table_t EventsPipe; /**< Event notification IN Pipe configuration table. */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */
@@ -102,10 +97,6 @@
 					                    */
 					uint8_t  InterfaceNumber; /**< Interface index of the Still Image interface within the attached device. */
 
-					uint16_t DataINPipeSize; /**< Size in bytes of the Still Image interface's IN data pipe. */
-					uint16_t DataOUTPipeSize;  /**< Size in bytes of the Still Image interface's OUT data pipe. */
-					uint16_t EventsPipeSize;  /**< Size in bytes of the Still Image interface's IN events pipe. */
-
 					bool IsSessionOpen; /**< Indicates if a PIMA session is currently open with the attached device. */
 					uint32_t TransactionID; /**< Transaction ID for the next transaction to send to the device. */
 				} State; /**< State data for the USB class interface within the device. All elements in this section