Added CDC_Device_Flush() command to the CDC Device mode class driver.

Minor updates to the unfinished SideShow demo for clarity.

Added unfinished MassStorageHost class driver demo.

Demos/Device/Incomplete/Sideshow/Lib/SideshowApplications.c

@@ -33,19 +33,6 @@
 SideShow_Application_t InstalledApplications[MAX_APPLICATIONS];
 
 
-uint8_t SideShow_GetTotalApplications(void)
-{
-	uint8_t TotalInstalledApps = 0;
-	
-	for (uint8_t App = 0; App < ARRAY_ELEMENTS(InstalledApplications); App++)
-	{
-		if (InstalledApplications[App].InUse)
-		  TotalInstalledApps++;
-	}
-	
-	return TotalInstalledApps;	
-}
-
 SideShow_Application_t* SideShow_GetFreeApplication(void)
 {
 	for (uint8_t App = 0; App < ARRAY_ELEMENTS(InstalledApplications); App++)

Demos/Device/Incomplete/Sideshow/Lib/SideshowApplications.h

@@ -56,7 +56,6 @@
 		extern SideShow_Application_t InstalledApplications[MAX_APPLICATIONS];
 		
 	/* Function Prototypes: */
-		uint8_t                 SideShow_GetTotalApplications(void);
 		SideShow_Application_t* SideShow_GetFreeApplication(void);
 		SideShow_Application_t* SideShow_GetApplicationFromGUID(GUID_t* GUID);
 		

Demos/Device/Incomplete/Sideshow/Lib/SideshowCommands.c

@@ -295,21 +295,26 @@ static void SideShow_GetString(SideShow_PacketHeader_t* PacketHeader, void* Unic
 
 static void SideShow_GetApplicationOrder(SideShow_PacketHeader_t* PacketHeader)
 {
-	uint8_t TotalInstalledApplications = SideShow_GetTotalApplications();
-	uint16_t GadgetGUIDBytes           = (TotalInstalledApplications * sizeof(GUID_t));
-
+	uint8_t  TotalApplications = 0;
+		   
 	Endpoint_ClearOUT();
 
+	for (uint8_t App = 0; App < MAX_APPLICATIONS; App++)
+	{
+		if (InstalledApplications[App].InUse)
+		  TotalApplications++;
+	}
+
 	PacketHeader->Length = sizeof(SideShow_PacketHeader_t) +
-	                       sizeof(uint32_t) + GadgetGUIDBytes;
+	                       sizeof(uint32_t) + (TotalApplications * sizeof(GUID_t));
 	
 	Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 	Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
-	Endpoint_Write_DWord_LE(TotalInstalledApplications);
+	Endpoint_Write_DWord_LE(TotalApplications);
 	
 	for (uint8_t App = 0; App < MAX_APPLICATIONS; App++)
 	{
-		if (InstalledApplications[App].InUse == true)
+		if (InstalledApplications[App].InUse)
 		  Endpoint_Write_Stream_LE(&InstalledApplications[App].ApplicationID, sizeof(GUID_t));
 	}
 
@@ -386,9 +391,7 @@ static void SideShow_DeleteApplication(SideShow_PacketHeader_t* PacketHeader)
 	SideShow_Application_t* AppToDelete = SideShow_GetApplicationFromGUID(&ApplicationGUID);
 
 	if (AppToDelete != NULL)
-	{
-		AppToDelete->InUse = false;
-	}
+	  AppToDelete->InUse = false;
 	else
 	  PacketHeader->Type.NAK = true;
 

Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2009.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, and distribute this software
+  and its documentation for any purpose and without fee is hereby
+  granted, provided that the above copyright notice appear in all
+  copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Main source file for the MassStorageHost demo. This file contains the main tasks of
+ *  the demo and is responsible for the initial application hardware configuration.
+ */
+ 
+#include "MassStorageHost.h"
+
+/** LUFA Mass Storage Class driver interface configuration and state information. This structure is
+ *  passed to all Mass Storage Class driver functions, so that multiple instances of the same class
+ *  within a device can be differentiated from one another.
+ */
+USB_ClassInfo_MS_Host_t FlashDisk_MS_Interface =
+	{
+		.Config =
+			{
+				.DataINPipeNumber       = 1,
+				.DataOUTPipeNumber      = 2,
+			},
+	};
+
+	
+/** Main program entry point. This routine configures the hardware required by the application, then
+ *  starts the scheduler to run the application tasks.
+ */
+int main(void)
+{
+	SetupHardware();
+
+	puts_P(PSTR(ESC_FG_CYAN "Mass Storage Host Demo running.\r\n" ESC_FG_WHITE));
+
+	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
+
+	for (;;)
+	{
+		switch (USB_HostState)
+		{
+			case HOST_STATE_Addressed:
+				LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
+			
+				uint16_t ConfigDescriptorSize;
+				uint8_t  ConfigDescriptorData[512];
+
+				if ((USB_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, NULL) != HOST_SENDCONTROL_Successful) ||
+				    (ConfigDescriptorSize > sizeof(ConfigDescriptorData)) ||
+					(USB_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData)))
+				{
+					printf("Error Retrieving Configuration Descriptor.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+
+				if (MS_Host_ConfigurePipes(&FlashDisk_MS_Interface,
+				                            ConfigDescriptorSize, ConfigDescriptorData) != MS_ENUMERROR_NoError)
+				{
+					printf("Attached Device Not a Valid Mouse.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+				
+				if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
+				{
+					printf("Error Setting Device Configuration.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+				
+				printf("Mouse Enumerated.\r\n");
+				USB_HostState = HOST_STATE_Configured;
+				break;
+			case HOST_STATE_Configured:
+				LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+				
+				uint8_t MaxLUNIndex;
+				if (MS_Host_GetMaxLUN(&FlashDisk_MS_Interface, &MaxLUNIndex))
+				{
+					printf("Error retrieving max LUN index.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+				
+				if (MS_Host_ResetMSInterface(&FlashDisk_MS_Interface))
+				{
+					printf("Error resetting Mass Storage interface.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+				
+				SCSI_Inquiry_Response_t InquiryData;
+				if (MS_Host_GetInquiryData(&FlashDisk_MS_Interface, &InquiryData))
+				{
+					printf("Error retreiving device Inquiry data.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;				
+				}
+
+				printf("Vendor \"%.8s\", Product \"%.16s\"\r\n", InquiryData.VendorID, InquiryData.ProductID);
+				
+				bool DeviceReady;
+				printf("Waiting until ready...\r\n"));
+
+				do
+				{
+					if (USB_HostState != HOST_STATE_Configured)
+					  break;
+
+					if (MS_Host_TestUnitReady(&FlashDisk_MS_Interface, 0, &DeviceReady))
+					{
+						printf("Error waiting for device to be ready.\r\n");
+						LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+						USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+						break;
+					}
+				}
+				while (DeviceReady == false);
+
+				puts_P(PSTR("Retrieving Capacity... "));
+
+				SCSI_Capacity_t DiskCapacity;
+				if (MS_Host_ReadDeviceCapacity(0, &DiskCapacity))
+				{
+					printf("Error retrieving device capacity.\r\n");
+					LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+					USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+					break;
+				}
+				
+				printf("%lu blocks of %lu bytes.\r\n", DiskCapacity.Blocks, DiskCapacity.BlockSize);
+
+				LEDs_SetAllLEDs(LEDMASK_USB_READY);
+				USB_HostState = HOST_STATE_WaitForDeviceRemoval;
+				break;
+		}
+	
+		MS_Host_USBTask(&FlashDisk_MS_Interface);
+		USB_USBTask();
+	}
+}
+
+/** Configures the board hardware and chip peripherals for the demo's functionality. */
+void SetupHardware(void)
+{
+	/* Disable watchdog if enabled by bootloader/fuses */
+	MCUSR &= ~(1 << WDRF);
+	wdt_disable();
+
+	/* Disable clock division */
+	clock_prescale_set(clock_div_1);
+
+	/* Hardware Initialization */
+	SerialStream_Init(9600, false);
+	LEDs_Init();
+	USB_Init();
+}
+
+/** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
+ *  starts the library USB task to begin the enumeration and USB management process.
+ */
+void EVENT_USB_Host_DeviceAttached(void)
+{
+	puts_P(PSTR("Device Attached.\r\n"));
+	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
+}
+
+/** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
+ *  stops the library USB task management process.
+ */
+void EVENT_USB_Host_DeviceUnattached(void)
+{
+	puts_P(PSTR("\r\nDevice Unattached.\r\n"));
+	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
+}
+
+/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
+ *  enumerated by the host and is now ready to be used by the application.
+ */
+void EVENT_USB_Host_DeviceEnumerationComplete(void)
+{
+	LEDs_SetAllLEDs(LEDMASK_USB_READY);
+}
+
+/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
+void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
+{
+	USB_ShutDown();
+
+	printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
+	                         " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
+
+	LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+	for(;;);
+}
+
+/** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
+ *  enumerating an attached USB device.
+ */
+void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
+{
+	printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
+	                         " -- Error Code %d\r\n"
+	                         " -- Sub Error Code %d\r\n"
+	                         " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
+	
+	LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
+}

Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.h

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2009.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, and distribute this software
+  and its documentation for any purpose and without fee is hereby
+  granted, provided that the above copyright notice appear in all
+  copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for MassStorage.c.
+ */
+
+#ifndef _MASS_STORAGE_HOST_H_
+#define _MASS_STORAGE_HOST_H_
+
+	/* Includes: */
+		#include <avr/io.h>
+		#include <avr/wdt.h>
+		#include <avr/pgmspace.h>
+		#include <avr/power.h>
+		#include <stdio.h>
+
+		#include <LUFA/Version.h>
+		#include <LUFA/Drivers/Misc/TerminalCodes.h>
+		#include <LUFA/Drivers/Peripheral/SerialStream.h>
+		#include <LUFA/Drivers/Board/LEDs.h>
+		#include <LUFA/Drivers/USB/USB.h>
+		#include <LUFA/Drivers/USB/Class/MassStorage.h>
+		
+	/* Macros: */
+		/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
+		#define LEDMASK_USB_NOTREADY      LEDS_LED1
+
+		/** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */
+		#define LEDMASK_USB_ENUMERATING  (LEDS_LED2 | LEDS_LED3)
+
+		/** LED mask for the library LED driver, to indicate that the USB interface is ready. */
+		#define LEDMASK_USB_READY        (LEDS_LED2 | LEDS_LED4)
+
+		/** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */
+		#define LEDMASK_USB_ERROR        (LEDS_LED1 | LEDS_LED3)
+		
+		/** LED mask for the library LED driver, to indicate that the USB interface is busy. */
+		#define LEDMASK_USB_BUSY         (LEDS_LED2)
+
+	/* Function Prototypes: */
+		void SetupHardware(void);
+	
+		void EVENT_USB_Host_HostError(const uint8_t ErrorCode);
+		void EVENT_USB_Host_DeviceAttached(void);
+		void EVENT_USB_Host_DeviceUnattached(void);
+		void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode);
+		void EVENT_USB_Host_DeviceEnumerationComplete(void);
+		
+#endif

Demos/Host/ClassDriver/makefile

@@ -18,8 +18,12 @@ all:
 	make -C CDCHost all	
 
 	make -C MouseHost clean
-	make -C MouseHost all	
+	make -C MouseHost all
 
+	make -C MassStorageHost clean
+	make -C MassStorageHost all
+	
 %:
 	make -C CDCHost $@
 	make -C MouseHost $@
+	make -C MassStorageHost $@

LUFA/Drivers/USB/Class/Device/CDC.c

@@ -115,21 +115,10 @@ bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 
 void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
 {
-	if (USB_DeviceState != DEVICE_STATE_Configured)
+	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
 	  return;
 
-	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
-
-	if (!(Endpoint_BytesInEndpoint()))
-	  return;
-	  
-	if (!(Endpoint_IsReadWriteAllowed()))
-	{
-		Endpoint_ClearIN();
-		Endpoint_WaitUntilReady();
-	}	
-	
-	Endpoint_ClearIN();
+	CDC_Device_Flush(CDCInterfaceInfo);
 }
 
 void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)
@@ -157,6 +146,23 @@ void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, con
 	Endpoint_Write_Byte(Data);	
 }
 
+void CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
+{
+	if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
+	  return;
+
+	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataINEndpointNumber);
+	
+	if (Endpoint_BytesInEndpoint())
+	{
+		Endpoint_ClearIN();
+		Endpoint_WaitUntilReady();
+	}
+	
+	Endpoint_ClearIN();
+	Endpoint_WaitUntilReady();	
+}
+
 uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 {
 	Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);

LUFA/Drivers/USB/Class/Device/CDC.h

@@ -185,6 +185,12 @@
 			 */
 			uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
 			
+			/** Flushes any data waiting to be sent, ensuring that the send buffer is cleared.
+			 *
+			 *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+			 */
+			void CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
+			
 			/** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial
 			 *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist
 			 *  until they are cleared via a second notification. This should be called each time the CDC class driver's 

LUFA/Drivers/USB/Class/Host/HID.c

@@ -39,7 +39,7 @@
 uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint16_t ConfigDescriptorSize,
                                 uint8_t* ConfigDescriptorData)
 {
-	uint8_t  FoundEndpoints = 0;
+	uint8_t FoundEndpoints = 0;
 
 	memset(&HIDInterfaceInfo->State, 0x00, sizeof(HIDInterfaceInfo->State));
 
@@ -68,7 +68,7 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint
 	#endif
 	HIDInterfaceInfo->State.SupportsBootSubClass = (CurrentHIDInterface->SubClass != 0);
 
-	while (FoundEndpoints != ((1 << HID_FOUND_DATAPIPE_IN) | (1 << HID_FOUND_DATAPIPE_OUT)))
+	while (FoundEndpoints != (HID_FOUND_DATAPIPE_IN | HID_FOUND_DATAPIPE_OUT))
 	{
 		if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
 		                              DComp_HID_Host_NextInterfaceHIDDataEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
@@ -85,15 +85,17 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint
 		{
 			Pipe_ConfigurePipe(HIDInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
 							   EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
+			HIDInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
 			
-			FoundEndpoints |= (1 << HID_FOUND_DATAPIPE_IN);
+			FoundEndpoints |= HID_FOUND_DATAPIPE_IN;
 		}
 		else
 		{
 			Pipe_ConfigurePipe(HIDInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_OUT,
 							   EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
+			HIDInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
 			
-			FoundEndpoints |= (1 << HID_FOUND_DATAPIPE_OUT);		
+			FoundEndpoints |= HID_FOUND_DATAPIPE_OUT;		
 		}
 	}
 

LUFA/Drivers/USB/Class/Host/HID.h

@@ -100,7 +100,7 @@
 				HID_ENUMERROR_NoError                    = 0, /**< Configuration Descriptor was processed successfully */
 				HID_ENUMERROR_InvalidConfigDescriptor    = 1, /**< The device returned an invalid Configuration Descriptor */
 				HID_ENUMERROR_NoHIDInterfaceFound        = 2, /**< A compatible HID interface was not found in the device's Configuration Descriptor */
-				HID_ENUMERROR_EndpointsNotFound          = 3, /**< Compatible HID endpoints were not found in the device's CDC interface */
+				HID_ENUMERROR_EndpointsNotFound          = 3, /**< Compatible HID endpoints were not found in the device's HID interface */
 			} HIDHost_EnumerationFailure_ErrorCodes_t;
 	
 		/* Function Prototypes: */

LUFA/Drivers/USB/Class/Host/MassStorage.c

@@ -36,4 +36,99 @@
 
 #warning The Mass Storage Host mode Class driver is currently incomplete and is for preview purposes only.
 
+uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint16_t ConfigDescriptorLength,
+							   uint8_t* DeviceConfigDescriptor)
+{
+	uint8_t FoundEndpoints = 0;
+	
+	memset(&MSInterfaceInfo->State, 0x00, sizeof(MSInterfaceInfo->State));
+
+	if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
+	  return MS_ENUMERROR_InvalidConfigDescriptor;
+	
+	if (USB_GetNextDescriptorComp(&ConfigDescriptorLength, &DeviceConfigDescriptor,
+	                              DComp_NextMassStorageInterface) != DESCRIPTOR_SEARCH_COMP_Found)
+	{
+		return MS_ENUMERROR_NoMSInterfaceFound;
+	}
+
+	MSInterfaceInfo->State.InterfaceNumber	     =
+	#if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)
+	                     DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Interface_t)->InterfaceNumber;
+	#else
+	                     DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Interface_t)->bInterfaceNumber;
+	#endif
+	
+	while (FoundEndpoints != (MS_FOUND_DATAPIPE_IN | MS_FOUND_DATAPIPE_OUT))
+	{
+		if (USB_GetNextDescriptorComp(&ConfigDescriptorLength, &DeviceConfigDescriptor,
+		                              DComp_NextInterfaceBulkDataEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
+		{
+			return MS_ENUMERROR_EndpointsNotFound;
+		}
+		
+		USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
+
+		if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
+		{
+			Pipe_ConfigurePipe(MSInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
+			                   EndpointData->EndpointAddress, EndpointData->EndpointSize,
+			                   PIPE_BANK_DOUBLE);
+			MSInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
+
+			FoundEndpoints |= MS_FOUND_DATAPIPE_IN;
+		}
+		else
+		{
+			Pipe_ConfigurePipe(MSInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
+			                   EndpointData->EndpointAddress, EndpointData->EndpointSize,
+			                   PIPE_BANK_DOUBLE);
+			MSInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
+
+			FoundEndpoints |= MS_FOUND_DATAPIPE_OUT;
+		}		
+	}
+
+	MSInterfaceInfo->State.Active = true;
+	return MS_ENUMERROR_NoError;
+}
+
+static uint8_t DComp_NextMassStorageInterface(void* CurrentDescriptor)
+{
+	if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
+	{
+		if ((DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Class    == MASS_STORE_CLASS)    &&
+		    (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).SubClass == MASS_STORE_SUBCLASS) &&
+		    (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Protocol == MASS_STORE_PROTOCOL))
+		{
+			return DESCRIPTOR_SEARCH_Found;
+		}
+	}
+	
+	return DESCRIPTOR_SEARCH_NotFound;
+}
+
+static uint8_t DComp_NextInterfaceBulkDataEndpoint(void* CurrentDescriptor)
+{