[RFC/PATCH/RESEND 1/3] usb unittests framework: test files

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



This patch includes the tests that should be compiled with the
GoogleTest framework.

Signed-off-by: Tatyana Brokhman <tlinder@xxxxxxxxxxxxxx>

---
 tools/usb/unittests/make/Makefile          |  132 ++
 tools/usb/unittests/make/autoconfig.sh     |  118 ++
 tools/usb/unittests/usb/UASP_CMD_tests.cc  | 2140 ++++++++++++++++++++++++++++
 tools/usb/unittests/usb/UASP_TM_tests.cc   | 1207 ++++++++++++++++
 tools/usb/unittests/usb/UASP_tests.h       |  434 ++++++
 tools/usb/unittests/usb/composite_tests.cc | 1646 +++++++++++++++++++++
 tools/usb/unittests/usb/composite_tests.h  |   65 +
 tools/usb/unittests/usb/g_serial_tests.cc  |  198 +++
 tools/usb/unittests/usb/g_serial_tests.h   |   68 +
 tools/usb/unittests/usb/hs_expected_desc.h |  164 +++
 tools/usb/unittests/usb/libusb_utils.cc    |  358 +++++
 tools/usb/unittests/usb/libusb_utils.h     |  149 ++
 tools/usb/unittests/usb/ss_expected_desc.h |  291 ++++
 tools/usb/unittests/usb/streams_tests.cc   |  243 ++++
 tools/usb/unittests/usb/streams_tests.h    |   51 +
 tools/usb/unittests/usb/usb_devel_mode.cc  |  185 +++
 tools/usb/unittests/usb/usb_devel_mode.h   |   50 +
 tools/usb/unittests/usb/usb_tests.cc       |  651 +++++++++
 tools/usb/unittests/usb/usb_tests.h        |  146 ++
 tools/usb/unittests/usb/usb_tests_main.cc  |   83 ++
 tools/usb/unittests/usb/ut_config.h        |   89 ++
 21 files changed, 8468 insertions(+), 0 deletions(-)
 create mode 100644 tools/usb/unittests/make/Makefile
 create mode 100644 tools/usb/unittests/make/autoconfig.sh
 create mode 100644 tools/usb/unittests/usb/UASP_CMD_tests.cc
 create mode 100644 tools/usb/unittests/usb/UASP_TM_tests.cc
 create mode 100644 tools/usb/unittests/usb/UASP_tests.h
 create mode 100644 tools/usb/unittests/usb/composite_tests.cc
 create mode 100644 tools/usb/unittests/usb/composite_tests.h
 create mode 100644 tools/usb/unittests/usb/g_serial_tests.cc
 create mode 100644 tools/usb/unittests/usb/g_serial_tests.h
 create mode 100644 tools/usb/unittests/usb/hs_expected_desc.h
 create mode 100644 tools/usb/unittests/usb/libusb_utils.cc
 create mode 100644 tools/usb/unittests/usb/libusb_utils.h
 create mode 100644 tools/usb/unittests/usb/ss_expected_desc.h
 create mode 100644 tools/usb/unittests/usb/streams_tests.cc
 create mode 100644 tools/usb/unittests/usb/streams_tests.h
 create mode 100644 tools/usb/unittests/usb/usb_devel_mode.cc
 create mode 100644 tools/usb/unittests/usb/usb_devel_mode.h
 create mode 100644 tools/usb/unittests/usb/usb_tests.cc
 create mode 100644 tools/usb/unittests/usb/usb_tests.h
 create mode 100644 tools/usb/unittests/usb/usb_tests_main.cc
 create mode 100644 tools/usb/unittests/usb/ut_config.h

diff --git a/tools/usb/unittests/make/Makefile b/tools/usb/unittests/make/Makefile
new file mode 100644
index 0000000..3f4986e
--- /dev/null
+++ b/tools/usb/unittests/make/Makefile
@@ -0,0 +1,132 @@
+# A Makefile for building Google Test and USB30 tests.
+#
+# SYNOPSIS:
+#
+#   make [all]  - makes everything.
+#   make TARGET - makes the given target.
+#   make clean  - removes all files generated by make.
+#
+# Befor building the code the folowing env. variables needs to be set:
+# GTEST - Pointer to the root of Google Tests
+# KERNEL - Pointer to the Kernel code the test are about to be ran on
+#
+
+# Points to the root of Google Test, relative to where this file is.
+GTEST_DIR = $(GTEST)
+
+# Where to find usb tests code.
+USER_DIR = ../usb
+
+# Where to find kernel code.
+KERNEL_DIR = $(KERNEL)
+
+USB_INC_DIR = $(KERNEL_DIR)/include/linux/usb
+
+LINUX_INC_DIR = $(KERNEL_DIR)/arch/x86/include/asm
+
+# Flags passed to the preprocessor.
+CPPFLAGS += -I$(GTEST_DIR) -I$(GTEST_DIR)/include -I$(LIBUSB_INC)
+CPPFLAGS += -I$(KERNEL_DIR)/include
+#CPPFLAGS += -I$(KERNEL_DIR)/arch/x86/include
+
+# Flags passed to the C++ compiler.
+CXXFLAGS += -g -Wall -Wextra -m32
+
+LIBUSB_LIB = $(LIBUSB)/lib
+LFLAGS = -L/usr/lib32 -lstdc++ -L$(LIBUSB_LIB) -lusb-1.0 -lpthread
+
+# All tests produced by this Makefile.  Remember to add new tests you
+# created to the list.
+TESTS = usb_tests
+
+
+# All Google Test headers.  Usually you shouldn't change this
+# definition.
+GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
+                $(GTEST_DIR)/include/gtest/internal/*.h
+
+
+KERNEL_HEADERS = $(USB_INC_DIR)/*.h
+
+
+LIBUSB_INC = $(LIBUSB)/include/libusb-1.0
+LIBUSB_HEADERS = $(LIBUSB_INC)/libusb.h
+
+# House-keeping build targets.
+
+all : $(TESTS)
+
+clean :
+	rm -f $(TESTS) gtest.a gtest_main.a *.o
+
+# Builds gtest.a and gtest_main.a.
+
+# Usually you shouldn't tweak such internal variables, indicated by a
+# trailing _.
+GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
+
+# For simplicity and to avoid depending on Google Test's
+# implementation details, the dependencies specified below are
+# conservative and not optimized.  This is fine as Google Test
+# compiles fast and for ordinary users its source rarely changes.
+gtest-all.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(GTEST_DIR)/src/gtest-all.cc
+
+gtest_main.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(GTEST_DIR)/src/gtest_main.cc
+
+gtest.a : gtest-all.o
+	$(AR) $(ARFLAGS) $@ $^
+
+gtest_main.a : gtest-all.o gtest_main.o
+	$(AR) $(ARFLAGS) $@ $^
+
+# Builds a sample test.  A test should link with either gtest.a or
+# gtest_main.a, depending on whether it defines its own main()
+# function.
+
+libusb_utils.o : $(USER_DIR)/libusb_utils.cc \
+                     $(USER_DIR)/libusb_utils.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS) $(LIBUSB_HEADERS)
+		$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/libusb_utils.cc
+
+composite_tests.o : $(USER_DIR)/composite_tests.cc \
+                     $(USER_DIR)/composite_tests.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS) $(LIBUSB_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/composite_tests.cc
+
+g_serial_tests.o : $(USER_DIR)/g_serial_tests.cc \
+                     $(USER_DIR)/g_serial_tests.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/g_serial_tests.cc
+
+streams_tests.o : $(USER_DIR)/streams_tests.cc \
+                     $(USER_DIR)/streams_tests.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/streams_tests.cc
+
+UASP_CMD_tests.o : $(USER_DIR)/UASP_CMD_tests.cc \
+                     $(USER_DIR)/UASP_tests.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/UASP_CMD_tests.cc
+
+
+UASP_TM_tests.o : $(USER_DIR)/UASP_TM_tests.cc \
+                     $(USER_DIR)/UASP_tests.h $(KERNEL_HEADERS) \
+                     $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/UASP_TM_tests.cc
+
+usb_tests.o : $(USER_DIR)/usb_tests.cc $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/usb_tests.cc
+
+usb_tests_main.o : $(USER_DIR)/usb_tests_main.cc $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/usb_tests_main.cc
+
+usb_devel_mode.o : $(USER_DIR)/usb_devel_mode.cc $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/usb_devel_mode.cc
+
+usb_tests : g_serial_tests.o usb_tests.o usb_tests_main.o gtest.a \
+    composite_tests.o libusb_utils.o usb_devel_mode.o UASP_CMD_tests.o \
+    UASP_TM_tests.o streams_tests.o
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LFLAGS) $^ -o $@
+
diff --git a/tools/usb/unittests/make/autoconfig.sh b/tools/usb/unittests/make/autoconfig.sh
new file mode 100644
index 0000000..b8e90ff
--- /dev/null
+++ b/tools/usb/unittests/make/autoconfig.sh
@@ -0,0 +1,118 @@
+#!/bin/bash
+# A Script to configure the kernel .config file
+
+cat .config | sed -e 's/# CONFIG_BLK_DEV_INITRD is not set/CONFIG_BLK_DEV_INITRD=y/' > .config.new
+cp .config.new .config
+cat .config | sed -e 's/# CONFIG_EXT2_FS is not set/CONFIG_EXT2_FS=y\
+# CONFIG_EXT2_FS_XATTR is not set\
+# CONFIG_EXT2_FS_XIP is not set/' > .config.new
+cp .config.new .config
+cat .config | sed -e 's/# CONFIG_DEBUG_INFO is not set/CONFIG_DEBUG_INFO=y/' > .config.new
+cp .config.new .config
+cat .config | sed -e 's/# CONFIG_USB_GADGET is not set/CONFIG_USB_GADGET=m\
+CONFIG_USB_GADGET_DEBUG=y\
+CONFIG_USB_GADGET_DEBUG_FILES=y\
+CONFIG_USB_GADGET_DEBUG_FS=y\
+CONFIG_USB_GADGET_DEBUG_MODULE_LOAD=y\
+CONFIG_USB_GADGET_VBUS_DRAW=2\
+CONFIG_USB_GADGET_SELECTED=y\
+CONFIG_USB_GADGET_DUMMY_HCD=y\
+CONFIG_USB_DUMMY_HCD=m\
+CONFIG_USB_GADGET_DUALSPEED=y\
+CONFIG_USB_ZERO=m\
+CONFIG_USB_AUDIO=m\
+CONFIG_USB_ETH=m\
+CONFIG_USB_ETH_RNDIS=y\
+CONFIG_USB_ETH_EEM=y\
+CONFIG_USB_GADGETFS=m\
+CONFIG_USB_FILE_STORAGE=m\
+CONFIG_USB_FILE_STORAGE_TEST=y\
+CONFIG_USB_MASS_STORAGE=m\
+CONFIG_USB_G_SERIAL=m\
+CONFIG_USB_MIDI_GADGET=m\
+CONFIG_USB_G_PRINTER=m\
+CONFIG_USB_CDC_COMPOSITE=m\
+CONFIG_USB_G_MULTI=m\
+CONFIG_USB_G_MULTI_RNDIS=y\
+CONFIG_USB_G_MULTI_CDC=y\
+# CONFIG_USB_GADGET_AT91 is not set\
+# CONFIG_USB_GADGET_ATMEL_USBA is not set\
+# CONFIG_USB_GADGET_FSL_USB2 is not set\
+# CONFIG_USB_GADGET_LH7A40X is not set\
+# CONFIG_USB_GADGET_OMAP is not set\
+# CONFIG_USB_GADGET_PXA25X is not set\
+# CONFIG_USB_GADGET_R8A66597 is not set\
+# CONFIG_USB_GADGET_PXA27X is not set\
+# CONFIG_USB_GADGET_S3C_HSOTG is not set\
+# CONFIG_USB_GADGET_IMX is not set\
+# CONFIG_USB_GADGET_S3C2410 is not set\
+# CONFIG_USB_GADGET_M66592 is not set\
+# CONFIG_USB_GADGET_AMD5536UDC is not set\
+# CONFIG_USB_GADGET_FSL_QE is not set\
+# CONFIG_USB_GADGET_CI13XXX is not set\
+# CONFIG_USB_GADGET_NET2280 is not set\
+# CONFIG_USB_GADGET_GOKU is not set\
+# CONFIG_USB_GADGET_LANGWELL is not set/' > .config.new
+cp .config.new .config
+
+cat .config | sed -e 's/# CONFIG_USB_ACM is not set/CONFIG_USB_ACM=y/' > .config.new
+cp .config.new .config
+cat .config | sed -e 's/# CONFIG_USB_STORAGE_DEBUG is not set/CONFIG_USB_STORAGE_DEBUG=y/' > .config.new
+cp .config.new .config
+cat .config | sed -e 's/# CONFIG_USB_SERIAL is not set/CONFIG_USB_SERIAL=y\
+CONFIG_USB_SERIAL_CONSOLE=y\
+# CONFIG_USB_EZUSB is not set\
+CONFIG_USB_SERIAL_GENERIC=y\
+# CONFIG_USB_SERIAL_AIRCABLE is not set\
+# CONFIG_USB_SERIAL_ARK3116 is not set\
+# CONFIG_USB_SERIAL_BELKIN is not set\
+# CONFIG_USB_SERIAL_CH341 is not set\
+# CONFIG_USB_SERIAL_WHITEHEAT is not set\
+# CONFIG_USB_SERIAL_DIGI_ACCELEPORT is not set\
+# CONFIG_USB_SERIAL_CP210X is not set\
+# CONFIG_USB_SERIAL_CYPRESS_M8 is not set\
+# CONFIG_USB_SERIAL_EMPEG is not set\
+# CONFIG_USB_SERIAL_FTDI_SIO is not set\
+# CONFIG_USB_SERIAL_FUNSOFT is not set\
+# CONFIG_USB_SERIAL_VISOR is not set\
+# CONFIG_USB_SERIAL_IPAQ is not set\
+# CONFIG_USB_SERIAL_IR is not set\
+# CONFIG_USB_SERIAL_EDGEPORT is not set\
+# CONFIG_USB_SERIAL_EDGEPORT_TI is not set\
+# CONFIG_USB_SERIAL_GARMIN is not set\
+# CONFIG_USB_SERIAL_IPW is not set\
+# CONFIG_USB_SERIAL_IUU is not set\
+# CONFIG_USB_SERIAL_KEYSPAN_PDA is not set\
+# CONFIG_USB_SERIAL_KEYSPAN is not set\
+# CONFIG_USB_SERIAL_KLSI is not set\
+# CONFIG_USB_SERIAL_KOBIL_SCT is not set\
+# CONFIG_USB_SERIAL_MCT_U232 is not set\
+# CONFIG_USB_SERIAL_MOS7720 is not set\
+# CONFIG_USB_SERIAL_MOS7840 is not set\
+# CONFIG_USB_SERIAL_MOTOROLA is not set\
+# CONFIG_USB_SERIAL_NAVMAN is not set\
+# CONFIG_USB_SERIAL_PL2303 is not set\
+# CONFIG_USB_SERIAL_OTI6858 is not set\
+# CONFIG_USB_SERIAL_QCAUX is not set\
+# CONFIG_USB_SERIAL_QUALCOMM is not set\
+# CONFIG_USB_SERIAL_SPCP8X5 is not set\
+# CONFIG_USB_SERIAL_HP4X is not set\
+# CONFIG_USB_SERIAL_SAFE is not set\
+# CONFIG_USB_SERIAL_SIEMENS_MPI is not set\
+# CONFIG_USB_SERIAL_SIERRAWIRELESS is not set\
+# CONFIG_USB_SERIAL_SYMBOL is not set\
+# CONFIG_USB_SERIAL_TI is not set\
+# CONFIG_USB_SERIAL_CYBERJACK is not set\
+# CONFIG_USB_SERIAL_XIRCOM is not set\
+# CONFIG_USB_SERIAL_OPTION is not set\
+# CONFIG_USB_SERIAL_OMNINET is not set\
+# CONFIG_USB_SERIAL_OPTICON is not set\
+# CONFIG_USB_SERIAL_VIVOPAY_SERIAL is not set\
+# CONFIG_USB_SERIAL_DEBUG is not set/' > .config.new
+cp .config.new .config
+
+cat .config | sed -e 's/# CONFIG_USB_XHCI_HCD is not set/CONFIG_USB_XHCI_HCD=y\
+CONFIG_USB_XHCI_HCD_DEBUGGING=y/' > .config.new
+cp .config.new .config
+
+echo "DONE! Configured: CONFIG_USB_DUMMY_HCD=y"
\ No newline at end of file
diff --git a/tools/usb/unittests/usb/UASP_CMD_tests.cc b/tools/usb/unittests/usb/UASP_CMD_tests.cc
new file mode 100644
index 0000000..066219e
--- /dev/null
+++ b/tools/usb/unittests/usb/UASP_CMD_tests.cc
@@ -0,0 +1,2140 @@
+/*
+ * UASP_CMD_tests.cc - The tests in this file test the UASP COMMAND IUs
+ * handling. This file implements test to be run on a UASP supporting device.
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include "UASP_tests.h"
+#include "usb_tests.h"
+#include "usb_devel_mode.h"
+
+unsigned char reference_buf[1024] =
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    -\n"
+"reference       reference       reference       reference    0\n";
+
+
+/*
+ * verify_sense_iu() - prints and verifies the received sense_iu structure
+ * @buf: pointer to the sense_iu to print
+ * @length: size of the buf param
+ *
+ * Returns 0 if the status =  STATUS_GOOD
+ *         1 if the sense data is SS_OVERLAPPED_COMMANDS_ATTEMPTED
+ *         -1 otherwise
+ */
+static int verify_sense_iu(unsigned char *buf, int length)
+{
+	struct sense_iu *status_iu = (struct sense_iu *)buf;
+	unsigned long sense_data;
+	int rc = 0;
+
+	if (length != sizeof(struct sense_iu)) {
+		printf("verify_sense_iu(): length (%d) != status_iu size (%d)\n",
+		       length, sizeof(struct sense_iu));
+		return -1;
+	}
+
+	if (status_iu->iu_id != IU_ID_SENSE) {
+		printf("verify_sense_iu(): status_iu->iu_id != IU_ID_SENSE\n");
+		return -1;
+	}
+
+	switch (status_iu->status) {
+	case STATUS_GOOD:
+		printf("	Status received = STATUS_GOOD\n");
+		break;
+	case STATUS_CHECK_CONDITION:
+		printf("	Status received = STATUS_CHECK_CONDITION");
+		break;
+	case STATUS_CONDITION_MET:
+		printf("	Status received = STATUS_CONDITION_MET");
+		break;
+	case STATUS_BUSY:
+		printf("	Status received = STATUS_BUSY");
+		break;
+	case STATUS_RESERVATION_CONFLICT:
+		printf("	Status received = STATUS_RESERVATION_CONFLICT");
+		break;
+	case STATUS_TASK_SET_FULL:
+		printf("	Status received = STATUS_TASK_SET_FULL");
+		break;
+	case STATUS_ACA_ACTIVE:
+		printf("	Status received = STATUS_ACA_ACTIVE");
+		break;
+	case STATUS_TASK_ABORTED:
+		printf("	Status received = STATUS_TASK_ABORTED");
+		break;
+	default:
+		printf("	ERROR: Unknown status code!");
+	}
+	if (status_iu->status) {
+		/* Print the SENSE data*/
+		rc = -1;
+		sense_data = status_iu->sense_data[0] << 16 |
+				status_iu->sense_data[1] << 8 |
+				status_iu->sense_data[2];
+		switch (sense_data) {
+		case SS_COMMUNICATION_FAILURE:
+			printf("	SENSE DATA = SS_COMMUNICATION_FAILURE\n");
+			break;
+		case SS_INVALID_COMMAND:
+			printf("	SENSE DATA = SS_INVALID_COMMAND\n");
+			break;
+		case SS_INVALID_FIELD_IN_CDB:
+			printf("	SENSE DATA = SS_INVALID_FIELD_IN_CDB\n");
+			break;
+		case SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE:
+			printf("	SENSE DATA = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE\n");
+			break;
+		case SS_LOGICAL_UNIT_NOT_SUPPORTED:
+			printf("	SENSE DATA = SS_LOGICAL_UNIT_NOT_SUPPORTED\n");
+			break;
+		case SS_MEDIUM_NOT_PRESENT:
+			printf("	SENSE DATA = SS_MEDIUM_NOT_PRESENT\n");
+			break;
+		case SS_MEDIUM_REMOVAL_PREVENTED:
+			printf("	SENSE DATA = SS_MEDIUM_REMOVAL_PREVENTED\n");
+			break;
+		case SS_NOT_READY_TO_READY_TRANSITION:
+			rc = 0;
+			printf("	SENSE DATA = SS_NOT_READY_TO_READY_TRANSITION\n");
+			break;
+		case SS_RESET_OCCURRED:
+			printf("	SENSE DATA = SS_RESET_OCCURRED\n");
+			break;
+		case SS_SAVING_PARAMETERS_NOT_SUPPORTED:
+			printf("	SENSE DATA = SS_SAVING_PARAMETERS_NOT_SUPPORTED\n");
+			break;
+		case SS_UNRECOVERED_READ_ERROR:
+			printf("	SENSE DATA = SS_UNRECOVERED_READ_ERROR\n");
+			break;
+		case SS_WRITE_ERROR:
+			printf("	SENSE DATA = SS_WRITE_ERROR\n");
+			break;
+		case SS_WRITE_PROTECTED:
+			printf("	SENSE DATA = SS_WRITE_PROTECTED\n");
+			break;
+		case SS_OVERLAPPED_COMMANDS_ATTEMPTED:
+			printf("	SENSE DATA = SS_OVERLAPPED_COMMANDS_ATTEMPTED\n");
+			return 1;
+		default:
+			printf("	ERROR: Unrecognized sense data!\n");
+		}
+		printf(" (Press Enter to continue...)");
+		(void)getchar();
+	}
+	return rc;
+}
+
+/**
+ * print_cmdiu() - print the received command iu
+ * @cmdiu: pointer to the cmd_iu to print
+ *
+ */
+static void print_cmdiu(struct cmd_iu *cmdiu)
+{
+	printf("\ncmdiu->iu_id [%d] = %02x, \n"
+	       "cmdiu->reserved [%d] = %02x, \n"
+	       "cmdiu->ipt_tag [%d] = %d, \n"
+	       "cmdiu->forth_byte [%d] = %02x, \n"
+	       "cmdiu->reserved5 [%d] = %02x, \n"
+	       "cmdiu->length [%d] = %02x, \n"
+	       "cmdiu->reserved7 [%d] = %02x, \n"
+	       "cmdiu->lun[8] = \n"
+	       "%02x %02x %02x %02x %02x %02x %02x %02x\n"
+	       "cmdiu->cdb[16] = \n"
+	       "%02x %02x %02x %02x %02x %02x %02x %02x\n"
+	       "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+	       sizeof(cmdiu->iu_id), cmdiu->iu_id,
+	       sizeof(cmdiu->reserved), cmdiu->reserved,
+	       sizeof(cmdiu->tag), cmdiu->tag,
+	       sizeof(cmdiu->b), cmdiu->b,
+	       sizeof(cmdiu->reserved5), cmdiu->reserved5,
+	       sizeof(cmdiu->length), cmdiu->length,
+	       sizeof(cmdiu->reserved7), cmdiu->reserved7,
+	       cmdiu->lun[0], cmdiu->lun[1], cmdiu->lun[2], cmdiu->lun[3],
+	       cmdiu->lun[4], cmdiu->lun[5], cmdiu->lun[6], cmdiu->lun[7],
+	       cmdiu->cdb[0], cmdiu->cdb[1], cmdiu->cdb[2], cmdiu->cdb[3],
+	       cmdiu->cdb[4], cmdiu->cdb[5], cmdiu->cdb[6], cmdiu->cdb[7],
+	       cmdiu->cdb[8], cmdiu->cdb[9], cmdiu->cdb[10], cmdiu->cdb[11],
+	       cmdiu->cdb[12], cmdiu->cdb[13], cmdiu->cdb[14], cmdiu->cdb[15]);
+}
+
+/**
+ * fill_cmd_iu() - Fills the command iu structure with given values
+ * @iu: pointer to the cmd_iu structure to fill
+ * @cdb_opcode: OpCode of the CDB to send
+ * @lun: LUN number
+ * @add_length: additional_length field of the CDB
+ *
+ */
+void fill_cmd_iu(struct cmd_iu *iu, u8 cdb_opcode, u8 lun, u8 add_length)
+{
+	memset((void *)iu, 0 ,sizeof(struct cmd_iu));
+	iu->iu_id = 0x01; /* Command iu*/
+	iu->reserved = 0;
+	iu->tag = get_next_ip_tag();
+	memset(&iu->b,0,sizeof(iu->b));
+	iu->reserved5 = 0;
+	iu->length = 6;
+
+	memset(iu->lun, 0, 8);
+	iu->lun[0] = lun; /* Workaround: Right now @init we set lun_id[0] = i */
+	iu->cdb[0] = cdb_opcode;
+	iu->cdb[1] = 0;
+	iu->cdb[2] = 0;
+	iu->cdb[3] = 0;
+	iu->cdb[4] = add_length;
+	iu->cdb[5] = 0;
+}
+
+/**
+ * receive_read_iu() - Reads a READ IU from the device.
+ * @udev: handle of the libusb device
+ * @sts: pointer to the status endpoint descriptor
+ *
+ * Used when opperating in HS mode for DATA IN commands. In SS
+ * mode replaced by ERDY.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+static int receive_read_iu(struct libusb_device_handle *udev,
+				   struct libusb_endpoint_descriptor *sts,
+				   u16 tag)
+{
+	unsigned char buf[1024];
+	int transferred;
+	int ret;
+
+	if (!udev || !sts)
+		return -1;
+
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   UASP_SIZEOF_RW_READY_IU,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		return -1;
+	}
+	/* Verify the tag */
+	if (((struct rw_ready_iu*)buf)->tag != tag ||
+		((struct rw_ready_iu*)buf)->iu_id != IU_ID_READ_READY) {
+		printf("	ERROR: Received Incorrect IU!!!"
+			   " (iu_id = %d, tag = %d, expected_tag = %d)\n\n",
+			   ((struct rw_ready_iu*)buf)->iu_id,
+			   ((struct rw_ready_iu*)buf)->tag, tag);
+		return -1;
+	}
+	return 0;
+}
+
+/**
+ * exec_send_mode_sense10() - Test the MODE_SENSE10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the MODE_SENSE10 SCSI command to the device and verifies
+ * the correct reply from it.
+ * It consists of several tests (according to the fields of the
+ * MODE_SENSE10 CDB) :
+ * - First test case:
+ *	   page code = 0x08 (cashing)
+ * 	   pc = 0 (page control = return current values)
+ * - Second test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 01 (page control = return changable values)
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_mode_sense10(struct libusb_device *dev)
+{
+	struct cmd_iu modes_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	uint8_t buf[1024];
+	int transferred;
+	int ret = -1;
+
+	/*
+	 * First test case:
+	 * page code = 0x08 (cashing)
+	 * pc = 0 (page control = return current values)
+	 *
+	 * Expected reply:
+	 * buf[0-1] - len -2 = 18 = 0x00, 0x12
+	 * buf[3] = (curlun->lun->ro ? 0x80 : 0x00) = 0x00
+	 * buf[8] = 0x08  Page code
+	 * buf[9] = 0x0a  Page length
+	 * buf[10] = 0x04 Write cache enable, Read cache not disabled,
+	 *				 No cache retention priorities
+	 * buf[12]-buf[13] = 0xffff Don't disable prefetch
+	 * buf[14-15] = 0x00 Minimum prefetch = 0
+	 * buf[16-19] =0xffff, 0xffff Maximum prefetch ceiling
+	 * reply length = 20
+	 */
+	uint8_t expected_buf_t1[20] = {0x00, 0x12, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00,
+				       0x08, 0x0a, 0x04, 0x00,
+				       0xff, 0xff, 0x00, 0x00,
+				       0xff, 0xff, 0xff, 0xff};
+	/*
+	 * Second test case:
+	 * page code = 0x08 (cashing)
+	 * pc = 01 (page control = return changable values)
+	 *
+	 * expected reply:
+	 * buf[0-1] - len -2 = 18 = 0x00, 0x12
+	 * buf[3] = (curlun->lun->ro ? 0x80 : 0x00); = 0x00
+	 * buf[8] = 0x08  Page code
+	 * buf[9] = 0x0a  Page length
+	 * buf[10-19] = 0x00
+	 * reply length = 20
+	 */
+	uint8_t expected_buf_t2[20] = {0x00, 0x12, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00,
+				       0x08, 0x0a, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00};
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_mode_sense10_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_send_mode_sense10_done;
+	}
+	memset(buf, 0, 1024);
+
+	fill_cmd_iu(&modes_iu, 0x5a, UASP_LUN_NUM, 0x10);
+
+	/* First test case: */
+	/* Fill aditional cdb fields */
+	modes_iu.cdb[2] = 0x08; /* page code = cashing, pc = 0 */
+	printf("First test case: page code = 0x08 (cashing)\n"
+	       "		 pc = 0 (page controll = return current "
+	       "values)\n");
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&modes_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_mode_sense10_done;
+	}
+
+	memset(buf, 0, 1024);
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, modes_iu.tag))
+			goto exec_send_mode_sense10_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 20, &transferred, 2000);
+
+	if (memcmp(buf, expected_buf_t1, 20))
+		printf("	ERROR ocured! Received incorrect reply!\n"
+		       "	buf = %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x,\n"
+		       "	      %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4],
+		       buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
+		       buf[12], buf[13], buf[14], buf[15]);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_send_mode_sense10_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_send_mode_sense10_done;
+
+	/* Second test case: */
+	/* Fill aditional cdb fields */
+	modes_iu.cdb[2] = 0x48; /* page code = cashing, pc = 1 */
+	printf("Second test case: page code = 0x08 (cashing)\n"
+	       "		 pc = 1 (page controll = return changble "
+	       "values)\n");
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&modes_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_mode_sense10_done;
+	}
+
+	memset(buf, 0, 1024);
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, modes_iu.tag))
+			goto exec_send_mode_sense10_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 20, &transferred, 2000);
+
+	if (memcmp(buf, expected_buf_t2, 20))
+		printf("	ERROR ocured! Received incorrect reply!\n"
+		       "	buf = %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x,\n"
+		       "	      %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4],
+		       buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
+		       buf[12], buf[13], buf[14], buf[15]);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_mode_sense10_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_send_mode_sense() - Test the MODE_SENSE(6) SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the MODE_SENSE(6) SCSI command to the device and
+ * verifies the correct reply from it.
+ * It consists of several tests (according to the fields of the MODE_SENSE CDB):
+ * - First test case:
+ *	   page code = 0x08 (cashing)
+ * 	   pc = 0 (page control = return current values)
+ * - Second test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 01 (page control = return changable values)
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_mode_sense(struct libusb_device *dev)
+{
+	struct cmd_iu modes_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	uint8_t buf[1024];
+	int transferred;
+	int ret = -1;
+
+	/*
+	 * First test case:
+	 * page code = 0x08 (cashing)
+	 * pc = 0 (page control = return current values)
+	 *
+	 * Expected reply:
+	 * buf[0] - len -1 = 15
+	 * buf[2] = (curlun->lun->ro ? 0x80 : 0x00); = 0x00
+	 * buf[4] = 0x08  Page code
+	 * buf[5] = 0x0a  Page length
+	 * buf[6] = 0x04 Write cache enable, Read cache not disabled,
+	 *				 No cache retention priorities
+	 * buf[8]-buf[9] = 0xffff Don't disable prefetch
+	 * buf[10-11] = 0x00 Minimum prefetch = 0
+	 * buf[12-15] =0xffff, 0xffff Maximum prefetch ceiling
+	 * reply length = 16
+	 */
+	uint8_t expected_buf_t1[16] = {0x0f, 0x00, 0x00, 0x00,
+				       0x08, 0x0a, 0x04, 0x00,
+				       0xff, 0xff, 0x00, 0x00,
+				       0xff, 0xff, 0xff, 0xff};
+	/*
+	 * Second test case:
+	 * page code = 0x08 (cashing)
+	 * pc = 01 (page control = return changable values)
+	 *
+	 * Expected reply:
+	 * buf[0] - len -1 = 15
+	 * buf[2] = (curlun->lun->ro ? 0x80 : 0x00); = 0x00
+	 * buf[4] = 0x08  Page code
+	 * buf[5] = 0x0a  Page length
+	 * buf[6-15] = 0x00
+	 * reply length = 16
+	 */
+	uint8_t expected_buf_t2[16] = {0x0f, 0x00, 0x00, 0x00,
+				       0x08, 0x0a, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00,
+				       0x00, 0x00, 0x00, 0x00};
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_mode_sense_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_send_mode_sense_done;
+	}
+	memset(buf, 0, 1024);
+
+	fill_cmd_iu(&modes_iu, 0x1a, UASP_LUN_NUM, 0x10);
+
+	/* First test case: */
+	/* Fill aditional cdb fields */
+	modes_iu.cdb[2] = 0x08; /* page code = cashing, pc = 0 */
+	printf("First test case: page code = 0x08 (cashing)\n"
+	       "		 pc = 0 (page controll = return current "
+	       "values)\n");
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&modes_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_mode_sense_done;
+	}
+
+	memset(buf, 0, 1024);
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, modes_iu.tag))
+			goto exec_send_mode_sense_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 16, &transferred, 2000);
+
+	if (memcmp(buf, expected_buf_t1, 16))
+		printf("	ERROR ocured! Received incorrect reply!\n"
+		       "	buf = %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x,\n"
+		       "	      %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4],
+		       buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
+		       buf[12], buf[13], buf[14], buf[15]);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_send_mode_sense_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_send_mode_sense_done;
+
+	/* Second test case: */
+	/* Fill aditional cdb fields */
+	modes_iu.cdb[2] = 0x48; /* page code = cashing, pc = 1 */
+	printf("Second test case: page code = 0x08 (cashing)\n"
+	       "		 pc = 1 (page controll = return changble "
+	       "values)\n");
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&modes_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_mode_sense_done;
+	}
+
+	memset(buf, 0, 1024);
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, modes_iu.tag))
+			goto exec_send_mode_sense_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 16, &transferred, 2000);
+
+	if (memcmp(buf, expected_buf_t2, 16))
+		printf("	ERROR ocured! Received incorrect reply!\n"
+		       "	buf = %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x,\n"
+		       "	      %02x, %02x, %02x, %02x, %02x, %02x, %02x,"
+		       " %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4],
+		       buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
+		       buf[12], buf[13], buf[14], buf[15]);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_mode_sense_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_send_prevent_allow_removal() - Test the PREVENT_ALLOW_MEDIA_REMOVAL
+ * SCSI command
+ * @dev:pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_prevent_allow_removal(struct libusb_device *dev)
+{
+	struct cmd_iu prev_allow_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	uint8_t buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_prevent_allow_removal_done;
+	}
+
+	memset(buf, 0, 1024);
+
+	fill_cmd_iu(&prev_allow_iu, 0x1e, UASP_LUN_NUM, 0);
+	/* Update the prevent field */
+	prev_allow_iu.cdb[4] = 0x01;
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_send_prevent_allow_removal_done;
+	}
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&prev_allow_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_prevent_allow_removal_done;
+	}
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+	if (ret)
+		goto exec_send_prevent_allow_removal_done;
+
+	/*Restore the prevent_allow -> allow medium removal */
+	printf("Restoring to 'allow medium removal'...\n");
+	prev_allow_iu.cdb[4] = 0x00;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&prev_allow_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_prevent_allow_removal_done;
+	}
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_prevent_allow_removal_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_send_read_capacity() - Test the READ_CAPACITY SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the READ_CAPACITY SCSI command to the device and
+ * verifies the correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_read_capacity(struct libusb_device *dev)
+{
+	struct cmd_iu readc_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	uint8_t buf[1024];
+	int transferred;
+	int ret = -1;
+
+	unsigned long lba, block_length ;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_read_capacity_done;
+	}
+
+	memset(buf, 0, 1024);
+
+	fill_cmd_iu(&readc_iu, 0x25, UASP_LUN_NUM, 0);
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_send_read_capacity_done;
+	}
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&readc_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_read_capacity_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, readc_iu.tag))
+			goto exec_send_read_capacity_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 8, &transferred, 2000);
+	lba = IUGETDW(&buf[0]);
+	block_length = IUGETDW(&buf[4]);
+	printf("reply received:\n"
+	       "	LBA = %d,	Block Length = %d\n",
+	       (int)lba, (int)block_length);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_read_capacity_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_send_inquiry() - Test the INQUIRY SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the INQUIRY SCSI command to the device and verifies the
+ * correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_inquiry(struct libusb_device *dev)
+{
+	struct cmd_iu inq_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	char vendor_id[9];
+	char prod_id[17];
+	int *prod_level;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_inquiry_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_send_inquiry_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&inq_iu, 0x12, UASP_LUN_NUM, 0x24);
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&inq_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_inquiry_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev,sts,inq_iu.tag))
+			goto exec_send_inquiry_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, CMDIU_SIZE, &transferred, 2000);
+
+	printf("reply received: size = %d, ret=%d\n", transferred, ret);
+	memcpy(vendor_id,&(buf[8]),sizeof(vendor_id));
+	memcpy(prod_id,&(buf[16]),sizeof(prod_id));
+	prod_level = (int*)&(buf[32]);
+	printf("     Vendor identification (ASCII)[8-15]: %s\n"
+	      "     Product identification (ASCII)[16-31]: %s\n"
+	      "     Product revision level[32-35]: %x\n", &buf[8], prod_id,
+		*prod_level);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_inquiry_done:
+	libusb_close(udev);
+    return ret;
+}
+
+
+/**
+ * exec_send_request_sense() - Test the REQUEST_SENCE command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the REQUEST_SENCE SCSI command to the device and
+ * verifies the correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_request_sense(struct libusb_device *dev)
+{
+	struct cmd_iu sense_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_send_request_sense_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find Command BULK OUT endpoint!\n");
+		goto exec_send_request_sense_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&sense_iu, 0x03, UASP_LUN_NUM, 0x18);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&sense_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_send_request_sense_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, sense_iu.tag))
+			goto exec_send_request_sense_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 18, &transferred, 2000);
+
+	printf("Reply received: size = %d, ret=%d\n", transferred, ret);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_send_request_sense_done:
+	libusb_close(udev);
+    return ret;
+}
+
+/**
+ * exec_test_unit_ready() - Test the TEST_UNIT_READY command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_unit_ready(struct libusb_device *dev)
+{
+	struct cmd_iu unit_ready_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_unit_ready_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_unit_ready_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&unit_ready_iu, 0x00, UASP_LUN_NUM, 0);
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_unit_ready_done;
+	}
+
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n", ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_test_unit_ready_done:
+	libusb_close(udev);
+    return ret;
+}
+
+/**
+ * test_write() - Tests the SCSI WRITE command
+ * @dev: pointer to the libusb device to run the test on
+ * @write_iu: pointer to the cmdiu to send
+ * @data_size: size of the data to write
+ * @data_buf: the data buffer to write
+ *
+ * This function is used to test the WRITE6, WRITE10 and WRITE12 SCSI commands.
+ *
+ * Return 0 on success, -1 otherwise
+ * TODO: add write verification
+ */
+static int test_write(struct libusb_device *dev,
+			  struct cmd_iu write_iu,
+			  int data_size,
+			  unsigned char *data_buf)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkout, *bulkin, *sts;
+	unsigned char buf[1024];
+	unsigned char *read_to_buf;
+
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	read_to_buf = (unsigned char *)malloc(data_size);
+	if (!read_to_buf) {
+		printf("	ERROR: cound't allocate memory!\n");
+		return ret;
+	}
+	/*
+	 * Prior to a write command we need to send test_unit_ready command to
+	 * verify that the device is ready for data transfer
+	 */
+	ret = exec_test_unit_ready(dev);
+	if (ret) {
+		printf("TEST_UNIT_READY failed\n");
+		goto exec_test_write_done;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_write_done;
+	}
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkout = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_OUT);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !bulkout || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_write_done;
+	}
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&write_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_write_done;
+	}
+
+	/* If we're working in HS mode we should receive a WRITE READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER) {
+		memset(buf, 0, sizeof(buf));
+		ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+					   UASP_SIZEOF_RW_READY_IU,
+					   &transferred, 2000);
+
+		if (ret) {
+			printf("libusb_bulk_transfer error = %d\n",ret);
+			goto exec_test_write_done;
+		}
+		/* Verify the tag */
+		if (((struct rw_ready_iu*)buf)->tag != write_iu.tag ||
+		    ((struct rw_ready_iu*)buf)->iu_id != IU_ID_WRITE_READY) {
+			printf("	ERROR: Received Incorrect IU!!!"
+			       " (iu_id = %d, tag = %d, expected_tag = %d)\n\n",
+			       ((struct rw_ready_iu*)buf)->iu_id,
+			       ((struct rw_ready_iu*)buf)->tag, write_iu.tag);
+			goto exec_test_write_done;
+		}
+	}
+
+	printf("	Sending Data:...\n");
+	ret = libusb_bulk_transfer(udev, bulkout->bEndpointAddress,
+				   data_buf, data_size, &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_write_done;
+	}
+	printf("data sent: transferred = %d, data_size = %d\n",
+	       transferred, data_size);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_write_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+
+exec_test_write_done:
+	free(read_to_buf);
+	libusb_close(udev);
+    return ret;
+}
+
+/**
+ * test_read() - Tests the SCSI READ command
+ * @dev: pointer to the libusb device to run the test on
+ * @write_iu: pointer to the cmdiu to send
+ * @data_size: size of the data to read
+ *
+ * This function is used to test the READ6, READ10 and READ12 SCSI commands.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+static int test_read(struct libusb_device *dev,
+			  struct cmd_iu read_iu,
+			  int data_size)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/*
+	 * Prior to a read command we need to send test_unit_ready command to
+	 * verify that the device is ready for data transfer
+	 */
+	ret = exec_test_unit_ready(dev);
+	if (ret) {
+		printf("TEST_UNIT_READY failed\n");
+		goto exec_test_read_done;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_read_done;
+	}
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_read_done;
+	}
+
+	memset(buf, 0, sizeof(buf));
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&read_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_read_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, read_iu.tag))
+			goto exec_test_read_done;
+
+	printf("waiting for data...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, data_size, &transferred, 2000);
+
+	printf("Reply received: size = %d, ret=%d\n", transferred, ret);
+	if (transferred != sizeof(reference_buf))
+		printf("\n	ERROR: Received less data then expected (%d)\n",
+		      sizeof(reference_buf));
+	else
+		if (memcmp(buf, reference_buf, sizeof(reference_buf)))
+			printf("	Receieved not-expected data:\n%s\n",
+			       buf);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+
+exec_test_read_done:
+	libusb_close(udev);
+    return ret;
+}
+
+int reset_data_file(struct libusb_device *dev)
+{
+	unsigned char buf[1024];
+	struct cmd_iu write_iu;
+	int i = 0;
+
+	printf("	Reseting data file...\n");
+	/* Fill the data buffer*/
+	for (i = 0; i < 1024; i++) {
+		if (!(i % 100))
+			buf[i] = 0x0a;
+		else
+			buf[i] = 0x41;
+	}
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	return test_write(dev, write_iu, 1024, buf);
+}
+
+/**
+ * exec_test_read6() - Test the READ6 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read6(struct libusb_device *dev)
+{
+	struct cmd_iu read6_iu;
+	struct cmd_iu write_iu;
+
+	int rc = 0;
+
+	/* Write the reference_buf to the file prior to reading */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	rc = test_write(dev, write_iu, sizeof(reference_buf), reference_buf);
+	if (rc) {
+		printf("Failed to write reference buffer\n");
+		return rc;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&read6_iu, 0x08, UASP_LUN_NUM, 0);
+	read6_iu.cdb[4] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_read(dev, read6_iu, 1024);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+/**
+ * exec_test_read10() - Test the READ10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read10(struct libusb_device *dev)
+{
+	struct cmd_iu read10_iu;
+	struct cmd_iu write_iu;
+	int rc = 0;
+
+	/* Write the reference_buf to the file prior to reading */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	rc = test_write(dev, write_iu, sizeof(reference_buf), reference_buf);
+	if (rc) {
+		printf("Failed to write reference buffer\n");
+		return rc;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&read10_iu, 0x28, UASP_LUN_NUM, 0);
+	read10_iu.cdb[8] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_read(dev, read10_iu, 1024);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+/**
+ * exec_test_read12() - Test the READ12 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read12(struct libusb_device *dev)
+{
+	struct cmd_iu read12_iu;
+	struct cmd_iu write_iu;
+	int rc = 0;
+
+	/* Write the reference_buf to the file prior to reading */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	rc = test_write(dev, write_iu, sizeof(reference_buf), reference_buf);
+	if (rc) {
+		printf("Failed to write reference buffer\n");
+		return rc;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&read12_iu, 0xa8, UASP_LUN_NUM, 0);
+	read12_iu.cdb[9] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_read(dev, read12_iu, 1024);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+/**
+ * exec_test_write6() - Test the WRITE6 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write6(struct libusb_device *dev)
+{
+	struct cmd_iu write6_iu;
+	unsigned char buf[1024];
+	int i, rc;
+
+	/* Fill the data buffer*/
+	for (i = 0; i < 1024; i++) {
+		if (!(i % 100))
+			buf[i] = 0x0a;
+		else
+			buf[i] = 0x41;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&write6_iu, 0x0a, UASP_LUN_NUM, 0);
+	write6_iu.cdb[4] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_write(dev, write6_iu, 1024, buf);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+
+/**
+ * exec_test_write10() - Test the WRITE10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write10(struct libusb_device *dev)
+{
+	struct cmd_iu write10_iu;
+	unsigned char buf[1024];
+	int i, rc;
+
+	/* Fill the data buffer*/
+	for (i = 0; i < 1024; i++) {
+		if (!(i % 100))
+			buf[i] = 0x0a;
+		else
+			buf[i] = 0x42;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&write10_iu, 0x2a, UASP_LUN_NUM, 0);
+	write10_iu.cdb[8] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_write(dev, write10_iu, 1024, buf);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+
+/**
+ * exec_test_write12() - Test the WRITE12 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write12(struct libusb_device *dev)
+{
+	struct cmd_iu write12_iu;
+	unsigned char buf[1024];
+	int i, rc;
+
+	/* Fill the data buffer*/
+	for (i = 0; i < 1024; i++) {
+		if (!(i % 100))
+			buf[i] = 0x0a;
+		else
+			buf[i] = 0x43;
+	}
+
+	/* Start reading from block 0, LBA = 0  */
+	fill_cmd_iu(&write12_iu, 0xaa, UASP_LUN_NUM, 0);
+	write12_iu.cdb[9] = 0x02; /* read 2 blocks (of 512 bytes) */
+
+	rc = test_write(dev, write12_iu, 1024, buf);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return rc;
+}
+
+/**
+ * exec_test_write_huge() - Test the WRITE10 SCSI command with alot of data
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write_huge(struct libusb_device *dev)
+{
+	struct cmd_iu write10_iu;
+	unsigned char buf[31744];
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkout, *bulkin, *sts;
+
+	int transferred, i;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/*
+	 * Prior to a write command we need to send test_unit_ready command to
+	 * verify that the device is ready for data transfer
+	 */
+	ret = exec_test_unit_ready(dev);
+	if (ret) {
+		printf("TEST_UNIT_READY failed\n");
+		goto exec_test_write_huge_done;
+	}
+
+	/* Fill the data buffer*/
+	for (i = 0; i < 31744; i++) {
+		if (!(i % 100))
+			buf[i] = 0x0a;
+		else
+			buf[i] = 0x42;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_write_huge_done;
+	}
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkout = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_OUT);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !bulkout || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_write_huge_done;
+	}
+
+	/* Start writing from block 0, LBA = 0  */
+	fill_cmd_iu(&write10_iu, 0x2a, UASP_LUN_NUM, 0);
+	/* write 62 blocks (of 512 bytes) = 31744 bytes*/
+	write10_iu.cdb[8] = 0x3e;
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&write10_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_write_huge_done;
+	}
+
+		/* If we're working in HS mode we should receive a WRITE READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER) {
+		memset(buf, 0, sizeof(buf));
+		ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+					   UASP_SIZEOF_RW_READY_IU,
+					   &transferred, 2000);
+
+		if (ret) {
+			printf("libusb_bulk_transfer error = %d\n",ret);
+			goto exec_test_write_huge_done;
+		}
+		/* Verify the tag */
+		if (((struct rw_ready_iu*)buf)->tag != write10_iu.tag ||
+		    ((struct rw_ready_iu*)buf)->iu_id != IU_ID_WRITE_READY) {
+			printf("	ERROR: Received Incorrect IU!!!"
+			       " (iu_id = %d, tag = %d, expected_tag = %d)\n\n",
+			       ((struct rw_ready_iu*)buf)->iu_id,
+			       ((struct rw_ready_iu*)buf)->tag, write10_iu.tag);
+			goto exec_test_write_huge_done;
+		}
+	}
+
+	printf("	Sending Data:...\n");
+	ret = libusb_bulk_transfer(udev, bulkout->bEndpointAddress,
+				   buf, 31744, &transferred, 0);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_write_huge_done;
+	}
+
+	printf("data sent: transferred = %d\n", transferred);
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_write_huge_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+
+	if (ret)
+		goto exec_test_write_huge_done;
+
+	ret = 0;
+exec_test_write_huge_done:
+	libusb_close(udev);
+	if (reset_data_file(dev))
+		printf("	Failed Reseting data fail!\n");
+	return ret;
+}
+
+/**
+ * exec_test_read_format_capacities() - Test the READ FORMAT CAPACITIES
+ * SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read_format_capacities(struct libusb_device *dev)
+{
+	struct cmd_iu form_cap_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	unsigned char expected_buf[12] = {0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+					  0x07, 0xa1, 0x02, 0x00, 0x02, 0x00};
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_read_format_capacities_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !bulkin || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_read_format_capacities_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&form_cap_iu, 0x23, UASP_LUN_NUM, 0);
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&form_cap_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_read_format_capacities_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, form_cap_iu.tag))
+			goto exec_test_read_format_capacities_done;
+
+	printf("waiting for reply:...\n");
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 12, &transferred, 2000);
+
+	if (memcmp(expected_buf, buf, 12)) {
+		printf("Received incorrect reply:\n"
+			"	buf = %02x, %02x, %02x, %02x, %02x, %02x,\n"
+			"	      %02x, %02x, %02x, %02x, %02x, %02x\n",
+			       buf[0], buf[1], buf[2], buf[3], buf[4],
+			       buf[5], buf[6], buf[7], buf[8], buf[9],
+			       buf[10], buf[11]);
+	} else
+		printf("Received expected data\n");
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret){
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_read_format_capacities_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_read_format_capacities_done;
+	ret = 0;
+exec_test_read_format_capacities_done:
+	libusb_close(udev);
+    return ret;
+}
+
+/**
+ * exec_test_start_stop() - Test the TEST_START_STOP_UNIT command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ *
+ * TODO: this test isn't full. It doesn't check that the unit was indeed
+ * started/ejected etc. It just verifies the completion status.
+ */
+int exec_test_start_stop(struct libusb_device *dev)
+{
+	struct cmd_iu start_stop_iu, sense_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_start_stop_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !sts || !bulkin) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_start_stop_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&start_stop_iu, 0x1b, UASP_LUN_NUM, 0);
+
+	/* First test case (LoEj,Start) = 00 (stop motor) */
+	printf("	First test case (LoEj,Start) = 00 (stop motor)\n");
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&start_stop_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret){
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_start_stop_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_start_stop_done;
+
+	/* Second test case (LoEj,Start) = 01 (start motor) */
+	printf("	Second test case (LoEj,Start) = 01 (start motor)\n");
+	start_stop_iu.cdb[4] = 0x01;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&start_stop_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_start_stop_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_start_stop_done;
+
+	/* Third test case (LoEj,Start) = 10 (Eject media) */
+	printf("	Third test case (LoEj,Start) = 10 (Eject media)\n");
+	start_stop_iu.cdb[4] = 0x02;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&start_stop_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret){
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_start_stop_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_start_stop_done;
+
+	/*
+	 * After the media is ejected the lun is closed. We need to re-open
+	 * it manualy in order to be able to continue working with it
+	 */
+	ret = usb_tests_write_gadget_sysfs_file_str((char *)"lun0/file",
+					(char *)"/root/back_storage_file.txt");
+	if (ret) {
+		printf("Write to device_attr(file) failed %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+	/* After the LUN was re-opened, issue a REQUEST SENSE first */
+	printf("Issue REQUEST SENSE...\n");
+	fill_cmd_iu(&sense_iu, 0x03, UASP_LUN_NUM, 0x18);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&sense_iu, CMDIU_SIZE,
+				   &transferred, 2000);
+
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER &&
+		receive_read_iu(udev, sts, sense_iu.tag))
+			goto exec_test_start_stop_done;
+
+	ret = libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, 18, &transferred, 2000);
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret)
+		printf("libusb_bulk_transfer error = %d\n",ret);
+	else
+		ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_start_stop_done;
+
+	/* Forth test case (LoEj,Start) = 11 (LOAD media) */
+	printf("	Forth test case (LoEj,Start) = 11 (LOAD media)\n");
+	start_stop_iu.cdb[4] = 0x03;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&start_stop_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_start_stop_done;
+	}
+
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret){
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_start_stop_done;
+	}
+	ret = verify_sense_iu(buf, transferred);
+	if (ret)
+		goto exec_test_start_stop_done;
+
+	ret = 0;
+exec_test_start_stop_done:
+	libusb_close(udev);
+    return ret;
+}
+
+/**
+ * exec_test_verify() - Test the VERIFY command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_verify(struct libusb_device *dev)
+{
+	struct cmd_iu verify_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_verify_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_verify_done;
+	}
+
+	/* First write data to the device to verify it */
+	if (exec_test_write6(dev)) {
+		printf("	ERROR: write (prior to verify) failed!\n");
+		goto exec_test_verify_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&verify_iu, 0x2f, UASP_LUN_NUM, 0);
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&verify_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_verify_done;
+	}
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_verify_done;
+	}
+	ret = verify_sense_iu(buf,transferred);
+	if (ret)
+		goto exec_test_verify_done;
+
+	ret = 0;
+exec_test_verify_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_synchronize_cache() - Test the SYNCHRONIZE CACHE
+ * command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_synchronize_cache(struct libusb_device *dev)
+{
+	struct cmd_iu sync_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_sync_cache_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_sync_cache_done;
+	}
+
+	memset(buf, 0, 1024);
+	fill_cmd_iu(&sync_iu, 0x35, UASP_LUN_NUM, 0);
+	/* Update CDB fields */
+	sync_iu.cdb[8] = 2;
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&sync_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_sync_cache_done;
+	}
+
+	printf("	Reading status:...\n");
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+				   SENSEIU_SIZE, &transferred, 2000);
+
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_sync_cache_done;
+	}
+	ret = verify_sense_iu(buf,transferred);
+	if (ret)
+		goto exec_test_sync_cache_done;
+
+	ret = 0;
+exec_test_sync_cache_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_cmd_overlapped_tag() - Verifies correct behavior in
+ * case of CMD overlapped tag attempted
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_cmd_overlapped_tag(struct libusb_device *dev)
+{
+	struct cmd_iu unit_ready_iu, tag_error_cmd;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_cmd_overlapped_tag_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_cmd_overlapped_tag_done;
+	}
+
+	/* Issue command for the overlapped tag condition */
+	fill_cmd_iu(&unit_ready_iu, 0x00, UASP_LUN_NUM, 0x00);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_cmd_overlapped_tag_done;
+	}
+
+	printf("Issued TEST UNIT TEADY command...\n");
+
+	/* Now issue a CMD with the same tag */
+	fill_cmd_iu(&tag_error_cmd, 0x00, UASP_LUN_NUM, 0x00);
+	tag_error_cmd.tag = unit_ready_iu.tag;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&tag_error_cmd,
+				   CMDIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_cmd_overlapped_tag_done;
+	}
+
+	printf("Issued a CMD with the same tag...\n");
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_cmd_overlapped_tag_done;
+	} else
+		ret = verify_sense_iu(buf,transferred);
+
+	if (ret != 1)
+		goto exec_test_cmd_overlapped_tag_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_cmd_overlapped_tag_done;
+	}
+
+	ret = 0;
+exec_test_cmd_overlapped_tag_done:
+	libusb_close(udev);
+	/* If test sucseded, verify that the device is functional */
+	if (!ret && exec_send_request_sense(dev)) {
+		printf("	ERROR: After overlapped tag the device is not"
+		       "functional!!!\n");
+		ret = -1;
+	}
+	return ret;
+}
diff --git a/tools/usb/unittests/usb/UASP_TM_tests.cc b/tools/usb/unittests/usb/UASP_TM_tests.cc
new file mode 100644
index 0000000..ab360ca
--- /dev/null
+++ b/tools/usb/unittests/usb/UASP_TM_tests.cc
@@ -0,0 +1,1207 @@
+/*
+ * UASP_TM_tests.cc - The tests in this file test the UASP TASK MANAGEMENT IUs
+ * handling. This file implements test to be run on a UASP supporting device.
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include "UASP_tests.h"
+#include "usb_tests.h"
+#include "usb_devel_mode.h"
+
+struct command_status{
+	u8 code; /* for cmdiu this is CDB OpCode. For tmiu this is tm func */
+	u16 tag;
+	int is_cmdiu;
+	int expected_comp_sts;
+	int stat_received;
+};
+
+#define MAX_ACTIVE_COMMANDS 100
+static struct command_status active_cmd_arr[MAX_ACTIVE_COMMANDS];
+static int num_act_cmd = 0;
+
+static void reset_active_cmd_arr()
+{
+	int i=0;
+	for (i = 0; i < MAX_ACTIVE_COMMANDS; i++) {
+		active_cmd_arr[i].code = 0;
+		active_cmd_arr[i].tag = 0;
+		active_cmd_arr[i].is_cmdiu = 0;
+		active_cmd_arr[i].expected_comp_sts = -1;
+	}
+	num_act_cmd = 0;
+}
+
+static void add_cmd_to_arr(u8 code,
+			   u16 tag,
+			   int is_cmdiu,
+			   int expected_comp_sts)
+{
+	active_cmd_arr[num_act_cmd].code = code;
+	active_cmd_arr[num_act_cmd].tag = tag;
+	active_cmd_arr[num_act_cmd].is_cmdiu = is_cmdiu;
+	active_cmd_arr[num_act_cmd].expected_comp_sts = expected_comp_sts;
+	active_cmd_arr[num_act_cmd++].stat_received = 0;
+}
+
+static int find_cmd_in_arr(u16 tag){
+	int i;
+	for (i = 0; i < num_act_cmd; i++)
+		if (active_cmd_arr[i].tag == tag)
+			return i;
+	return -1;
+}
+
+static int analize_received_status(unsigned char *buf)
+{
+	struct sense_iu *sense;
+	struct response_iu *response;
+	u16 tag;
+	int is_cmdiu;
+	int cmd_index;
+	int status;
+
+	if (buf[0] == 0x03) {
+		sense = (struct sense_iu*)buf;
+		tag = sense->tag;
+		is_cmdiu = 1;
+		status = sense->status;
+	} else if (buf[0] == 0x04){
+		response = (struct response_iu *)buf;
+		tag = response->tag;
+		is_cmdiu = 0;
+		status = response->status;
+	} else {
+		printf("	ERROR: Unknoun packet received!"
+		       " (IU ID = %d)\n", buf[0]);
+		return -1;
+	}
+
+	cmd_index = find_cmd_in_arr(tag);
+	if (cmd_index == -1) {
+		printf("	ERROR: command with such iptag "
+		       "wasn't issued!\n");
+		return -1;
+	}
+	if (active_cmd_arr[cmd_index].stat_received) {
+		printf("	ERROR: Received comp status for same"
+		       " commad twise!\n");
+		return -1;
+	}
+	if (is_cmdiu && !active_cmd_arr[cmd_index].is_cmdiu) {
+		printf("	ERROR: received SENSE IU for TM IU\n");
+		return -1;
+	}
+	if (active_cmd_arr[cmd_index].expected_comp_sts != status) {
+		printf("	ERROR! Completion status isn't as "
+		       "expected!\n"
+		       "	Expected %02x	Received %02x\n",
+		       active_cmd_arr[cmd_index].expected_comp_sts, status);
+		return -1;
+	}
+	printf("	Received status for command code = %02x\n",
+	       active_cmd_arr[cmd_index].code);
+	active_cmd_arr[cmd_index].stat_received = 1;
+	return 0;
+}
+
+/**
+ * fill_tm_iu() - Fills the command iu structure with given values
+ * @iu: pointer to the tm_iu structure to fill
+ * @tm_function: TM function type to fill
+ * @lun: LUN number
+ *
+ */
+void fill_tm_iu(struct tm_iu *iu, u8 tm_function, u8 lun)
+{
+	memset((void *)iu, 0 ,sizeof(struct tm_iu));
+	iu->iu_id = 0x05; /* task management iu*/
+	iu->reserved1 = 0;
+	iu->tag = get_next_ip_tag();
+	iu->tm_function = tm_function;
+	iu->reserved5 = 0;
+	/* Reserved for all tm_functions but ABORT_TASK and QUERY_TASK */
+	iu->task_tag = 0;
+	memset(iu->lun, 0, 8);
+	iu->lun[0] = lun; /* Workaround: Right now @init we set lun_id[0] = i */
+}
+
+/**
+ * exec_test_tm_reset_lun() - Test the LOGICAL LUN RESET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_reset_lun(struct libusb_device *dev)
+{
+	struct tm_iu reset_lun_iu;
+	struct cmd_iu write_iu, read_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_reset_lun_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_reset_lun_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue 2 commands to be canceled later on by the LUN_RESET TM */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&write_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_lun_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(write_iu.cdb[0], write_iu.tag, 1, -1);
+
+	fill_cmd_iu(&read_iu, 0x08, UASP_LUN_NUM, 0);
+	read_iu.cdb[4] = 0x02; /* read 2 blocks (of 512 bytes) */
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&read_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_lun_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(read_iu.cdb[0], read_iu.tag, 1, -1);
+
+	/* Now issue the LUN_RESET TM */
+	fill_tm_iu(&reset_lun_iu, 0x08, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&reset_lun_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_lun_done;
+	}
+
+
+	add_cmd_to_arr(reset_lun_iu.tm_function, reset_lun_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_reset_lun_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_reset_lun_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_tm_reset_lun_done;
+	}
+	ret = 0;
+exec_test_tm_reset_lun_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_tm_abort_task() - Test the ABORT_TASK TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_abort_task(struct libusb_device *dev)
+{
+	struct tm_iu abort_cmd_iu;
+	struct cmd_iu write_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_abort_task_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_abort_task_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue a command to be canceled later on by the ABORT_TASK TM */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&write_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_task_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(write_iu.cdb[0], write_iu.tag, 1, -1);
+
+	/* Now issue the ABORT TASK TM */
+	fill_tm_iu(&abort_cmd_iu, 0x01, UASP_LUN_NUM);
+	abort_cmd_iu.task_tag = write_iu.tag;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&abort_cmd_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_task_done;
+	}
+
+
+	add_cmd_to_arr(abort_cmd_iu.tm_function, abort_cmd_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_abort_task_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_abort_task_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_tm_abort_task_done;
+	}
+	ret = 0;
+
+exec_test_tm_abort_task_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_tm_abort_task_set() - Test the ABORT TASK SET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_abort_task_set(struct libusb_device *dev)
+{
+	struct tm_iu abort_ts_iu, query_ts_iu;
+	struct cmd_iu write_iu, read_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_abort_ts_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_abort_ts_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue 2 commands to be canceled later on by the ABORT_TASK_SET TM */
+	fill_cmd_iu(&write_iu, 0x0a, UASP_LUN_NUM, 0);
+	write_iu.cdb[4] = 0x02; /* write 2 blocks (of 512 bytes) */
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&write_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_ts_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(write_iu.cdb[0], write_iu.tag, 1, -1);
+
+	fill_cmd_iu(&read_iu, 0x08, UASP_LUN_NUM, 0);
+	read_iu.cdb[4] = 0x02; /* read 2 blocks (of 512 bytes) */
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&read_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_ts_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(read_iu.cdb[0], read_iu.tag, 1, -1);
+
+	/* Now issue the ABORT_TASK_SET TM */
+	fill_tm_iu(&abort_ts_iu, 0x02, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&abort_ts_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_ts_done;
+	}
+
+
+	add_cmd_to_arr(abort_ts_iu.tm_function, abort_ts_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+
+	/* Issue another TM that should not be canceled */
+	fill_tm_iu(&query_ts_iu, 0x81, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_ts_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_abort_ts_done;
+	}
+
+
+	add_cmd_to_arr(query_ts_iu.tm_function, query_ts_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* read status for both TM IUs issued*/
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_abort_ts_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_abort_ts_done;
+		memset(buf, 0, sizeof(buf));
+
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_abort_ts_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_abort_ts_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_tm_abort_ts_done;
+	}
+	ret = 0;
+exec_test_tm_abort_ts_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_tm_reset_nexus() - Test the RESET NEXUS TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_reset_nexus(struct libusb_device *dev)
+{
+	struct tm_iu reset_nexus_iu;
+	struct cmd_iu inq_iu, unit_ready_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts || !bulkin) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue 2 commands to be completed befor the RESET_NEXUS TM */
+	fill_cmd_iu(&inq_iu, 0x12, UASP_LUN_NUM, 0x24);
+	printf("Sending INQUIRY command...\n");
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&inq_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+	add_cmd_to_arr(inq_iu.cdb[0], inq_iu.tag, 1, -1);
+	/* No status is expected for this command */
+	fill_cmd_iu(&unit_ready_iu, 0x00, UASP_LUN_NUM, 0);
+	printf("Sending TEST UNIT READY command...\n");
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+	/* No status is expected for this command */
+	add_cmd_to_arr(unit_ready_iu.cdb[0], unit_ready_iu.tag, 1, -1);
+
+	/* Now issue the RESET_NEXUS TM */
+	printf("Sending RESET NEXUS TM...\n");
+	fill_tm_iu(&reset_nexus_iu, 0x10, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&reset_nexus_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+
+	add_cmd_to_arr(reset_nexus_iu.tm_function, reset_nexus_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* Try reading inquiry result - should fail */
+	/*
+	 * Due to the implementation in dummy_hcd this woun't fail.
+	 * See implementation of dummy_queue() for details
+	 */
+	memset(buf, 0, sizeof(buf));
+	printf("Try Reading INQUERY result...\n");
+	if (!libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, CMDIU_SIZE, &transferred, 2000)){
+		printf("	ERROR: Received data on bulk ep!\n");
+		/* Un-comment if running on a real UDC
+		ret = -1;
+		goto exec_test_tm_reset_nexus_done;*/
+	}
+
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_reset_nexus_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_reset_nexus_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_tm_reset_nexus_done;
+	}
+
+	ret = 0;
+exec_test_tm_reset_nexus_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+
+/**
+ * exec_test_tm_query_async_ev() - Test the QUERY ASYNC EVENT TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_async_ev(struct libusb_device *dev)
+{
+	struct tm_iu query_tm_iu;
+	struct response_iu *res_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int resp_info = 0;
+	int ret = -1;
+
+	/* Reset the nexus in order for UNIT_ATTENTION to be LUN_RESET */
+	if (exec_test_tm_reset_nexus(dev))
+		return -1;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto test_tm_query_async_ev_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto test_tm_query_async_ev_done;
+	}
+
+	reset_active_cmd_arr();
+	fill_tm_iu(&query_tm_iu, 0x82, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_tm_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto test_tm_query_async_ev_done;
+	}
+	add_cmd_to_arr(query_tm_iu.tm_function, query_tm_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_SUCCEEDED);
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto test_tm_query_async_ev_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto test_tm_query_async_ev_done;
+
+	res_iu = (struct response_iu *)buf;
+	resp_info = (res_iu->resp_info[0] << 16) |
+		    (res_iu->resp_info[1] << 8) |
+		    res_iu->resp_info[2];
+
+	if (resp_info != (SS_RESET_OCCURRED | (1 << 20)))
+		printf("	Reseived strange RESPONCE info = %06x",
+		       resp_info);
+
+	ret = 0;
+test_tm_query_async_ev_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_tm_query_task() - Test the QUERY TASK TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_task(struct libusb_device *dev)
+{
+	struct tm_iu query_task_iu;
+	struct cmd_iu inq_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *bulkin, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_query_task_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	bulkin = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_DATA_IN);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts || !bulkin) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_query_task_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue a command to be queried later on */
+	fill_cmd_iu(&inq_iu, 0x12, UASP_LUN_NUM, 0x24);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&inq_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_query_task_done;
+	}
+
+	printf("Issued INQUERY command...\n");
+	add_cmd_to_arr(inq_iu.cdb[0], inq_iu.tag, 1, STATUS_GOOD);
+
+	/* Now issue the QUERY TASK TM */
+	fill_tm_iu(&query_task_iu, 0x80, UASP_LUN_NUM);
+	query_task_iu.task_tag = inq_iu.tag;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_task_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_query_task_done;
+	}
+
+	printf("Issued QUERY TASK TM...\n");
+	add_cmd_to_arr(query_task_iu.tm_function, query_task_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_SUCCEEDED);
+
+	/* If we're working in HS mode we should receive a READ READY IU */
+	if (get_dev_speed() < USB_SPEED_SUPER) {
+		memset(buf, 0, sizeof(buf));
+		ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+					   UASP_SIZEOF_RW_READY_IU,
+					   &transferred, 2000);
+
+		if (ret) {
+			printf("libusb_bulk_transfer error = %d\n",ret);
+			goto exec_test_tm_query_task_done;
+		}
+		/* Verify the tag */
+		if (((struct rw_ready_iu*)buf)->tag != inq_iu.tag ||
+		    ((struct rw_ready_iu*)buf)->iu_id != IU_ID_READ_READY) {
+			printf("	ERROR: Received Incorrect IU!!!"
+			       " (iu_id = %d, tag = %d, expected_tag = %d)\n\n",
+			       ((struct rw_ready_iu*)buf)->iu_id,
+			       ((struct rw_ready_iu*)buf)->tag, inq_iu.tag);
+			goto exec_test_tm_query_task_done;
+		}
+	}
+
+	/* read status of TM */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_query_task_done;
+	} else {
+		ret = analize_received_status(buf);
+	}
+
+	printf("Reading INQUERY data...\n");
+	/* Complete the INQUERY command handling */
+	memset(buf, 0, sizeof(buf));
+	if (libusb_bulk_transfer(udev, bulkin->bEndpointAddress,
+				   buf, CMDIU_SIZE, &transferred, 2000)){
+		printf("	ERROR: INQUERY failed\n");
+		ret = -1;
+		goto exec_test_tm_query_task_done;
+	}
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_query_task_done;
+	} else {
+		ret = analize_received_status(buf);
+	}
+
+	if (ret)
+		goto exec_test_tm_query_task_done;
+
+	/*
+	 * Issue another QUERY TASK TM. This time the result should be
+	 * COMPLETE since the command completed
+	 */
+	fill_tm_iu(&query_task_iu, 0x80, UASP_LUN_NUM);
+	query_task_iu.task_tag = inq_iu.tag;
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_task_iu, TMIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_query_task_done;
+	}
+
+
+	printf("Issued seconf QUERY TASK TM...\n");
+	add_cmd_to_arr(query_task_iu.tm_function, query_task_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_query_task_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_query_task_done;
+
+	ret = 0;
+
+exec_test_tm_query_task_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+
+/**
+ * exec_test_tm_query_task_set() - Test the QUERY TASK SET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_task_set(struct libusb_device *dev)
+{
+	struct tm_iu query_task_set_iu;
+	struct cmd_iu unit_ready_iu1, unit_ready_iu2;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_query_task_set_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_query_task_set_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue 2 commands to be queried later on */
+	fill_cmd_iu(&unit_ready_iu1, 0x00, UASP_LUN_NUM, 0x00);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu1, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_query_task_set_done;
+	}
+
+	printf("Issued TEST UNIT TEADY1 command...\n");
+	add_cmd_to_arr(unit_ready_iu1.cdb[0], unit_ready_iu1.tag, 1,
+		       STATUS_GOOD);
+
+	fill_cmd_iu(&unit_ready_iu2, 0x00, UASP_LUN_NUM, 0x00);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu2, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_query_task_set_done;
+	}
+
+	printf("Issued TEST UNIT TEADY2 command...\n");
+	add_cmd_to_arr(unit_ready_iu2.cdb[0], unit_ready_iu2.tag, 1,
+		       STATUS_GOOD);
+
+	/* Now issue the QUERY TASK SET TM - both command are in processing */
+	fill_tm_iu(&query_task_set_iu, 0x81, UASP_LUN_NUM);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_task_set_iu,
+				   TMIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_query_task_set_done;
+	}
+
+	printf("Issued QUERY TASK SET TM "
+	       "(both commands are in processing)...\n");
+	add_cmd_to_arr(query_task_set_iu.tm_function, query_task_set_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_SUCCEEDED);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_query_task_set_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_query_task_set_done;
+
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_query_task_set_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_query_task_set_done;
+
+
+	memset(buf, 0, sizeof(buf));
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_query_task_set_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_query_task_set_done;
+
+	/*
+	 * Issue another QUERY TASK SET TM. This time the result should be
+	 * COMPLETE since both commands are completed
+	 */
+	fill_tm_iu(&query_task_set_iu, 0x81, UASP_LUN_NUM);
+
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&query_task_set_iu,
+				   TMIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_query_task_set_done;
+	}
+
+
+	printf("Issued seconf QUERY TASK SET TM...\n");
+	add_cmd_to_arr(query_task_set_iu.tm_function, query_task_set_iu.tag, 0,
+		       RESPONSE_TM_FUNCTION_COMPLETE);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_query_task_set_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_query_task_set_done;
+
+	ret = 0;
+
+exec_test_query_task_set_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * exec_test_tm_overlapped_tag() - Verifies correct behavior in
+ * case of TM overlapped tag attempted
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_overlapped_tag(struct libusb_device *dev)
+{
+	struct tm_iu tag_error_tm;
+	struct cmd_iu unit_ready_iu;
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *cmd_ep, *sts;
+	unsigned char buf[1024];
+	int transferred;
+	int ret = -1;
+
+	if (!dev)
+		return -1;
+
+	/* After a reset occured check the unit attention */
+	if (exec_send_request_sense(dev))
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto exec_test_tm_overlapped_tag_done;
+	}
+
+	cmd_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_CMD);
+	sts = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK, 0,
+					 PIPE_ID_STS);
+	if (!cmd_ep || !sts) {
+		printf("Didn't find endpoints!\n");
+		goto exec_test_tm_overlapped_tag_done;
+	}
+
+	reset_active_cmd_arr();
+
+	/* Issue command for the overlapped tag condition */
+	fill_cmd_iu(&unit_ready_iu, 0x00, UASP_LUN_NUM, 0x00);
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&unit_ready_iu, CMDIU_SIZE,
+				   &transferred,
+				   2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_overlapped_tag_done;
+	}
+
+	printf("Issued TEST UNIT TEADY command (tag = %d)...\n",
+	       unit_ready_iu.tag);
+
+	/* Now issue a TM with the same tag */
+	fill_tm_iu(&tag_error_tm, 0x81, UASP_LUN_NUM);
+	tag_error_tm.tag = unit_ready_iu.tag;
+	ret = libusb_bulk_transfer(udev, cmd_ep->bEndpointAddress,
+				   (unsigned char*)&tag_error_tm,
+				   TMIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("Transfer error %d \n",ret);
+		goto exec_test_tm_overlapped_tag_done;
+	}
+
+	printf("Issued a TM with the same tag (= %d)...\n",
+	       tag_error_tm.tag);
+	add_cmd_to_arr(tag_error_tm.tm_function, tag_error_tm.tag, 0,
+		       RESPONSE_OVERLAPPED_TAG_ATTEMPTED);
+
+	/* read status */
+	memset(buf, 0, sizeof(buf));
+	/*
+	 * We read data according to SENSE_U size since it's bigger
+	 * than RESPONSE IU
+	 */
+	ret = libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000);
+	if (ret) {
+		printf("libusb_bulk_transfer error = %d\n",ret);
+		goto exec_test_tm_overlapped_tag_done;
+	} else
+		ret = analize_received_status(buf);
+
+	if (ret)
+		goto exec_test_tm_overlapped_tag_done;
+
+	/* Verify that no additional data is about to be received */
+	if (!libusb_bulk_transfer(udev, sts->bEndpointAddress, buf,
+			   SENSEIU_SIZE, &transferred, 2000)) {
+		printf("	ERROR: REceived additional data on "
+		       "status ep!\n");
+		ret = -1;
+		goto exec_test_tm_overlapped_tag_done;
+	}
+
+	ret = 0;
+exec_test_tm_overlapped_tag_done:
+	reset_active_cmd_arr();
+	libusb_close(udev);
+	/* If test sucseded, verify that the device is functional */
+	if (!ret && exec_send_request_sense(dev)) {
+		printf("	ERROR: After overlapped tag the device is not"
+		       "functional!!!\n");
+		ret = -1;
+	}
+	return ret;
+}
+
diff --git a/tools/usb/unittests/usb/UASP_tests.h b/tools/usb/unittests/usb/UASP_tests.h
new file mode 100644
index 0000000..7b01782
--- /dev/null
+++ b/tools/usb/unittests/usb/UASP_tests.h
@@ -0,0 +1,434 @@
+/*
+ * UASP_tests.h - This file defines tests to be run on a UASP supporting device.
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _UASP_TESTS_H
+#define _UASP_TESTS_H
+
+extern "C" {
+#include <linux/usb/ch9.h>
+}
+
+#define IUGETDW(w) (((w)[0] << 24) | ((w)[1] << 16) | ((w)[2] << 8) | (w)[3])
+
+#define SCSI_SENSE_BUFFERSIZE 96
+
+#define UASP_LUN_NUM	0
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+
+/* IU identifier summary - see table 10 of the UAS Spec */
+enum iu_id {
+	IU_ID_COMMAND			= 0x01,
+	IU_ID_SENSE			= 0x03,
+	IU_ID_RESPONSE			= 0x04,
+	IU_ID_TASK_MANAGEMENT		= 0x05,
+	IU_ID_READ_READY		= 0x06,
+	IU_ID_WRITE_READY		= 0x07,
+};
+
+/* COMMAND IU - Section 6.2.2 from UAS Spec */
+struct cmd_iu {
+	u8 iu_id;	/* should be set to 01h*/
+	u8 reserved;
+	u16 tag;	/* section 4.2 of the UAS spec*/
+
+	u8 b;
+
+	u8 reserved5; /* Should be set to 0 */
+	u8 length; /*
+		     * length is represented only by bits 2-7.
+		     * bits 0-1 are reserved
+		     */
+	u8 reserved7; /*place holder. should be 0*/
+	u8 lun[8];
+	u8 cdb[16];
+	u8 *add_cdb;	/* Additional cdb bytes*/
+};
+#define CMDIU_SIZE 36
+
+
+/* TM FUNCTION IU  - see table 19 of the UAS Spec */
+struct tm_iu {
+	u8 iu_id;	/* Should be set to 05h */
+	u8 reserved1;
+	u16 tag;	/* section 4.2 of the UAS spec*/
+	u8 tm_function; /* valid values defined in tm_function_data */
+	u8 reserved5;
+	/* Reserved for all tm_functions but ABORT_TASK and QUERY_TASK */
+	u16 task_tag;
+	u8 lun[8];
+};
+#define TMIU_SIZE 16
+
+/* SENSE IU -	section	6.2.5 of the UAS spec */
+struct sense_iu {
+	u8 iu_id;	/* should be 0x03h*/
+	u8 reserved1;
+	u16 tag;	/* section 4.2 of the UAS spec*/
+	u16 status_qual;
+	u8 status;	/* Status code*/
+	u8 rsvd8[6];
+	u16 len;
+	u8 sense_data[SCSI_SENSE_BUFFERSIZE];
+};
+#define SENSEIU_SIZE (16 + SCSI_SENSE_BUFFERSIZE)
+
+/* STATUS values of SENSE IU as defined in SAM-4 */
+enum status_code_data {
+	STATUS_GOOD =			0x00,
+	STATUS_CHECK_CONDITION =	0x02,
+	STATUS_CONDITION_MET =		0x04,
+	STATUS_BUSY =			0x08,
+	STATUS_RESERVATION_CONFLICT =	0x18,
+	STATUS_TASK_SET_FULL =		0x28,
+	STATUS_ACA_ACTIVE =		0x30,
+	STATUS_TASK_ABORTED =		0x40,
+};
+
+/* RESPONSE IU - see table 17 of the UAS Spec */
+struct response_iu {
+	u8 iu_id;	/* Should be set to 04h*/
+	u8 reserved;
+	u16 tag;	/* section 4.2 of the UAS spec*/
+	u8 resp_info[3];
+	u8 status;	/* Response code*/
+};
+#define RESPONSEIU_SIZE 8
+
+/* Response code values of RESPONSE IU - see table 18 of the UAS Spec */
+enum response_code_data {
+	RESPONSE_TM_FUNCTION_COMPLETE		= 0x00,
+	RESPONSE_INVALID_IU			= 0x02,
+	RESPONSE_TM_FUNCTION_NOT_SUPPORTED	= 0x04,
+	RESPONSE_TM_FUNCTION_FAILED		= 0x05,
+	RESPONSE_TM_FUNCTION_SUCCEEDED		= 0x08,
+	RESPONSE_INCORRECT_LUN			= 0x09,
+	RESPONSE_OVERLAPPED_TAG_ATTEMPTED	= 0x0A,
+};
+
+/* READ/WRITE READY IU - see table 14/15 of the UAS Spec */
+struct rw_ready_iu {
+	u8 iu_id;
+	u8 reserved;
+	u16 tag;	/* section 4.2 of the UAS spec */
+};
+#define UASP_SIZEOF_RW_READY_IU 4
+
+/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
+#define SS_NO_SENSE				0
+#define SS_COMMUNICATION_FAILURE		0x040800
+#define SS_INVALID_COMMAND			0x052000
+#define SS_INVALID_FIELD_IN_CDB			0x052400
+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE	0x052100
+#define SS_LOGICAL_UNIT_NOT_SUPPORTED		0x052500
+#define SS_MEDIUM_NOT_PRESENT			0x023a00
+#define SS_MEDIUM_REMOVAL_PREVENTED		0x055302
+#define SS_NOT_READY_TO_READY_TRANSITION	0x062800
+#define SS_RESET_OCCURRED			0x062900
+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED	0x053900
+#define SS_UNRECOVERED_READ_ERROR		0x031100
+#define SS_WRITE_ERROR				0x030c02
+#define SS_WRITE_PROTECTED			0x072700
+#define SS_OVERLAPPED_COMMANDS_ATTEMPTED	0x0b4e00
+
+inline u16 get_next_ip_tag()
+{
+	static u8 my_ip_tag = 1;
+	return my_ip_tag++;
+}
+
+/**
+ * fill_cmd_iu() - Fills the command iu structure with given values
+ * @iu: pointer to the cmd_iu structure to fill
+ * @cdb_opcode: OpCode of the CDB to send
+ * @lun: LUN number
+ * @add_length: additional_length field of the CDB
+ *
+ */
+void fill_cmd_iu(struct cmd_iu *iu, u8 cdb_opcode, u8 lun, u8 add_length);
+
+/**
+ * exec_send_mode_sense10() - Test the MODE_SENSE10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the MODE_SENSE10 SCSI command to the device and verifies
+ * the correct reply from it.
+ * It consists of several tests (according to the fields of the
+ * MODE_SENSE10 CDB) :
+ * - First test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 0 (page control = return current values)
+ * - Second test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 01 (page control = return changable values)
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_mode_sense10(struct libusb_device *dev);
+
+/**
+ * exec_send_mode_sense() - Test the MODE_SENSE(6) SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the MODE_SENSE(6) SCSI command to the device and
+ * verifies the correct reply from it.
+ * It consists of several tests (according to the fields of the MODE_SENSE CDB):
+ * - First test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 0 (page control = return current values)
+ * - Second test case:
+ *	   page code = 0x08 (cashing)
+ *	   pc = 01 (page control = return changable values)
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_mode_sense(struct libusb_device *dev);
+
+/**
+ * exec_send_prevent_allow_removal() - Test the PREVENT_ALLOW_MEDIA_REMOVAL
+ * SCSI command
+ * @dev:pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_prevent_allow_removal(struct libusb_device *dev);
+
+/**
+ * exec_send_read_capacity() - Test the READ_CAPACITY SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the READ_CAPACITY SCSI command to the device and
+ * verifies the correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_read_capacity(struct libusb_device *dev);
+
+/**
+ * exec_send_inquiry() - Test the INQUIRY SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the INQUIRY SCSI command to the device and verifies the
+ * correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_inquiry(struct libusb_device *dev);
+
+/**
+ * exec_send_request_sense() - Test the REQUEST_SENCE command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * This function sends the REQUEST_SENCE SCSI command to the device and
+ * verifies the correct reply from it.
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_send_request_sense(struct libusb_device *dev);
+
+/**
+ * exec_test_unit_ready() - Test the TEST_UNIT_READY command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_unit_ready(struct libusb_device *dev);
+
+/**
+ * exec_test_read6() - Test the READ6 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read6(struct libusb_device *dev);
+
+/**
+ * exec_test_read10() - Test the READ10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read10(struct libusb_device *dev);
+
+/**
+ * exec_test_read12() - Test the READ12 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read12(struct libusb_device *dev);
+
+/**
+ * exec_test_write6() - Test the WRITE6 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write6(struct libusb_device *dev);
+
+/**
+ * exec_test_write10() - Test the WRITE10 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write10(struct libusb_device *dev);
+
+
+/**
+ * exec_test_write12() - Test the WRITE12 SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write12(struct libusb_device *dev);
+
+/**
+ * exec_test_write_huge() - Test the WRITE10 SCSI command with alot of data
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_write_huge(struct libusb_device *dev);
+
+/**
+ * exec_test_read_format_capacities() - Test the READ FORMAT CAPACITIES
+ * SCSI command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_read_format_capacities(struct libusb_device *dev);
+
+/**
+ * exec_test_start_stop() - Test the TEST_START_STOP_UNIT command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ *
+ * TODO: this test isn't full. It doesn't check that the unit was indeed
+ * started/ejected etc. It just verifies the completion status.
+ */
+int exec_test_start_stop(struct libusb_device *dev);
+
+/**
+ * exec_test_verify() - Test the VERIFY command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_verify(struct libusb_device *dev);
+
+/**
+ * exec_test_synchronize_cache() - Test the SYNCHRONIZE CACHE
+ * command
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_synchronize_cache(struct libusb_device *dev);
+
+/**
+ * exec_test_cmd_overlapped_tag() - Verifies correct behavior in
+ * case of CMD overlapped tag attempted
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_cmd_overlapped_tag(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_reset_lun() - Test the LOGICAL LUN RESET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_reset_lun(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_abort_task() - Test the ABORT_TASK TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_abort_task(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_abort_task_set() - Test the ABORT TASK SET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_abort_task_set(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_reset_nexus() - Test the RESET NEXUS TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_reset_nexus(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_query_async_ev() - Test the QUERY ASYNC EVENT TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_async_ev(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_abort_cmd() - Test the QUERY TASK TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_task(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_query_task_set() - Test the QUERY TASK SET TM
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_query_task_set(struct libusb_device *dev);
+
+/**
+ * exec_test_tm_overlapped_tag() - Verifies correct behavior in
+ * case of TM overlapped tag attempted
+ * @dev: pointer to the libusb device to run the test on
+ *
+ * Return 0 on success, -1 otherwise
+ */
+int exec_test_tm_overlapped_tag(struct libusb_device *dev);
+#endif /*_UASP_TESTS_H*/
diff --git a/tools/usb/unittests/usb/composite_tests.cc b/tools/usb/unittests/usb/composite_tests.cc
new file mode 100644
index 0000000..ea79f36
--- /dev/null
+++ b/tools/usb/unittests/usb/composite_tests.cc
@@ -0,0 +1,1646 @@
+/*
+ * composite_tests.c - USB composite device general tests
+ *
+ * Coding convention:
+ *	External functions begin with test_ sufix.
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include "libusb_utils.h"
+#include "hs_expected_desc.h"
+#include "ss_expected_desc.h"
+#include "usb_tests.h"
+#include "ut_config.h"
+
+
+/**
+ * dump_dev_descriptor() - prints the received device descriptor
+ * @dev_desc: device descriptor to print
+ */
+static void dump_dev_descriptor(struct libusb_device_descriptor dev_desc)
+{
+	printf("Device descriptor:\n"
+	       "bLength		%5u\n"
+	       "bDescriptorType	%5u\n"
+	       "bcdUSB		0x%02x\n"
+	       "bDeviceClass	%5u\n"
+	       "bDeviceSubClass	%5u\n"
+	       "bDeviceProtocol	%5u\n"
+	       "bMaxPacketSize0	%5u\n"
+	       "idVendor	%5u\n"
+	       "idProduct	0x%02x\n"
+	       "bcdDevice	0x%02x\n"
+	       "bNumConfigurations	%5u\n",
+	       dev_desc.bLength, dev_desc.bDescriptorType, dev_desc.bcdUSB,
+	       dev_desc.bDeviceClass, dev_desc.bDeviceSubClass,
+	       dev_desc.bDeviceProtocol, dev_desc.bMaxPacketSize0,
+	       dev_desc.idVendor, dev_desc.idProduct, dev_desc.bcdDevice,
+	       dev_desc.bNumConfigurations);
+}
+
+/**
+ * dump_ep_desc() - prints the endpoint descriptor
+ * @ep_desc: endpoint descriptor to print
+ */
+static void dump_ep_desc(struct libusb_endpoint_descriptor *ep_desc)
+{
+	printf("Endpoint descriptor:\n"
+	       "bLength		%5u\n"
+	       "bDescriptorType	%5u\n"
+	       "bEndpointAddress %5u (%s endpoint)\n",
+	       ep_desc->bLength, ep_desc->bDescriptorType,
+	       ep_desc->bEndpointAddress,
+	       ((ep_desc->bEndpointAddress & LIBUSB_ENDPOINT_IN) ?
+							"IN" : "OUT"));
+
+	printf("bmAttributes	%5u	",ep_desc->bmAttributes);
+
+	switch (usb_endpoint_type(
+		(const struct usb_endpoint_descriptor *)ep_desc)){
+		case USB_ENDPOINT_XFER_CONTROL:
+			printf("Transfer Type	CONTROL\n");
+			break;
+		case USB_ENDPOINT_XFER_ISOC:
+			printf("Transfer Type	ISOC\n");
+			break;
+		case USB_ENDPOINT_XFER_BULK:
+			printf("Transfer Type	BULK\n");
+			break;
+		case USB_ENDPOINT_XFER_INT:
+			printf("Transfer Type	INTR\n");
+			break;
+		default:
+			printf("Transfer Type	Unknown\n");
+			break;
+	}
+       printf("wMaxPacketSize	0x%02x\n"
+	      "bInterval	%5u\n",
+	      ep_desc->wMaxPacketSize, ep_desc->bInterval);
+}
+
+
+/**
+ * check_ep_descriptor() - Verify the recived endpoint descriptor
+ * @ep_desc: the endpoint descriptor to check
+ * @ref_ep_desc: reference endpoint descriptor
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * This function checks the validity of a given endpoint descriptor of the
+ * connected device according to the supplied reference descriptor
+ */
+static int check_ep_descriptor(struct libusb_endpoint_descriptor *ep_desc,
+			       struct libusb_endpoint_descriptor *ref_ep_desc)
+{
+	if ((ep_desc->bmAttributes != ref_ep_desc->bmAttributes) ||
+	    (ep_desc->wMaxPacketSize != ref_ep_desc->wMaxPacketSize) ||
+	    (ep_desc->bInterval != ref_ep_desc->bInterval) ||
+	    ((ep_desc->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) !=
+	     (ref_ep_desc->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)))
+		return -1;
+	return 0;
+}
+
+/**
+ * check_dev_desc() - Verify the recived device descriptor
+ * @dev: libusb device to check
+ * @ref_dev_desc: reference device descriptor to check according to
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * This function checks the validity of the  device descriptor of the connected
+ * device according to the provided reference device descriptor
+ */
+static int check_dev_desc(libusb_device *dev,
+			  struct libusb_device_descriptor ref_dev_desc)
+{
+	struct libusb_device_descriptor dev_desc;
+	if (libusb_get_device_descriptor(dev,&dev_desc))
+	{
+		printf("Couldn't get device descriptor\n");
+		return -1;
+	}
+
+	if (dev_desc.bcdUSB != ref_dev_desc.bcdUSB ||
+	    dev_desc.bMaxPacketSize0 != ref_dev_desc.bMaxPacketSize0)
+	{
+		printf("Incompatible Device descriptor! Expected:\n");
+		dump_dev_descriptor(ref_dev_desc);
+		printf("\nReceived:\n");
+		dump_dev_descriptor(dev_desc);
+		return -1 ;
+	}
+	if (ut_debug)
+		dump_dev_descriptor(dev_desc);
+	return 0;
+}
+
+/**
+ * soursesink_test_setup() - Send a control request to setup/begin a spesific
+ * test (to be handled by f_soursesink).
+ * @udev: libusb device handle for the opened device
+ * @dev: libusb device
+ * @reques: the request code to send . Handled requests are:
+ *	 0x5e - set up the bulk buffer size
+ * @wValue: in case of request = 0x5e: size of the bulk buffer
+ *
+ * Returns: the number of bytes actually transferred on success,
+ *	LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ *	LIBUSB_ERROR_PIPE if the control request was not supported by the device
+ *	LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ *	another LIBUSB_ERROR code on other failures
+ *
+ * NOTE: the requests sent by this function are propriatary and are handled
+ * by g_zero (in sourcesink configuration)
+ */
+int soursesink_test_setup(struct libusb_device_handle *udev,
+			  libusb_device *dev,
+			  uint8_t request,
+			  uint16_t wValue)
+{
+	if (!udev || !dev)
+		return LIBUSB_ERROR_IO;
+
+	return libusb_control_transfer(udev, LIBUSB_REQUEST_TYPE_VENDOR |
+				       LIBUSB_RECIPIENT_INTERFACE,
+				       request, wValue, 0, NULL, 0,
+				       BULK_TRANSFERR_TIMEOUT);
+}
+
+/* HS Device tests */
+
+/**
+ * check_hs_intr_desc() - Verify the recived interface descriptor
+ * @dev: libusb device to check descriptors for
+ *
+ * Returns 0 on success -1 for failure
+ *
+ * This function checks the validity of  HS Interface descriptors (including
+ * endpoint descriptors) of the connected device according to the expected
+ * descriptors in hs_expected_desc.h
+ */
+static int check_hs_intr_desc(libusb_device *dev)
+{
+	struct libusb_config_descriptor *config;
+	struct libusb_interface_descriptor *interface_desc;
+	int i,j;
+
+	config = (struct libusb_config_descriptor*)
+			malloc(sizeof(struct libusb_config_descriptor));
+	if (!config) {
+		printf("Error in allocating memory\n");
+		return -1;
+	}
+
+	if (libusb_get_active_config_descriptor(dev, &config))
+		goto check_hs_intr_err;
+
+	for (i = 0; i < config->interface->num_altsetting; i++) {
+		interface_desc = (struct libusb_interface_descriptor *)
+					&(config->interface->altsetting[i]);
+		/* Go over the interface endpoints*/
+		for (j = 0; j < interface_desc->bNumEndpoints; j++) {
+			struct libusb_endpoint_descriptor *ep_desc =
+				(struct libusb_endpoint_descriptor *)
+				&(interface_desc->endpoint[j]);
+			struct libusb_endpoint_descriptor *ref_ep_desc;
+			switch (ep_desc->bmAttributes &
+				USB_ENDPOINT_XFERTYPE_MASK){
+			case USB_ENDPOINT_XFER_CONTROL:
+				/* TODO */
+				break;
+			case USB_ENDPOINT_XFER_ISOC:
+				/* TODO */
+				break;
+			case USB_ENDPOINT_XFER_BULK:
+				if (ep_desc->bEndpointAddress &
+				    LIBUSB_ENDPOINT_IN)
+					ref_ep_desc = &hs_bulk_in_ep_desc;
+				else
+					ref_ep_desc = &hs_bulk_out_ep_desc;
+				break;
+			case USB_ENDPOINT_XFER_INT:
+				ref_ep_desc = &hs_intr_ep_desc;
+				break;
+			default:
+				printf("Unknown endpoint type!\n");
+				goto check_hs_intr_err;
+			}
+
+			if (!ref_ep_desc)
+				goto check_hs_intr_err;
+
+			if (check_ep_descriptor(ep_desc, ref_ep_desc)){
+				printf("Incompatible Endpoint descriptor! "
+				       "Expected:\n");
+				dump_ep_desc(ref_ep_desc);
+				printf("\nReceived:\n");
+				dump_ep_desc(ep_desc);
+				goto check_hs_intr_err;
+			}
+			if (ut_debug)
+				dump_ep_desc(ep_desc);
+		}
+	}
+
+	free(config);
+	return 0;
+check_hs_intr_err:
+	free(config);
+	return -1;
+}
+
+/**
+ * test_hs_descriptors() - checks the validity of HS device descriptors
+ * according to the expected descriptors in hs_expected_desc.h
+ * @dev: libusb device to check
+ *
+ * Returns 0 for sucsess -1 for failure
+ */
+int test_hs_descriptors(libusb_device *dev)
+{
+	struct libusb_device_handle *udev;
+	int ret;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto test_hs_desc_err;
+	}
+
+	if (check_dev_desc(dev, hs_device_descriptor))
+	    goto test_hs_desc_err;
+
+	if (check_hs_intr_desc(dev))
+	    goto test_hs_desc_err;
+
+	ret = 0;
+	goto test_hs_desc_done;
+
+test_hs_desc_err:
+	ret = -1;
+test_hs_desc_done:
+	libusb_close(udev);
+	return ret;
+}
+
+
+/* SS device tests */
+
+/**
+ * dump_usb_ext_cap_desc() - prints the USB 2.0 extension device capability
+ * descriptor
+ * @usb_ext_cap: the descriptor to print
+ */
+static void dump_usb_ext_cap_desc(
+	struct libusb_usb_ext_cap_descriptor *usb_ext_cap)
+{
+	if (!usb_ext_cap)
+		return;
+	printf("  USB 2.0 extension device capability descriptor:\n"
+	       "    bLength			%5u\n"
+	       "    bDescriptorType		%5u\n"
+	       "    bDevCapabilityType		%5u\n"
+	       "    bmAttributes		 0x%02x, %s\n"
+	       ,
+	       usb_ext_cap->bLength,
+	       usb_ext_cap->bDescriptorType,
+	       usb_ext_cap->bDevCapabilityType,
+	       usb_ext_cap->bmAttributes,
+	       (usb_ext_cap->bmAttributes & 0x1) ?
+	       "Supports LPM" : "Doesn't support LPM");
+}
+
+/**
+ * dump_ss_usb_cap_desc() - prints the SuperSpeed USB capability descriptor
+ * @ss_usb_cap: the descriptor to print
+ */
+static void dump_ss_usb_cap_desc(
+	struct libusb_ss_usb_cap_descriptor *ss_usb_cap)
+{
+	static const char *speed[] = {
+		"None",
+		"Low Speed",
+		"Full Speed",
+		"Low & Full Speed",
+		"High Speed",
+		"Low & High Speed",
+		"Full & High Speed",
+		"Low, Full & High Speed",
+		"5Gbps Speed",
+		"Low & 5Gbps Speed",
+		"Full & 5Gbps Speed",
+		"Low, Full & 5Gbps Speed",
+		"High & 5Gbps Speed",
+		"Low, High & 5Gbps Speed",
+		"Full, High & 5Gbps Speed",
+		"Low, Full, High & 5Gbps Speed"
+	};
+
+	if (!ss_usb_cap)
+		return;
+	printf("  SuperSpeed USB capability descriptor:\n"
+	      "    bLength			%5u\n"
+	      "    bDescriptorType		%5u\n"
+	      "    bDevCapabilityType		%5u\n"
+	      "    bmAttributes		 0x%02x, %s\n"
+	      "    wSpeedSupported		 0x%02x,\n %s%s\n"
+	      "    bFunctionalitySupport	 0x%02x,\n %s%s\n"
+	      "    bU1devExitLat		%5u\n"
+	      "    bU2devExitLat		%5u\n",
+	      ss_usb_cap->bLength,
+	      ss_usb_cap->bDescriptorType,
+	      ss_usb_cap->bDevCapabilityType,
+	      ss_usb_cap->bmAttributes,
+	      (ss_usb_cap->bmAttributes & 0x2) ?
+	       "Supports LTM" : "Doesn't support LTM",
+	      ss_usb_cap->wSpeedSupported,
+	      "	Supports ",
+	      speed[ss_usb_cap->wSpeedSupported & 0xF],
+	      ss_usb_cap->bFunctionalitySupport,
+	      "	Min speed at which all the functionality is available is ",
+	      speed[ss_usb_cap->bFunctionalitySupport & 0xF],
+	      ss_usb_cap->bU1devExitLat,
+	      ss_usb_cap->bU2DevExitLat);
+}
+
+/**
+ * dump_bos_desc()- prints the BOS descriptor.
+ * @bos: bos descriptor to print
+ */
+static void dump_bos_desc(struct libusb_bos_descriptor bos)
+{
+	printf("BOS descriptor:\n"
+	       "  bLength             	%5u\n"
+	       "  bDescriptorType     	%5u\n"
+	       "  wTotalLength        	%5u\n"
+	       "  bNumDeviceCaps      	%5u\n",
+	       bos.bLength, bos.bDescriptorType,
+	       bos.wTotalLength, bos.bNumDeviceCaps);
+}
+
+/**
+ * dump_ep_comp_desc() - prints the SS Endpoint Companion Descriptor
+ * @ep_comp_desc: the descriptor to print
+ */
+static void dump_ep_comp_desc(struct libusb_ss_ep_comp_descriptor *ep_comp_desc)
+{
+	printf("Endpoint Companion Descriptor:\n"
+	       "  bLength	      	%5u\n"
+	       "  bDescriptorType	%5u\n"
+	       "  bMaxBurst		%5u\n"
+	       "  bmAttributes		%5u\n"
+	       "  wBytesPerInterval	%5u\n",
+	       ep_comp_desc->bLength, ep_comp_desc->bDescriptorType,
+	       ep_comp_desc->bMaxBurst, ep_comp_desc->bmAttributes,
+	       ep_comp_desc->wBytesPerInterval);
+}
+
+/**
+ * check_ep_comp_descriptor() - checks the validity of endpoint companion
+ * descriptor
+ * @ep_comp_desc: the descriptor to check
+ * @ref_ep_comp_desc: reference descriptor to check according to
+ *
+ * Returns 0 for sucsess -1 for failure
+ *
+ * This function verifies the  validity of the SS endpoint companion descriptor
+ * according to the provided reference endpoint companion descriptor
+ */
+static int check_ep_comp_descriptor(
+	struct libusb_ss_ep_comp_descriptor *ep_comp_desc,
+	struct libusb_ss_ep_comp_descriptor *ref_ep_comp_desc)
+{
+	if ((ep_comp_desc->bLength != ref_ep_comp_desc->bLength) ||
+	    (ep_comp_desc->bDescriptorType !=
+		ref_ep_comp_desc->bDescriptorType) ||
+	    (ep_comp_desc->bMaxBurst != ref_ep_comp_desc->bMaxBurst) ||
+	    (ep_comp_desc->bmAttributes != ref_ep_comp_desc->bmAttributes) ||
+	    (ep_comp_desc->wBytesPerInterval !=
+		ref_ep_comp_desc->wBytesPerInterval))
+		return -1;
+	return 0;
+}
+
+/**
+ * check_ss_intr_desc() - checks the validity of the interface
+ * @descriptor dev: libusb device to check descriptors for
+ * @num_expected_strms_in_ep: the number of expected streams for IN EP's
+ *	ep_comp descriptor
+ * @num_expected_strms_out_ep: the number of expected streams for OUT EP's
+ *	ep_comp descriptor
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * This function checks the validity of SS Interface descriptors (including
+ * endpoint descriptors) of the connected device according to the expected
+ * descriptors in ss_expected_desc.h
+ */
+static int check_ss_intr_desc(libusb_device *dev, int num_expected_strms_in_ep,
+			      int num_expected_strms_out_ep)
+{
+	struct libusb_config_descriptor *config;
+	int i,j,k;
+
+	if (libusb_get_active_config_descriptor(dev, &config))
+		goto check_ss_intr_err;
+
+	/* Go over the configuration interfaces */
+	for (k = 0; k < config->bNumInterfaces; k++) {
+		struct libusb_interface interface = config->interface[k];
+		/* Go over interface alternate settings */
+		for (i = 0; i < interface.num_altsetting; i++) {
+			struct libusb_interface_descriptor *interface_desc =
+				(struct libusb_interface_descriptor *)
+						&(interface.altsetting[i]);
+			/* Go over the interface endpoints */
+			for (j = 0; j < interface_desc->bNumEndpoints; j++) {
+				struct libusb_endpoint_descriptor *ep_desc =
+					(struct libusb_endpoint_descriptor *)
+					&(interface_desc->endpoint[j]);
+				struct libusb_endpoint_descriptor *ref_ep_desc;
+				struct libusb_ss_ep_comp_descriptor
+							ref_ep_comp_desc_copy;
+				struct libusb_ss_ep_comp_descriptor
+							*ref_ep_comp_desc;
+				switch (ep_desc->bmAttributes &
+					USB_ENDPOINT_XFERTYPE_MASK){
+				case USB_ENDPOINT_XFER_CONTROL:
+					/* TODO */
+					break;
+				case USB_ENDPOINT_XFER_ISOC:
+					/* TODO */
+					break;
+				case USB_ENDPOINT_XFER_BULK:
+					if (ep_desc->bEndpointAddress &
+					    LIBUSB_ENDPOINT_IN){
+						ref_ep_desc =
+							&ss_bulk_in_ep_desc;
+						memcpy(&ref_ep_comp_desc_copy,
+				&ss_bulk_in_ep_comp_desc,
+				sizeof(struct libusb_ss_ep_comp_descriptor));
+					ref_ep_comp_desc_copy.bmAttributes =
+						num_expected_strms_in_ep;
+						ref_ep_comp_desc =
+							&ref_ep_comp_desc_copy;
+					}else {
+						ref_ep_desc =
+							&ss_bulk_out_ep_desc;
+						memcpy(&ref_ep_comp_desc_copy,
+				&ss_bulk_out_ep_comp_desc,
+				sizeof(struct libusb_ss_ep_comp_descriptor));
+					ref_ep_comp_desc_copy.bmAttributes =
+						num_expected_strms_out_ep;
+						ref_ep_comp_desc =
+							&ref_ep_comp_desc_copy;
+					}
+					break;
+				case USB_ENDPOINT_XFER_INT:
+					ref_ep_desc = &ss_intr_ep_desc;
+					ref_ep_comp_desc =
+						&ss_intr_ep_comp_desc;
+					break;
+				default:
+					printf("Unknown endpoint type!\n");
+					goto check_ss_intr_err;
+				}
+
+				if (!ref_ep_desc)
+					goto check_ss_intr_err;
+
+				if (check_ep_descriptor(ep_desc, ref_ep_desc)){
+					printf("Incompatible Endpoint "
+					       "descriptor! Expected:\n");
+					dump_ep_desc(ref_ep_desc);
+					printf("\nReceived:\n");
+					dump_ep_desc(ep_desc);
+					goto check_ss_intr_err;
+				}
+
+				/* Check endpoint companion descriptor */
+				if (!ep_desc->ep_comp) {
+					printf("Endpoint companion descriptor "
+					       "is missing!\n");
+					goto check_ss_intr_err;
+				}
+				if (check_ep_comp_descriptor(ep_desc->ep_comp,
+							ref_ep_comp_desc)) {
+					printf("Incompatible Endpoint "
+					       "companion descriptor! "
+					       "Expected:\n");
+					dump_ep_comp_desc(ref_ep_comp_desc);
+					printf("\nReceived:\n");
+					dump_ep_comp_desc(ep_desc->ep_comp);
+					goto check_ss_intr_err;
+				}
+
+				if (ut_debug) {
+					dump_ep_desc(ep_desc);
+					dump_ep_comp_desc(ep_desc->ep_comp);
+				}
+			}
+		}
+	}
+
+	return 0;
+check_ss_intr_err:
+	return -1;
+}
+
+/**
+ * check_bos_desc() - checks the validity of the BOS descriptor
+ * @dev: the libusb device to check the descriptors for
+ *
+ * Returns 0 for sucsess -1 for failure
+ *
+ * This function checks the SS USB device BOS descriptor (and its sub
+ * descriptors) according to the expected descriptors in ss_expected_desc.h
+ */
+static int check_bos_desc(libusb_device *dev)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_bos_descriptor bos;
+	int ret;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	memset (&bos, 0, sizeof(bos));
+	ret = libusb_utils_get_bos_desc(dev, udev, &bos);
+	if (ret < 0) {
+		perror("can't get BOS descriptor");
+		goto test_bos_error;
+	}
+
+	if (ut_debug){
+		dump_bos_desc(bos);
+		dump_usb_ext_cap_desc(bos.usb_ext_cap);
+		dump_ss_usb_cap_desc(bos.ss_usb_cap);
+	}
+
+	/* BOS descriptor */
+	if ((bos.bLength != ss_bos_desc.bLength) ||
+	    (bos.bDescriptorType != ss_bos_desc.bDescriptorType) ||
+	    (bos.wTotalLength != ss_bos_desc.wTotalLength) ||
+	    (bos.bNumDeviceCaps != ss_bos_desc.bNumDeviceCaps)){
+		printf("Incompatible BOS descriptor! Expected:\n");
+		dump_bos_desc(ss_bos_desc);
+		printf("\nReceived:\n");
+		dump_bos_desc(bos);
+		goto test_bos_error;
+	}
+
+	/* USB 2.0 extension device capability descriptor */
+	if (bos.usb_ext_cap) {
+		struct libusb_usb_ext_cap_descriptor *usb_ext_cap;
+		struct libusb_usb_ext_cap_descriptor *exp_usb_ext_cap;
+
+		usb_ext_cap = bos.usb_ext_cap;
+		exp_usb_ext_cap = &ss_usb20_ext_desc;
+		if ((usb_ext_cap->bLength != exp_usb_ext_cap->bLength) ||
+		    (usb_ext_cap->bDescriptorType !=
+			exp_usb_ext_cap->bDescriptorType) ||
+		    (usb_ext_cap->bDevCapabilityType !=
+			exp_usb_ext_cap->bDevCapabilityType) ||
+		    (usb_ext_cap->bmAttributes !=
+			exp_usb_ext_cap->bmAttributes) ||
+		    (usb_ext_cap->bmAttributes !=
+			exp_usb_ext_cap->bmAttributes)){
+			printf("Incompatible USB 2.0 extension device "
+			       "capability descriptor! Expected:\n");
+			dump_usb_ext_cap_desc(exp_usb_ext_cap);
+			printf("\nReceived:\n");
+			dump_usb_ext_cap_desc(usb_ext_cap);
+			goto test_bos_error;
+		}
+	} else
+		goto test_bos_error;
+
+	/* SuperSpeed USB capability descriptor */
+	if (bos.ss_usb_cap) {
+		struct libusb_ss_usb_cap_descriptor *ss_usb_cap;
+		struct libusb_ss_usb_cap_descriptor *exp_ss_usb_cap;
+
+		ss_usb_cap = bos.ss_usb_cap;
+		exp_ss_usb_cap = &ss_usb_capability_desc;
+		if((ss_usb_cap->bLength != exp_ss_usb_cap->bLength) ||
+		   (ss_usb_cap->bDescriptorType !=
+			exp_ss_usb_cap->bDescriptorType) ||
+		   (ss_usb_cap->bDevCapabilityType !=
+			exp_ss_usb_cap->bDevCapabilityType) ||
+		   (ss_usb_cap->bmAttributes != exp_ss_usb_cap->bmAttributes) ||
+		   (ss_usb_cap->wSpeedSupported !=
+			exp_ss_usb_cap->wSpeedSupported) ||
+		   (ss_usb_cap->bFunctionalitySupport !=
+			exp_ss_usb_cap->bFunctionalitySupport) ||
+		   (ss_usb_cap->bU1devExitLat !=
+			exp_ss_usb_cap->bU1devExitLat) ||
+		   (ss_usb_cap->bU2DevExitLat !=
+			exp_ss_usb_cap->bU2DevExitLat)){
+			printf("Incompatible SuperSpeed USB capability "
+			       "descriptor! Expected:\n");
+			dump_ss_usb_cap_desc(exp_ss_usb_cap);
+			printf("\nReceived\n");
+			dump_ss_usb_cap_desc(ss_usb_cap);
+			goto test_bos_error;
+		}
+	}else
+		goto test_bos_error;
+
+	ret = 0;
+	goto test_bos_done;
+
+test_bos_error:
+	ret = -1;
+test_bos_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * test_ss_descriptors() - checks the validity of SS device descriptors
+ * according to the expected descriptors in ss_expected_desc.h
+ * @dev: libusb device to check
+ * @num_expected_strms_in_ep: the number of expected streams for IN EP's
+ *	ep_comp descriptor
+ * @num_expected_strms_out_ep: the number of expected streams for OUT EP's
+ *	ep_comp descriptor
+ *
+ * Returns 0 for sucsess -1 for failure
+ */
+int test_ss_descriptors(libusb_device *dev, int num_expected_strms_in_ep,
+			int num_expected_strms_out_ep)
+{
+	struct libusb_device_handle *udev;
+	int ret;
+
+	if (!dev)
+		return -1;
+
+	ret = libusb_open(dev, &udev);
+	if (ret) {
+		printf("Couldn't open device (%d) \n", ret);
+		return -1;
+	}
+
+	if (check_dev_desc(dev, ss_device_descriptor))
+		goto test_ss_desc_err;
+
+	if (check_ss_intr_desc(dev, num_expected_strms_in_ep,
+			       num_expected_strms_out_ep))
+		goto test_ss_desc_err;
+
+	if (check_bos_desc(dev))
+		goto test_ss_desc_err;
+
+	ret = 0;
+	goto test_ss_desc_done;
+
+test_ss_desc_err:
+	ret = -1;
+test_ss_desc_done:
+	libusb_close(udev);
+	return ret;
+}
+
+/**
+ * test_connect_disconnect() - initiates a connect/disconnect sequence by
+ * the device.
+ * @dev: libusb device
+ * @dev_speed: the original speed of the connected device (before the test)
+ * @num_expected_strms_in_ep: the number of expected streams for IN EP's
+ *	ep_comp descriptor (the descriptors are used the verify the connection)
+ * @num_expected_strms_out_ep: the number of expected streams for OUT EP's
+ *	ep_comp descriptor (the descriptors are used the verify the connection)
+ *
+ * Returns 0 for sucsess -1 for failure
+ *
+ * After the device is connected it's descriptors are verified according to the
+ * speed. The connection speed should be maintained!
+ */
+int test_connect_disconnect(libusb_device *dev,
+			    enum usb_device_speed dev_speed,
+			    int num_expected_strms_in_ep,
+			    int num_expected_strms_out_ep)
+{
+	struct libusb_device_handle *udev;
+	libusb_device *new_dev;
+	int ret = -1;
+	uint16_t wValue;
+
+	struct libusb_device_descriptor dev_desc;
+	if (libusb_get_device_descriptor(dev, &dev_desc))
+	{
+		printf("Couldn't get device descriptor\n");
+		return -1;
+	}
+
+	if (ut_debug)
+		printf("In test_connect_disconnect\n");
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	ret = libusb_control_transfer(udev, LIBUSB_REQUEST_TYPE_VENDOR |
+				       LIBUSB_RECIPIENT_DEVICE,
+				       CONN_DISCONN_TEST, 0, 0, NULL, 0,
+				       BULK_TRANSFERR_TIMEOUT);
+
+	/*
+	 * We ignore the LIBUSB_ERROR_NO_DEVICE because the device disconnects
+	 * before the response is handled by the host
+	 */
+	if ((ret < 0) && (ret != LIBUSB_ERROR_NO_DEVICE)){
+		printf("Couldn't send setup test control packet = %d\n", ret);
+		goto test_connect_disconnect_err;
+	}
+
+	libusb_close(udev);
+
+	/* Wait for test completion and verify dev. connection */
+	(void)sleep(2);
+
+	/*
+	 * After the reenumeration we need to update the libusb device handle.
+	 * The devnum isn't valid anymore so we need to update the productid
+	 * and the vendorid according to device descriptor
+	 */
+	libusb_utils_exit();
+	libusb_utils_init();
+	new_dev = get_libusb_dev();
+	if (!new_dev) {
+		return -1;
+	}
+
+	/* Verify successfull conection by checking descriptors */
+	switch (dev_speed) {
+	case USB_SPEED_SUPER:
+		printf("num_expected_strms_in_ep = %d\n",
+		       num_expected_strms_in_ep);
+		printf("num_expected_strms_out_ep = %d\n",
+		       num_expected_strms_out_ep);
+		ret = test_ss_descriptors(new_dev, num_expected_strms_in_ep,
+			       num_expected_strms_out_ep);
+		break;
+	default:
+		ret = test_hs_descriptors(new_dev);
+	}
+
+	goto test_connect_disconnect_done;
+
+test_connect_disconnect_err:
+	libusb_close(udev);
+test_connect_disconnect_done:
+	return ret;
+}
+
+/**
+ * test_get_status_functionality() - verify the GET_STATUS request handling
+ * @dev: Libusb device hook
+ * @in_udev: External hook to the libusb device
+ * @bmRequestType: The request's bmRequestType
+ * @expected_res: The expected post-action status
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This is a general function that sends a GET_STATUS request to {HS / SS}
+ * {device / EP / interface} with test specific parameters
+ */
+static int test_get_status_functionality(
+				libusb_device               *dev,
+				struct libusb_device_handle *in_udev,
+				uint8_t                      bmRequestType,
+				uint16_t                     wIndex,
+				unsigned char               *expected_res)
+{
+	struct libusb_device_handle *udev = NULL;
+	unsigned char data[2] = {0};
+	int transfer_res = 0, ret_val = 0;
+	bool init_libusb = 0;
+
+	if (!in_udev) {
+		if (!dev) {
+			printf("libusb device  == NULL..\n");
+			return -1;
+		}
+
+		if (libusb_open(dev, &udev)) {
+			printf("Couldn't open device\n");
+			return -1;
+		}
+		init_libusb = 1;
+	}
+	else {
+		udev = in_udev;
+	}
+
+	transfer_res = libusb_control_transfer(udev, /* libusb_device_handle */
+				bmRequestType,		/* bmRequestType */
+				LIBUSB_REQUEST_GET_STATUS, /* bRequest */
+				0,			   /* wValue */
+				wIndex,			   /* wIndex */
+				data,			   /* returned data */
+				2,			   /* wLength */
+				CTL_REQ_TRANSFERR_TIMEOUT);/* timeout */
+
+	if ((transfer_res == LIBUSB_ERROR_NO_DEVICE) ||
+		(transfer_res == LIBUSB_ERROR_TIMEOUT) ||
+		(transfer_res == LIBUSB_ERROR_IO) ||
+		(transfer_res == LIBUSB_ERROR_PIPE))
+	{
+		printf("LIBUSB error (%d)\n", transfer_res);
+		ret_val = -1;
+	}
+
+	if ( (data[0] != expected_res[0]) || (data[1] != expected_res[1]) ){
+		printf("data (0x%x, 0x%x) != expected_res (0x%x, 0x%x)..\n",
+				data[0], data[1], expected_res[0],
+				expected_res[1]);
+		ret_val = -1;
+	}
+
+	if (init_libusb)
+		libusb_close(udev);
+
+	return ret_val;
+}
+
+/**
+ * test_ss_get_status_default_device() - verify the GET_STATUS(dev) request
+ * handling
+ * @dev: Libusb device hook
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a GET_STATUS request to the ss device in default state
+ * (when LTM, U1 & U2 are not enabled) and checks that the response is  as
+ * expected (section 9.4.5 in the USB3 standard)
+ */
+int test_ss_get_status_default_device(libusb_device *dev)
+{
+	return test_get_status_functionality(dev, NULL,
+			(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_DEVICE),
+			0x00, /* For GetStatus(DEVICE) request wIndex=0 */
+			ss_get_status_default_device_expected);
+}
+
+/**
+ * test_ss_get_status_default_interface() - verify the GET_STATUS(intr) request
+ * handling
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a GET_STATUS request to the ss interface in default state
+ * (section 9.4.5 in the USB3 standard)
+ */
+int test_ss_get_status_default_interface(libusb_device *dev,
+					 int interface_id)
+{
+	return test_get_status_functionality(dev, NULL,
+			(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			interface_id, ss_get_status_default_interface_expected);
+}
+
+/**
+ * test_ss_get_status_default_ep() - verify the GET_STATUS(ep) request handlind
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a  GET_STATUS request to the ss endpoint in default state
+ * (section 9.4.5 in the USB3 standard). It's run for the BULK IN endpoint and
+ * assumes the device has such.
+ */
+int test_ss_get_status_default_ep(libusb_device *dev,
+				  int interface_id)
+{
+	struct libusb_endpoint_descriptor *in_ep;
+	struct libusb_device_handle *udev = NULL;
+	int rc = -1;
+
+	if (!dev) {
+		printf("libusb device  == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK,
+					 interface_id, PIPE_ID_UNDEF);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		goto ss_get_status_default_ep_done;
+	}
+
+	rc = test_get_status_functionality(dev, udev,
+			( LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			  LIBUSB_RECIPIENT_ENDPOINT),
+			(uint16_t)in_ep->bEndpointAddress,
+			ss_get_status_default_ep_expected);
+
+ss_get_status_default_ep_done:
+	libusb_close(udev);
+	return rc;
+}
+
+/**
+ * test_hs_get_status_default_device() - verify the GET_STATUS(dev) request
+ * handling
+ * @dev: Libusb device hook
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a  GET_STATUS request to the hs device in default state
+ * and checks that the response is as expected (section 9.4.5 in the USB2
+ * standard)
+ */
+int test_hs_get_status_default_device(libusb_device *dev)
+{
+	return test_get_status_functionality(dev, NULL,
+			( LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			  LIBUSB_RECIPIENT_DEVICE),
+			0x00, /* For GetStatus(DEVICE) request wIndex=0 */
+			hs_get_status_default_device_expected);
+}
+
+/**
+ * test_hs_get_status_default_interface() - verify the GET_STATUS(intr) request
+ * handling
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a GET_STATUS request to the hs interface in default state
+ * (section 9.4.5 in the USB2 standard)
+ */
+int test_hs_get_status_default_interface(libusb_device *dev,
+					 int interface_id)
+{
+	return test_get_status_functionality(dev, NULL,
+			(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			interface_id, hs_get_status_default_interface_expected);
+}
+
+/**
+ * test_hs_get_status_default_ep() - verify the GET_STATUS(ep) request handlind
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a GET_STATUS request to the hs endpoint in default state
+ * (section 9.4.5 in the USB2 standard)
+ */
+int test_hs_get_status_default_ep(libusb_device *dev,
+				  int interface_id)
+{
+	struct libusb_endpoint_descriptor *in_ep;
+	struct libusb_device_handle *udev = NULL;
+	int rc = -1;
+
+	if (!dev) {
+		printf("libusb device  == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK,
+					 interface_id, PIPE_ID_UNDEF);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		goto hs_get_status_default_ep_done;
+	}
+
+	rc = test_get_status_functionality(dev, udev,
+			( LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			  LIBUSB_RECIPIENT_ENDPOINT),
+			(uint16_t)in_ep->bEndpointAddress,
+			hs_get_status_default_ep_expected);
+
+hs_get_status_default_ep_done:
+	libusb_close(udev);
+	return rc;
+}
+
+/**
+ * test_set_feature() - verify the SET_FEATURE request handling
+ * @dev: Libusb device hook
+ * @bmRequestType: The request's bmRequestType
+ * @wValue: The request's wValue
+ * @wIndex: The request's wIndex
+ * @pre_status:- The expected status before the set cmd
+ * @post_status: The expected status after the set cmd
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This is a general function that sends a SET_FEATURE request
+ * to {HS / SS} {device / EP / interface} with test specific
+ * parameters. The tests verifies the new settings.
+ */
+static int test_set_feature(libusb_device *dev,
+					  uint8_t  bmRequestType,
+					  uint16_t wValue,
+					  uint16_t wIndex,
+					  unsigned char *pre_status,
+					  unsigned char *post_status)
+{
+	struct libusb_device_handle *udev = NULL;
+	int transfer_res = 0, ret_val = -1;
+
+	if (!dev) {
+		printf("libusb device == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	/* Make sure that pre status is as expected */
+	ret_val = test_get_status_functionality(dev, udev,
+				LIBUSB_ENDPOINT_IN | bmRequestType,
+				wIndex, pre_status);
+
+	if (ret_val)
+	{
+		printf("Set feature test: Initial status != expected..\n");
+		goto exit_set_feature;
+	}
+
+	transfer_res = libusb_control_transfer(udev, 		/* device_hdl */
+				bmRequestType,			/* req type */
+				LIBUSB_REQUEST_SET_FEATURE,	/* bRequest */
+				wValue,				/* wValue */
+				wIndex,				/* wIndex */
+				NULL,				/* ret data */
+				0,				/* wLength */
+				CTL_REQ_TRANSFERR_TIMEOUT);	/* timeout */
+
+	if ((transfer_res == LIBUSB_ERROR_NO_DEVICE) ||
+	    (transfer_res == LIBUSB_ERROR_TIMEOUT) ||
+	    (transfer_res == LIBUSB_ERROR_IO) ||
+	    (transfer_res == LIBUSB_ERROR_PIPE) ) {
+		printf("LIBUSB error : (%d)\n", transfer_res);
+		ret_val = -1;
+		goto exit_set_feature;
+	}
+
+	/* Make sure that post status is as expected */
+	ret_val = test_get_status_functionality(dev, udev,
+				LIBUSB_ENDPOINT_IN | bmRequestType,
+				wIndex, post_status);
+
+	if (ret_val) {
+		printf("Set feature test:Post SET status != expected..\n");
+		goto exit_set_feature;
+	}
+
+exit_set_feature:
+	libusb_close(udev);
+	return ret_val;
+}
+
+/**
+ * test_clear_feature() - verify the CLEAR_FEATURE
+ * request handling
+ * @dev: Libusb device hook
+ * @bmRequestType: The request's bmRequestType
+ * @wValue: The request's wValue
+ * @wIndex: The request's wIndex
+ * @pre_status:- The expected status before the set cmd
+ * @post_status: The expected status after the set cmd
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This is a general function that sends a CLEAR_FEATURE request
+ * to {HS / SS} {device / EP / interface} with test specific
+ * parameters. The test verifies the new settings.
+ */
+static int test_clear_feature(libusb_device *dev,
+					  uint8_t  bmRequestType,
+					  uint16_t wValue,
+					  uint16_t wIndex,
+					  unsigned char *pre_status,
+					  unsigned char *post_status)
+{
+	struct libusb_device_handle *udev = NULL;
+	int transfer_res = 0, ret_val = -1;
+
+	if (!dev) {
+		printf("libusb device == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+
+	/* Make sure that pre status is as expected */
+	ret_val = test_get_status_functionality(dev, udev,
+				LIBUSB_ENDPOINT_IN | bmRequestType,
+				wIndex, pre_status);
+
+	if (ret_val)
+	{
+		printf("Clear feature test: Initial status != expected..\n");
+		goto exit_clear_feature;
+	}
+
+	/* Send the CLEAR_FEATURE: */
+	transfer_res = libusb_control_transfer(udev,		/* device_hdl */
+				bmRequestType,			/* req type */
+				LIBUSB_REQUEST_CLEAR_FEATURE,	/* bRequest */
+				wValue,				/* wValue */
+				wIndex,				/* wIndex */
+				NULL,				/* ret data */
+				0,				/* wLength */
+				CTL_REQ_TRANSFERR_TIMEOUT);	/* timeout */
+
+	if ( (transfer_res == LIBUSB_ERROR_NO_DEVICE) ||
+	     (transfer_res == LIBUSB_ERROR_TIMEOUT) ||
+	     (transfer_res == LIBUSB_ERROR_IO) ||
+	     (transfer_res == LIBUSB_ERROR_PIPE)) {
+		printf("LIBUSB error in CLEAR_FEATURE (%d)\n", transfer_res);
+		ret_val = -1;
+		goto exit_clear_feature;
+	}
+
+	/* Make sure that we are back to the initial status */
+	ret_val = test_get_status_functionality(dev, udev,
+				LIBUSB_ENDPOINT_IN | bmRequestType,
+				wIndex, post_status);
+
+	if (ret_val)
+		printf("Clear feature test:Post CLEAR status != expected..\n");
+
+exit_clear_feature:
+	libusb_close(udev);
+	return ret_val;
+}
+
+/**
+ * test_set_feature_functionality() - verify the SET_FEATURE request handling
+ * @dev: Libusb device hook
+ * @bmRequestType: The request's bmRequestType
+ * @wValue: The request's wValue
+ * @wIndex: The request's wIndex
+ * @pre_status:- The expected status before the set cmd
+ * @post_status: The expected status after the set cmd
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This is a general function that sends a SET_FEATURE request to {HS / SS}
+ * {device / EP / interface} with test specific parameters, after verifying the
+ * new settings, the tests clears the change.
+ */
+static int test_set_feature_functionality(libusb_device *dev,
+					  uint8_t  bmRequestType,
+					  uint16_t wValue,
+					  uint16_t wIndex,
+					  unsigned char *pre_status,
+					  unsigned char *post_status)
+{
+	int ret_val = -1;
+
+	ret_val = test_set_feature(dev,
+						  bmRequestType,
+						  wValue,
+						  wIndex,
+						  pre_status,
+						  post_status);
+
+	if (ret_val < 0) {
+		printf("test_set_feature failed\n");
+		return ret_val;
+	}
+
+	ret_val = test_clear_feature(dev,
+						  bmRequestType,
+						  wValue,
+						  wIndex,
+						  post_status,
+						  pre_status);
+
+	if (ret_val < 0) {
+		printf("test_set_feature failed\n");
+		return ret_val;
+	}
+
+	return ret_val;
+}
+
+/**
+ * test_ss_set_feature_u1_device() - verify the SET_FEATURE(U1) handling
+ * @dev: Libusb device hook
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss device in default state,
+ * to set the U1 power level capability
+ */
+int test_ss_set_feature_u1_device(libusb_device *dev)
+{
+	return test_set_feature_functionality(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_DEVICE), U1_ENABLE_FEATURE_SEL,
+			/* For SetFeature/GetStatus for DEVICE requests
+			 *  wIndex = 0x00
+			 */
+			0x00,
+			ss_get_status_default_device_expected,
+			ss_get_status_U1_enabled_device_expected);
+}
+
+/**
+ * test_ss_set_feature_u2_device() - verify the SET_FEATURE(U2) handling
+ * @dev: Libusb device hook
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss device in default state,
+ * to set the U2 power level capability
+ */
+int test_ss_set_feature_u2_device(libusb_device *dev)
+{
+	return test_set_feature_functionality(dev,
+			( LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			  LIBUSB_RECIPIENT_DEVICE), U2_ENABLE_FEATURE_SEL,
+			/* For SetFeature/GetStatus for DEVICE requests
+			 *  wIndex = 0x00
+			 */
+			0x00,
+			ss_get_status_default_device_expected,
+			ss_get_status_U2_enabled_device_expected);
+}
+
+/**
+ * test_ss_set_feature_ltm_device() - verify the SET_FEATURE(LTM) handling
+ * @dev: Libusb device hook
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss device in default state,
+ * to set the LTM capability
+ */
+int test_ss_set_feature_ltm_device(libusb_device *dev)
+{
+	return test_set_feature_functionality(dev,
+			( LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			  LIBUSB_RECIPIENT_DEVICE), LTM_ENABLE_FEATURE_SEL,
+			/* For SetFeature/GetStatus for DEVICE requests
+			 *  wIndex = 0x00
+			 */
+			0x00,
+			ss_get_status_default_device_expected,
+			ss_get_status_LTM_enabled_device_expected);
+}
+
+/**
+ * test_ss_set_feature_halt_ep() - verify the SET_FEATURE(HALT_EP) handling
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss EP in default state, to
+ * set the halt feature It's run for the BULK IN endpoint and assumes  the
+ * device has such.
+ */
+int test_ss_set_feature_halt_ep(libusb_device *dev,
+				int interface_id)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *in_ep;
+	int ret_val = -1;
+
+	if (!dev) {
+		printf("libusb device == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+			     LIBUSB_TRANSFER_TYPE_BULK,
+			     interface_id, PIPE_ID_UNDEF);
+	libusb_close(udev);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		goto ss_set_feature_halt_ep_done;
+	}
+
+	ret_val =  test_set_feature_functionality(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_ENDPOINT),
+			HALT_ENABLE_FEATURE_SEL,
+			(uint16_t)in_ep->bEndpointAddress,
+			ss_get_status_default_ep_expected,
+			ss_get_status_halt_enabled_ep_expected);
+
+ss_set_feature_halt_ep_done:
+	return ret_val;
+}
+
+/**
+ * test_hs_set_feature_halt_ep() - verify the SET_FEATURE(HALT_EP) handling
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the hs EP in default state,
+ * to set the halt feature. It's run for the BULK IN endpoint and assumes the
+ * device has such.
+ */
+int test_hs_set_feature_halt_ep(libusb_device *dev,
+				int interface_id)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *in_ep;
+	int ret_val = -1;
+
+	if (!dev) {
+		printf("libusb device == NULL..\n");
+		return -1;
+	}
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		return -1;
+	}
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+			     LIBUSB_TRANSFER_TYPE_BULK,
+			     interface_id, PIPE_ID_UNDEF);
+	libusb_close(udev);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		goto hs_set_feature_halt_ep_done;
+	}
+
+	ret_val =  test_set_feature_functionality(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_ENDPOINT),
+			HALT_ENABLE_FEATURE_SEL,
+			(uint16_t)in_ep->bEndpointAddress,
+			hs_get_status_default_ep_expected,
+			hs_get_status_halt_enabled_ep_expected);
+
+hs_set_feature_halt_ep_done:
+	return ret_val;
+}
+
+/**
+ * test_ss_set_feature_suspend_low_power_interface() - verify the
+ * SET_FEATURE(FUNCTION_SUSPEND) functionality
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss interface in default
+ * state, to set the suspend functionality for low power
+ */
+int test_ss_set_feature_suspend_low_power_interface(libusb_device *dev,
+						    int interface_id)
+{
+	int ret_val = 0;
+
+	/* Suspend the interface */
+	ret_val = test_set_feature(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id | (FUNC_SUSPEND_OPT_LOW_POWER << 8),
+			hs_get_status_default_interface_expected,
+			ss_get_status_suspend_low_power_interface_expected);
+
+	if (ret_val < 0)
+		goto ss_set_feature_suspend_interface_done;
+
+	/* Check that the device suspended the interface */
+	ret_val = usb_tests_read_gadget_sysfs_file((char*)GADGET_ZERO_FUNC_SUSPENDED_SYSFS_PATH);
+	if (ret_val != 1) {
+		printf("Function is not in suspend state, %d", ret_val);
+		goto ss_set_feature_suspend_interface_done;
+	}
+
+	/* Resume the interface */
+	ret_val = test_set_feature(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id,
+			ss_get_status_suspend_low_power_interface_expected,
+			hs_get_status_default_interface_expected);
+
+	if (ret_val < 0)
+		goto ss_set_feature_suspend_interface_done;
+
+	/* Check that the device resumed the interface */
+	ret_val = usb_tests_read_gadget_sysfs_file((char*)GADGET_ZERO_FUNC_SUSPENDED_SYSFS_PATH);
+	if (ret_val != 0) {
+		printf("Function is in suspend state, %d", ret_val);
+		goto ss_set_feature_suspend_interface_done;
+	}
+
+ss_set_feature_suspend_interface_done:
+	return ret_val;
+}
+
+/**
+ * test_ss_set_feature_suspend_remote_wakeup_interface() - verify the
+ * SET_FEATURE(FUNCTION_SUSPEND) functionality
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss interface in default
+ * state, to set the suspend functionality for remote wakeup
+ */
+int test_ss_set_feature_suspend_remote_wakeup_interface(libusb_device *dev,
+							int interface_id)
+{
+	int ret_val = 0;
+
+	/* Suspended the interface */
+	ret_val = test_set_feature(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id | (FUNC_SUSPEND_OPT_LOW_POWER << 8),
+			hs_get_status_default_interface_expected,
+			ss_get_status_suspend_low_power_interface_expected);
+
+	if (ret_val < 0)
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+
+	/* Check that the device suspended the interface */
+	ret_val = usb_tests_read_gadget_sysfs_file((char*)GADGET_ZERO_FUNC_SUSPENDED_SYSFS_PATH);
+	if (ret_val != 1) {
+		printf("Function is not in suspend state, %d", ret_val);
+		ret_val = -1;
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	/* Set the Function Remote Wake capability */
+	ret_val = usb_tests_write_gadget_sysfs_file_int(
+		(char*)ZERO_GADGET_ZERO_FUNC_WAKEUP_CAPABLE_SYSFS_PATH, 1);
+	if (ret_val != 0) {
+		printf("write file failed, %d", ret_val);
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	/* Set the Function Remote Wake Enabled feature */
+	ret_val = test_set_feature(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id | (FUNC_SUSPEND_OPT_WAKEUP_EN << 8),
+			ss_get_status_suspend_remote_wu_cap_interface_expected,
+			ss_get_status_suspend_remote_wu_en_cap_interface_expected);
+
+	if (ret_val != 0)
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+
+	/* Check that the device enabled the Function Remote Wake */
+	ret_val = usb_tests_read_gadget_sysfs_file(
+		(char*)ZERO_GADGET_ZERO_FUNC_WAKEUP_ENABLED_SYSFS_PATH);
+	if (ret_val != 1) {
+		printf("Function wake is not enabled, %d", ret_val);
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	/* Trigger Function Remote Wake by the device */
+	ret_val = usb_tests_write_gadget_sysfs_file_int(
+		(char*)ZERO_GADGET_ZERO_FUNC_WAKEUP_TRIGGER_SYSFS_PATH, 1);
+	if (ret_val != 0) {
+		printf("write file failed, %d", ret_val);
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	/* Resume the interface */
+	ret_val = test_set_feature(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id,
+			ss_get_status_suspend_remote_wu_en_cap_interface_expected,
+			ss_get_status_suspend_remote_wu_cap_interface_expected);
+
+	if (ret_val < 0)
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+
+	/* Check that the device resumed the interface */
+	ret_val = usb_tests_read_gadget_sysfs_file((char*)GADGET_ZERO_FUNC_SUSPENDED_SYSFS_PATH);
+	if (ret_val != 0) {
+		printf("Function is in suspend state, %d", ret_val);
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	/* Clear the Function Remote Wake capability */
+	ret_val = usb_tests_write_gadget_sysfs_file_int(
+		(char*)ZERO_GADGET_ZERO_FUNC_WAKEUP_CAPABLE_SYSFS_PATH, 0);
+	if (ret_val != 0) {
+		printf("write file failed, %d", ret_val);
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+	}
+
+	if (ret_val < 0)
+		goto ss_set_feature_suspend_remote_wakeup_interface_done;
+
+ss_set_feature_suspend_remote_wakeup_interface_done:
+	return ret_val;
+}
+
+/**
+ * test_hs_set_feature_suspend_remote_wakeup_interface() - verify the
+ * SET_FEATURE(FUNCTION_SUSPEND) functionality
+ * @dev: Libusb device hook
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 for sucsess, (-1) for failure
+ *
+ * This function sends a SET_FEATURE request to the ss interface in default
+ * state, to set the suspend functionality for remote wakeup
+ */
+int test_hs_set_feature_suspend_interface(libusb_device *dev,
+					  int interface_id)
+{
+	return test_set_feature_functionality(dev,
+			(LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD |
+			 LIBUSB_RECIPIENT_INTERFACE),
+			SUSPEND_ENABLE_FEATURE_SEL,
+			interface_id,
+			hs_get_status_default_interface_expected,
+			hs_get_status_default_interface_expected);
+}
+
diff --git a/tools/usb/unittests/usb/composite_tests.h b/tools/usb/unittests/usb/composite_tests.h
new file mode 100644
index 0000000..db68db0
--- /dev/null
+++ b/tools/usb/unittests/usb/composite_tests.h
@@ -0,0 +1,65 @@
+/*
+ * composite_tests.h - USB composite device general tests
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef COMPOSITE_TESTS_H
+#define COMPOSITE_TESTS_H
+
+#include <linux/kernel.h>
+#include <linux/usb/ch9.h>
+#include "libusb_utils.h"
+
+int soursesink_test_setup(struct libusb_device_handle *udev, libusb_device *dev,
+			  uint8_t request, uint16_t wValue);
+int test_hs_descriptors(libusb_device *dev);
+int test_ss_descriptors(libusb_device *dev, int num_expected_strms_in_ep,
+			    int num_expected_strms_out_ep);
+int test_connect_disconnect(libusb_device *dev, enum usb_device_speed dev_speed,
+			    int num_expected_strms_in_ep,
+			    int num_expected_strms_out_ep);
+int test_ss_get_status_default_device(libusb_device *dev);
+int test_ss_get_status_default_interface(libusb_device *dev, int interface_id);
+int test_ss_get_status_default_ep(libusb_device *dev, int interface_id);
+int test_hs_get_status_default_device(libusb_device *dev);
+int test_hs_get_status_default_interface(libusb_device *dev, int interface_id);
+int test_hs_get_status_default_ep(libusb_device *dev, int interface_id);
+int test_ss_set_feature_u1_device(libusb_device *dev);
+int test_ss_set_feature_u2_device(libusb_device *dev);
+int test_ss_set_feature_ltm_device(libusb_device *dev);
+int test_ss_set_feature_halt_ep(libusb_device *dev, int interface_id);
+int test_hs_set_feature_halt_ep(libusb_device *dev, int interface_id);
+int test_ss_set_feature_suspend_low_power_interface(libusb_device *dev,
+						    int interface_id);
+int test_ss_set_feature_suspend_remote_wakeup_interface(libusb_device *dev,
+							int interface_id);
+int test_hs_set_feature_suspend_interface(libusb_device *dev, int interface_id);
+
+#endif /*COMPOSITE_TESTS_H*/
diff --git a/tools/usb/unittests/usb/g_serial_tests.cc b/tools/usb/unittests/usb/g_serial_tests.cc
new file mode 100644
index 0000000..3da7870
--- /dev/null
+++ b/tools/usb/unittests/usb/g_serial_tests.cc
@@ -0,0 +1,198 @@
+/*
+ * g_serial_tests.c - generic USB serial function driver tests
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <linux/usb/ch9.h>
+
+#include "ut_config.h"
+#include "libusb_utils.h"
+#include "composite_tests.h"
+
+/**
+ * test_single_bulk_in() - Initiate a single bulk in transfer
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to receive
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * TODO: add data validity check
+ * 	 add debug information!
+ */
+int test_single_bulk_in(libusb_device *dev, int data_size,
+			int interface_id)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *in_ep;
+	unsigned char *data_in;
+	int transferred = 0;
+	int ret;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto test_single_bulk_in_err;
+	}
+
+	data_in = (unsigned char *)malloc(data_size+10);
+	if (!data_in) {
+		printf("Error allocating memory!\n");
+		goto test_single_bulk_in_err;
+	}
+
+	/*
+	 * First send the control request to setup the buffer size on
+	 * the device
+	 */
+	if (soursesink_test_setup(udev, dev, SET_BULK_BUF_SIZE, data_size) < 0){
+		printf("Coldn't send setup test control packet\n");
+		goto test_single_bulk_in_err;
+	}
+
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+					 LIBUSB_TRANSFER_TYPE_BULK,
+					 interface_id, PIPE_ID_UNDEF);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		goto test_single_bulk_in_err;
+	}
+
+	ret = libusb_bulk_transfer(udev, in_ep->bEndpointAddress, data_in,
+				   data_size, &transferred,
+				   BULK_TRANSFERR_TIMEOUT);
+	if (ret) {
+		printf("Transferr error %d (endpoint = %u)\n",ret,
+		       in_ep->bEndpointAddress);
+		goto test_single_bulk_in_err;
+	}
+
+	if (transferred != data_size) {
+		printf("The number of bytes actually "
+		       "transferred (%d) != data size (%d)",
+		       transferred, data_size);
+		goto test_single_bulk_in_err;
+	}
+
+	ret = 0;
+	goto test_single_bulk_in_done;
+test_single_bulk_in_err:
+	ret = -1;
+test_single_bulk_in_done:
+	libusb_close(udev);
+	free(data_in);
+	return ret;
+}
+
+/**
+ * test_single_bulk_out() - Initiate a single bulk out transfer
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to send
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * TODO: add data validity check
+ *	 add debug information!
+ */
+int test_single_bulk_out(libusb_device *dev, int data_size,
+			 int interface_id)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *out_ep;
+	unsigned char *data_out;
+	int transferred = 0;
+	int ret, i;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		goto test_single_bulk_out_err;
+	}
+
+	data_out = (unsigned char *)malloc(data_size+10);
+	if (!data_out) {
+		printf("Error allocating memory!\n");
+		goto test_single_bulk_out_err;
+	}
+
+	/*Fill in the data buffer*/
+	for (i = 0; i < data_size; i++)
+		snprintf((char*)(&data_out[i]), 1, "%d", i);
+
+	/*First send the control request to start the test in f_sourcesink*/
+	if (soursesink_test_setup(udev, dev, 0x5e, data_size) < 0){
+		printf("Codn't send setup test controll packet\n");
+		goto test_single_bulk_out_err;
+	}
+
+	out_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+			     LIBUSB_TRANSFER_TYPE_BULK,
+			     interface_id, PIPE_ID_UNDEF);
+
+	if (!out_ep) {
+		printf("Didn't find BULK OUT endpoint!\n");
+		goto test_single_bulk_out_err;
+	}
+
+	ret = libusb_bulk_transfer(udev, out_ep->bEndpointAddress, data_out,
+				   data_size, &transferred,
+				   BULK_TRANSFERR_TIMEOUT);
+	if (ret) {
+		printf("Transferr error %d (endpoint = %u)\n",ret,
+		       out_ep->bEndpointAddress);
+		goto test_single_bulk_out_err;
+	}
+
+	if (transferred != data_size) {
+		printf("The number of bytes actually transferred (%d) != "
+		       "data size (%d)", transferred, data_size);
+		goto test_single_bulk_out_err;
+	}
+
+	ret = 0;
+	goto test_single_bulk_out_done;
+test_single_bulk_out_err:
+	ret = -1;
+test_single_bulk_out_done:
+	libusb_close(udev);
+	free(data_out);
+	return ret;
+}
+
diff --git a/tools/usb/unittests/usb/g_serial_tests.h b/tools/usb/unittests/usb/g_serial_tests.h
new file mode 100644
index 0000000..48a2723
--- /dev/null
+++ b/tools/usb/unittests/usb/g_serial_tests.h
@@ -0,0 +1,68 @@
+/*
+ * g_serial_tests.h - generic USB serial function driver tests
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef G_SERIAL_TESTS_H
+#define G_SERIAL_TESTS_H
+
+#include <linux/kernel.h>
+#include "libusb_utils.h"
+
+/**
+ * test_single_bulk_in() - Initiate a single bulk in transfer
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to receive
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * TODO: add data validity check
+ *	 add debug information!
+ */
+int test_single_bulk_in(libusb_device *dev, int data_size,
+			int interface_id);
+
+
+/**
+ * test_single_bulk_out() - Initiate a single bulk out transfer
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to send
+ * @interface_id: interface id to run the test on
+ *
+ * Returns 0 on sucsess -1 for failure
+ *
+ * TODO: add data validity check
+ *	 add debug information!
+ */
+int test_single_bulk_out(libusb_device *dev, int data_size,
+			 int interface_id);
+
+#endif /*G_SERIAL_TESTS_H*/
diff --git a/tools/usb/unittests/usb/hs_expected_desc.h b/tools/usb/unittests/usb/hs_expected_desc.h
new file mode 100644
index 0000000..3223038
--- /dev/null
+++ b/tools/usb/unittests/usb/hs_expected_desc.h
@@ -0,0 +1,164 @@
+/*
+ * hs_expected_desc.h - Expected descriptors when opperation in HS mode
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include "libusb_utils.h"
+
+/* This is the expected value for the HS device descriptor */
+struct libusb_device_descriptor hs_device_descriptor = {
+	18,			/* bLength */
+	LIBUSB_DT_DEVICE,	/* bDescriptorType */
+	0x0210,			/* bcdUSB */
+	2,			/* bDeviceClass = LIBUSB_CLASS_COMM */
+	0,			/* bDeviceSubClass */
+	0,			/* bDeviceProtocol */
+	64,			/* bMaxPacketSize0 */
+	0x0525,			/* idVendor; May be different */
+	0xa4a7,			/* idProduct; May be different */
+	0,			/* bcdDevice; TODO: update */
+	0,			/* iManufacturer; May be different */
+	1,			/* iProduct; May be different */
+	2,			/* iSerialNumber; May be different */
+	1			/* bNumConfigurations */
+};
+
+/* This is the expected value for the HS device BULK OUT endpoint descriptor */
+struct libusb_endpoint_descriptor hs_bulk_out_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_OUT,	/* bEndpointAddress */
+	2,			/*
+				 * bmAttributes:Transfer Type	Bulk
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	512,			/* wMaxPacketSize */
+	0,			/* bInterval */
+	0,			/* bRefresh; Not used since not audio device */
+	0,			/* bSynchAddress; Not used */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/* This is the expected value for the HS device BULK IN endpoint descriptor */
+struct libusb_endpoint_descriptor hs_bulk_in_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_IN,	/* bEndpointAddress */
+	2,			/*
+				 * bmAttributes:Transfer Type	Bulk
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	512,			/* wMaxPacketSize */
+	0,			/* bInterval */
+	0,			/* bRefresh; Not used since not audio device */
+	0,			/* bSynchAddress; Not used */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/* This is the expected value for the HS device INTERRUPT endpoint descriptor */
+struct libusb_endpoint_descriptor hs_intr_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_IN,	/* bEndpointAddress */
+	3,			/*
+				 * bmAttributes:Transfer Type	Interrupt
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	0xa,			/* wMaxPacketSize */
+	9,			/* bInterval */
+	0,			/* bRefresh; Not used since not audio device */
+	0,			/* bSynchAddress; Not used */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/* This is the expected value for the HS device zero interface descriptor */
+struct libusb_interface_descriptor hs_zero_intr_descriptor = {
+	9,			/* bLength */
+	LIBUSB_DT_INTERFACE,	/* bDescriptorType */
+	0,			/* bInterfaceNumber */
+	0,			/* bAlternateSetting */
+	1,			/* bNumEndpoints */
+	LIBUSB_CLASS_COMM,	/* bInterfaceClass; May be different*/
+	0,			/* bInterfaceSubClass; Should be different */
+	0,			/* bInterfaceProtocol; Should be different */
+	0,			/* iInterface; Should be different */
+	NULL,			/* endpoint */
+	NULL,			/* extra */
+	NULL			/* extra_length */
+};
+
+/* This is the expected value for the HS device interface descriptor */
+struct libusb_interface_descriptor hs_intr_descriptor = {
+	9,			/* bLength */
+	LIBUSB_DT_INTERFACE,	/* bDescriptorType */
+	1,			/* bInterfaceNumber */
+	0,			/* bAlternateSetting */
+	2,			/* bNumEndpoints */
+	LIBUSB_CLASS_DATA,	/* bInterfaceClass; May be different */
+	0,			/* bInterfaceSubClass; Should be different */
+	0,			/* bInterfaceProtocol; Should be different */
+	0,			/* iInterface; Should be different */
+	NULL,			/* endpoint */
+	NULL,			/* extra */
+	NULL			/* extra_length */
+};
+
+
+/*
+ * Expected returned data values for the HS GET_STATUS tests
+ * (dummy_hcd configuration..)
+ */
+
+/*
+ * Expected result is 0x0001 - that means that only self-powered is enabled
+ * while Remote-wakeup is disabled
+ */
+unsigned char hs_get_status_default_device_expected[2] = { 0x01, 0x00};
+
+/* Expected result is 0x0000 (all is reserved) */
+unsigned char hs_get_status_default_interface_expected[2] = { 0x00, 0x00};
+
+/* Expected result is 0x0000 - that means that this ep is not halted */
+unsigned char hs_get_status_default_ep_expected[2] = { 0x00, 0x00};
+
+/* Expected result is 0x0001 - that means that this ep is halt enabled */
+unsigned char hs_get_status_halt_enabled_ep_expected[2] = { 0x01, 0x00};
diff --git a/tools/usb/unittests/usb/libusb_utils.cc b/tools/usb/unittests/usb/libusb_utils.cc
new file mode 100644
index 0000000..f8e60c7
--- /dev/null
+++ b/tools/usb/unittests/usb/libusb_utils.cc
@@ -0,0 +1,358 @@
+/*
+ * libusb_utils.c - libusb utilities
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include "libusb_utils.h"
+
+#include <linux/usb/ch9.h>
+
+
+static libusb_device **devs;
+static int devcnt;
+static int was_initialized = false;
+
+/**
+ * libusb_utils_parse_descriptor() - gets a descriptor buffer and parses it
+ * to the descriptor message.
+ * @source: the descriptor buffer to be parsed
+ * @descriptor: the bit mapping of the descriptor, for example use "bbwd"
+ *	for parsing a descriptor that contains byte, byte, 16-bit word,
+ *	32-bit word.
+ * @dest: a pointer to the descriptor message
+ * @host_endian: set host_endian if the w values are already in host endian
+ *	format, as opposed to bus endian.
+ *
+ */
+int libusb_utils_parse_descriptor(unsigned char *source,
+				  char *descriptor, void *dest,
+				  int host_endian)
+{
+	unsigned char *sp = source, *dp = (unsigned char*)dest;
+	uint16_t w;
+	uint32_t d;
+	char *cp;
+
+	for (cp = descriptor; *cp; cp++) {
+		switch (*cp) {
+			case 'b':	/* 8-bit byte */
+				*dp++ = *sp++;
+				break;
+			case 'w':
+			/* 16-bit word, convert from little endian to CPU */
+				/* Align to word boundary */
+				dp += ((unsigned long)dp & 1UL);
+
+				if (host_endian) {
+					memcpy(dp, sp, 2);
+				} else {
+					w = (sp[1] << 8) | sp[0];
+					*((uint16_t *)dp) = w;
+				}
+				sp += 2;
+				dp += 2;
+				break;
+			/* 32-bit word, convert from little endian to CPU */
+			case 'd':
+			/* Align to dword boundary */
+				dp = (unsigned char*)(((unsigned long)dp + 3)
+						      & ~3UL);
+				if (host_endian) {
+					memcpy(dp, sp, 4);
+				} else {
+					d = (sp[3] << 24) | (sp[2] << 16) |
+						(sp[1] << 8) | sp[0];
+					*((uint32_t *)dp) = d;
+				}
+				sp += 4;
+				dp += 4;
+				break;
+		}
+	}
+	return sp - source;
+}
+
+/**
+ * libusb_utils_get_bos_desc() - returns the BOS descriptor
+ * @dev: libusb device
+ * @udev: libusb device handle for the opened device
+ * @bos: the bos descriptor
+ *
+ * Returns 0 on success -1 on failure
+ *
+ * This function is relevent only for SS device.
+ */
+int libusb_utils_get_bos_desc(struct libusb_device *dev,
+		   struct libusb_device_handle *udev,
+		   struct libusb_bos_descriptor *bos)
+{
+	unsigned char bos_buf[LIBUSB_DT_BOS_MAX_SIZE];
+	int ret;
+	int ctrl_timeout = (5*1000);	/* milliseconds */
+
+	if (!dev | !udev)
+	    return -1;
+
+	memset (bos_buf, 0, sizeof(bos_buf));
+
+	ret = libusb_control_transfer(udev,
+			LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD |
+			      LIBUSB_RECIPIENT_DEVICE,
+			LIBUSB_REQUEST_GET_DESCRIPTOR,
+			LIBUSB_DT_BOS << 8, 0,
+			bos_buf, sizeof bos_buf, ctrl_timeout);
+
+	if (ret < 0 && errno != EPIPE) {
+		perror("can't get BOS");
+		return -1;
+	}
+
+	/* all supper-speed devices have a BOS */
+	if ((ret == 0) || (bos_buf[1] != LIBUSB_DT_BOS)) {
+		printf("not a BOS descriptor, buf[1]=%x\n", bos_buf[1]);
+		return -1;
+	}
+
+	libusb_parse_bos_desc(dev, bos, bos_buf);
+
+	return 0;
+}
+
+/**
+ * libusb_utils_get_device_by_num() - returns the device according to its
+ * bus number and device number
+ * @busnum: bus number
+ * @devnum: device number
+ *
+ * Returns pointer to the libusb device or NULL on failure
+ */
+libusb_device *libusb_utils_get_device_by_num(int busnum, int devnum)
+{
+	int i;
+	uint8_t bus, addr;
+	libusb_device *dev;
+
+	for (i = 0; (dev = devs[i]) != NULL; i++) {
+		bus = libusb_get_bus_number(dev);
+		addr = libusb_get_device_address(dev);
+
+
+		if (((busnum != -1) && (busnum != bus)) ||
+		    ((devnum != -1) && (devnum != addr)))
+			continue;
+
+		return dev;
+	}
+	return NULL;
+}
+
+/**
+ * libusb_utils_get_device_by_product_vendor() -returns the device according to
+ * its product ID and vendor ID
+ * @vendorid: vendor ID
+ * @productid: product ID
+ *
+ * Returns pointer to the libusb device or NULL on failure
+ */
+libusb_device *libusb_utils_get_device_by_product_vendor(int vendorid,
+							 int productid)
+{
+	int i;
+	libusb_device *dev;
+
+	for (i = 0; (dev = devs[i]) != NULL; i++) {
+		struct libusb_device_descriptor dev_desc;
+
+		if (libusb_get_device_descriptor(dev, &dev_desc) < 0) {
+			printf("Couldn't get device descriptor\n");
+			return NULL;
+		}
+		if (((vendorid != -1) && (vendorid != (int)dev_desc.idVendor))
+		    || ((productid != -1) &&
+			(productid != (int)dev_desc.idProduct))){
+			printf("dev_desc.idVendor = %d, dev_desc.idProduct = %d"
+			       "productid = %d, vendorid= %d\n",
+			       (int)dev_desc.idVendor,
+			       (int)dev_desc.idProduct, productid, vendorid);
+			continue;
+		}
+		return dev;
+	}
+	return NULL;
+}
+
+static struct libusb_uasp_pipe_usage_desc *get_pipe_usage_desc(
+	unsigned char *extra_ep_data,
+	int extra_length
+)
+{
+	struct libusb_uasp_pipe_usage_desc *pipe_usage_d = NULL;
+	if (extra_length < 0x04)
+		return NULL;
+	pipe_usage_d = (struct libusb_uasp_pipe_usage_desc *)extra_ep_data;
+	if (pipe_usage_d->bDescriptorType != LIBUSB_DT_PIPE_USAGE)
+		return NULL;
+	return pipe_usage_d;
+}
+
+/**
+ * get_ep_from_intrf() - returns the endpoint descriptor
+ * @dev: libusb device
+ * @ep_type: endpoint type (USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT})
+ * @interface: the interface in which ep list to search for the endpoint
+ * @pipeID - for UASP device specify the pipe id of the
+ *		 endpoint. If not a UASP device pipeID=0
+ *
+ * This function returns the endpoint descriptor (from a specified interfce)
+ * according to its transfer type direction, and if UASP device then pipe id.
+ *
+ * Returns the endpoint descriptor of the requested endpoint or NULL in case
+ * of error
+ */
+static struct libusb_endpoint_descriptor *get_ep_from_intrf(
+		struct libusb_interface *interface,
+		int direction,
+		int ep_type,
+		int pipeID
+)
+{
+	int i,j;
+	struct libusb_uasp_pipe_usage_desc *pipe_desc = NULL;
+	/* Go over interface alternate settings */
+	for (i = 0; i < interface->num_altsetting; i++) {
+		struct libusb_interface_descriptor *interface_desc =
+			(struct libusb_interface_descriptor *)
+					(interface->altsetting + i);
+		/* Go over the interface endpoints */
+		for (j = 0; j < interface_desc->bNumEndpoints; j++) {
+			struct libusb_endpoint_descriptor *ep_desc =
+				(struct libusb_endpoint_descriptor *)
+				(interface_desc->endpoint + j);
+			if (((ep_desc->bmAttributes &
+			      USB_ENDPOINT_XFERTYPE_MASK) == ep_type) &&
+			    ((ep_desc->bEndpointAddress &
+			     LIBUSB_ENDPOINT_DIR_MASK) == direction)){
+				if (!pipeID)
+					return ep_desc;
+
+				pipe_desc =
+					get_pipe_usage_desc(
+						(unsigned char*)ep_desc->extra,
+							ep_desc->extra_length);
+				if (pipe_desc &&
+				    (pipe_desc->bPipeID == pipeID))
+					return ep_desc;
+			}
+		}
+	}
+	return NULL;
+
+}
+
+/**
+ * libusb_utils_get_ep_desc() - returns the endpoint descriptor according to
+ * its transfer type, direction and if UASP device then pipe id.
+ * @dev: libusb device
+ * @ep_type: endpoint type (USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT})
+ * @intr_num: number of the interface the ep belongs to.
+ *	If this value is -1 then we'll return the first ep that is complient
+ *	with the direction and type, regardless of the interface
+ * @pipeID - for UASP device specify the pipe id of the
+ *		 endpoint. If not a UASP device pipeID=0
+ * Returns the endpoint descriptor of the requested endpoint or NULL in case
+ * of error
+ */
+struct libusb_endpoint_descriptor *libusb_utils_get_ep_desc(
+				libusb_device *dev,
+				int direction,
+				int ep_type,
+				int intr_num,
+				int pipeID)
+{
+	struct libusb_config_descriptor *config;
+	int k;
+	struct libusb_endpoint_descriptor *ret_val = NULL;
+
+	if (libusb_get_active_config_descriptor(dev, &config))
+		return NULL;
+
+	if ((intr_num > -1) && (intr_num < config->bNumInterfaces))
+		ret_val = get_ep_from_intrf(
+		      (struct libusb_interface *)(config->interface + intr_num),
+		      direction, ep_type, pipeID);
+	else {
+		for (k = 0; k < config->bNumInterfaces; k++) {
+			ret_val = get_ep_from_intrf(
+			     (struct libusb_interface *)(config->interface + k),
+			     direction, ep_type, pipeID);
+			if (ret_val)
+				return ret_val;
+		}
+	}
+	return ret_val;
+}
+
+/**
+ * libusb_utils_init() - initializes the libusb
+ *
+ * This function initializes the libusb and gets the list of devices.
+ * The function returns the number of devices
+ */
+int libusb_utils_init(void)
+{
+	int err = 0;
+
+	if (was_initialized)
+		return devcnt;
+
+	err = libusb_init(NULL);
+	if (err < 0)
+		return err;
+	devcnt = libusb_get_device_list(NULL, &devs);
+	was_initialized = true;
+
+	return devcnt;
+}
+
+
+/**
+ * libusb_utils_exit() - un-inits the libusb
+ *
+ * This function un-inits the libusb and frees the device list
+ */
+void libusb_utils_exit(void)
+{
+	libusb_free_device_list(devs, 1);
+	was_initialized = false;
+	libusb_exit(NULL);
+}
diff --git a/tools/usb/unittests/usb/libusb_utils.h b/tools/usb/unittests/usb/libusb_utils.h
new file mode 100644
index 0000000..96f9d93
--- /dev/null
+++ b/tools/usb/unittests/usb/libusb_utils.h
@@ -0,0 +1,149 @@
+/*
+ * libusb_utils.h - libusb utilities
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+extern "C" {
+#include <libusb.h>
+}
+
+/**
+ * libusb_utils_parse_descriptor() - gets a descriptor buffer and parses it
+ * to the descriptor message.
+ * @source: the descriptor buffer to be parsed
+ * @descriptor: the bit mapping of the descriptor, for example use "bbwd" for
+ *	parsing a descriptor that contains byte, byte, 16-bit word, 32-bit word.
+ * @dest: a pointer to the descriptor message
+ * @host_endian: set host_endian if the w values are already in host endian
+ *	format, as opposed to bus endian.
+ *
+ */
+int libusb_utils_parse_descriptor(unsigned char *source,
+				  char *descriptor, void *dest,
+				  int host_endian);
+
+
+/**
+ * libusb_utils_get_device_by_num() - returns the device according to its
+ * bus number and device number
+ * @busnum: bus number
+ * @devnum: device number
+ *
+ * Returns pointer to the libusb device or NULL on failure
+ */
+libusb_device *libusb_utils_get_device_by_num(int busnum, int devnum);
+
+
+/**
+ * libusb_utils_get_device_by_product_vendor() -returns the device according to
+ * its product ID and vendor ID
+ * @vendorid: vendor ID
+ * @productid: product ID
+ *
+ * Returns pointer to the libusb device or NULL on failure
+ */
+libusb_device *libusb_utils_get_device_by_product_vendor(int vendorid,
+							 int productid);
+
+/**
+ * libusb_utils_get_ep_desc() - returns the endpoint descriptor according to
+ * its transfer type, direction and if UASP device then pipe id.
+ * @dev: libusb device
+ * @ep_type: endpoint type (USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT})
+ * @intr_num: number of the interface the ep belongs to.
+ *	If this value is -1 then we'll return the first ep that is complient
+ *	with the direction and type, regardless of the interface
+ * @pipeID - for UASP device specify the pipe id of the
+ *		 endpoint. If not a UASP device pipeID=0
+ * Returns the endpoint descriptor of the requested endpoint or NULL in case
+ * of error
+ */
+struct libusb_endpoint_descriptor *libusb_utils_get_ep_desc(
+				libusb_device *dev,
+				int direction,
+				int ep_type,
+				int intr_num,
+				int pipeID);
+
+/**
+ * This function returns the endpoint descriptor according to
+ * its transfer type, direction and pipe usage.
+ * This function is used only with UASP device
+ *
+ * @param dev - libusb device
+ * @param ep_type - endpoint type (USB_ENDPOINT_XFER_{CONTROL,
+ *		  ISOC, BULK, INT})
+ * @param intr_num - number of the interface the ep belongs to.
+ *		   If this value is -1 then we'll return the
+ *		   first ep that is complient with the direction
+ *		   and type, regardless of the interface
+ * @param pipeID - the usage of the pipe, one of the bellow
+ *			PIPE_ID_CMD, PIPE_ID_STS, PIPE_ID_DATA_IN,
+ *			PIPE_ID_DATA_OUT
+ * @return - the endpoint descriptor of the requested endpoint
+ *	   or NULL in case of error
+ */
+struct libusb_endpoint_descriptor *libusb_utils_get_ep_desc_by_usage(
+				libusb_device *dev,
+				int direction,
+				int ep_type,
+				int intr_num,
+				u_int8_t pipeID);
+
+
+/**
+ * libusb_utils_get_bos_desc() - returns the BOS descriptor
+ * @dev: libusb device
+ * @udev: libusb device handle for the opened device
+ * @bos: the bos descriptor
+ *
+ * Returns 0 on success -1 on failure
+ *
+ * This function is relevent only for SS device.
+ */
+int libusb_utils_get_bos_desc(struct libusb_device *dev,
+		   struct libusb_device_handle *udev,
+		   struct libusb_bos_descriptor *bos);
+
+/**
+ * libusb_utils_init() - initializes the libusb
+ *
+ * This function initializes the libusb and gets the list of devices.
+ * The function returns the number of devices
+ */
+int libusb_utils_init(void);
+
+/**
+ * libusb_utils_exit() - un-inits the libusb
+ *
+ * This function un-inits the libusb and frees the device list
+ */
+void libusb_utils_exit(void);
+
diff --git a/tools/usb/unittests/usb/ss_expected_desc.h b/tools/usb/unittests/usb/ss_expected_desc.h
new file mode 100644
index 0000000..36c2e74
--- /dev/null
+++ b/tools/usb/unittests/usb/ss_expected_desc.h
@@ -0,0 +1,291 @@
+/*
+ * ss_expected_desc.h - Expected descriptors when opperation in SS mode
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include "libusb_utils.h"
+
+extern "C" {
+#include <linux/usb/ch9.h>
+}
+
+/*
+ * Device capability type codes. Table 9-11 from USB 3.0 spec
+ * This should be defined in ch9.h but is not. Untill then we
+ * define it here
+ */
+#define	USB_CAP_TYPE_USB20_EXTENSION	0x02
+#define	USB_CAP_TYPE_SUPERSPEED_USB	0x03
+#define	USB_CAP_TYPE_CONTAINER_ID	0x04
+
+
+/* This is the expected value for the SS device descriptor */
+struct libusb_device_descriptor ss_device_descriptor = {
+	18,			/* bLength; */
+	LIBUSB_DT_DEVICE,	/* bDescriptorType */
+	0x0300,			/* bcdUSB */
+	2,			/* bDeviceClass = LIBUSB_CLASS_COMM */
+	0,			/* bDeviceSubClass */
+	0,			/* bDeviceProtocol */
+	0x09,			/* bMaxPacketSize0 */
+	0x0525,			/* idVendor: May be different! */
+	0xa4a7,			/* idProduct: May be different! */
+	0,			/* bcdDevice. TODO: update */
+	0,			/* iManufacturer. May be different! */
+	1,			/* iProduct. May be different! */
+	2,			/* iSerialNumber. May be different!*/
+	1			/* bNumConfigurations */
+};
+
+/* This is the expected value for the SS device zero interface descriptor */
+struct libusb_interface_descriptor ss_zero_intr_descriptor = {
+	9,			/* bLength */
+	LIBUSB_DT_INTERFACE,	/* bDescriptorType */
+	0,			/* bInterfaceNumber */
+	0,			/* bAlternateSetting */
+	1,			/* bNumEndpoints */
+	LIBUSB_CLASS_COMM,	/* bInterfaceClass. May be different */
+	0,			/* bInterfaceSubClass. Should be different */
+	0,			/* bInterfaceProtocol. Should be different */
+	0,			/* iInterface. Should be different */
+	NULL,			/* endpoint */
+	NULL,			/* extra */
+	NULL			/* extra_length */
+};
+
+/* This is the expected value for the SS device interface descriptor */
+struct libusb_interface_descriptor ss_intr_descriptor = {
+	9,			/* bLength */
+	LIBUSB_DT_INTERFACE,	/* bDescriptorType */
+	1,			/* bInterfaceNumber */
+	0,			/* bAlternateSetting */
+	2,			/* bNumEndpoints */
+	LIBUSB_CLASS_DATA,	/* bInterfaceClass. May be different */
+	0,			/* bInterfaceSubClass. Should be different */
+	0,			/* bInterfaceProtocol. Should be different */
+	0,			/* iInterface. Should be different */
+	NULL,			/* endpoint */
+	NULL,			/* extra */
+	NULL			/* extra_length */
+};
+
+
+/* This is the expected value for the SS device BULK OUT endpoint descriptor */
+struct libusb_endpoint_descriptor ss_bulk_out_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_OUT,	/* bEndpointAddress */
+	2,			/*
+				 * bmAttributes:Transfer Type	Bulk
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	1024,			/* wMaxPacketSize */
+	0,			/* bInterval */
+	0,			/* bRefresh; Not used */
+	0,			/* bSynchAddress; Not used */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/*
+ * This is the expected (default) value for the SS device BULK OUT endpoint
+ * companion descriptor: bursting is not supported streaming is not supported
+ */
+struct libusb_ss_ep_comp_descriptor ss_bulk_out_ep_comp_desc = {
+	6,			/* bLength */
+	LIBUSB_DT_SS_ENDPOINT_COMP,/* bDescriptorType */
+	0,			/* bMaxBurst */
+	0,			/* bmAttributes */
+	0			/* wBytesPerInterval */
+};
+
+
+/* This is the expected value for the SS device BULK IN endpoint descriptor */
+struct libusb_endpoint_descriptor ss_bulk_in_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_IN,	/* bEndpointAddress */
+	2,			/*
+				 * bmAttributes:Transfer Type	Bulk
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	1024,			/* wMaxPacketSize */
+	0,			/* bInterval */
+	0,			/* bRefresh. Not used since not audio device*/
+	0,			/* bSynchAddress. Not used */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/*
+ * This is the expected (default) value for the SS device BULK IN endpoint
+ * companion descriptor: bursting is not supported, streaming is not supported
+ */
+struct libusb_ss_ep_comp_descriptor ss_bulk_in_ep_comp_desc = {
+	6,			/* bLength */
+	LIBUSB_DT_SS_ENDPOINT_COMP,/* bDescriptorType */
+	0,			/* bMaxBurst */
+	0,			/* bmAttributes */
+	0			/* wBytesPerInterval */
+};
+
+/* This is the expected value for the SS device INTERRUPT endpoint descriptor */
+struct libusb_endpoint_descriptor ss_intr_ep_desc = {
+	7,			/* bLength */
+	LIBUSB_DT_ENDPOINT,	/* bDescriptorType */
+	LIBUSB_ENDPOINT_IN,	/* bEndpointAddress */
+	3,			/*
+				 * bmAttributes:Transfer Type	Interrupt
+				 *		Synch Type	None
+				 *		Usage Type	Data
+				 */
+	0xa,			/* wMaxPacketSize */
+	9,			/* bInterval */
+	0,			/* bRefresh. Not used since not audio device*/
+	0,			/* bSynchAddress. */
+	NULL,			/* ep_comp */
+	NULL,			/* extra */
+	0			/* extra_length */
+};
+
+/*
+ * This is the expected (default) value for the SS device INTERRUPT endpoint
+ * companion descriptor: bursting is not supported, streaming is not supported
+ */
+struct libusb_ss_ep_comp_descriptor ss_intr_ep_comp_desc = {
+	6,			/* bLength */
+	LIBUSB_DT_SS_ENDPOINT_COMP,/* bDescriptorType */
+	0,			/* bMaxBurst */
+	0,			/* bmAttributes */
+	0xa			/* wBytesPerInterval */
+};
+
+/* This is the expected (default) value for the SS device BOS descriptor */
+struct libusb_bos_descriptor ss_bos_desc = {
+	5,			/* bLength */
+	USB_DT_BOS,		/* bDescriptorType */
+	22,			/* wTotalLength */
+	2,			/* bNumDeviceCaps */
+	NULL,			/* usb_ext_cap */
+	NULL			/* ss_usb_cap */
+};
+
+/*
+ * This is the expected (default) value for the SS device USB 2.0 Extension
+ * descriptor
+ */
+struct libusb_usb_ext_cap_descriptor ss_usb20_ext_desc = {
+	7,			/* bLength */
+	USB_DT_DEVICE_CAPABILITY,/* bDescriptorType */
+	USB_CAP_TYPE_USB20_EXTENSION,/* bDevCapabilityType */
+	0X02			/* bmAttributes: Support LPM */
+};
+
+/*
+ * This is the expected (default) value for the SS device SuperSpeed USB
+ * Capability descriptor: LTM not capble
+ */
+struct libusb_ss_usb_cap_descriptor ss_usb_capability_desc = {
+	10,			/* bLength */
+	USB_DT_DEVICE_CAPABILITY,/* bDescriptorType */
+	USB_CAP_TYPE_SUPERSPEED_USB,/* bDevCapabilityType */
+	0,			/* bmAttributes */
+	0x0f,			/* wSpeedSupported */
+	0x01,			/* bFunctionalitySupport */
+	1,			/* bU1devExitLat */
+	500			/* bU2DevExitLat */
+};
+
+
+/*
+ * Expected returned data values for the SS GET_STATUS tests
+ * (dummy_hcd configuration..)
+ */
+
+/* Expected result is 0x0001 - that means that only self-powered is enabled */
+unsigned char ss_get_status_default_device_expected[2] = { 0x01, 0x00};
+
+/* Expected result is 0x0005 - that means that self-powered, &U1 are enabled */
+unsigned char ss_get_status_U1_enabled_device_expected[2] = { 0x05, 0x00};
+
+/* Expected result is 0x0009 - that means that self-powered, & U2 are enabled */
+unsigned char ss_get_status_U2_enabled_device_expected[2] = { 0x09, 0x00};
+
+/* Expected result is 0x0011 - that means that self-powered & LTM are enabled */
+unsigned char ss_get_status_LTM_enabled_device_expected[2] = { 0x11, 0x00};
+
+/*
+ * Expected result is 0x0000 - that means that this interface is
+ * Remote-wakeup capable
+ */
+unsigned char ss_get_status_default_interface_expected[2] = { 0x00, 0x00};
+
+/* Expected result is 0x0001 - that means that this ep is halt enabled */
+unsigned char ss_get_status_halt_enabled_ep_expected[2] = { 0x01, 0x00};
+
+/* Expected result is 0x0000 - that means that this ep is not halted */
+unsigned char ss_get_status_default_ep_expected[2] = { 0x00, 0x00};
+
+/*
+ * Expected result is 0x0001 - that means that this interface's low power
+ * was enabled (lsb)
+ * In the case of g_zero due to the stub functionality, the
+ * expected value is 0x0000.
+ */
+unsigned char ss_get_status_suspend_low_power_interface_expected[2] = {
+	0x00, 0x00};
+
+/*
+ * Expected result is 0x0001 - that means that this interface's is remote
+ * wake up capable (bit #1)
+ */
+unsigned char ss_get_status_suspend_remote_wu_cap_interface_expected[2] = {
+	0x01, 0x00};
+
+/*
+ * Expected result is 0x0002 - that means that this interface's remote wake up
+ * was enabled (bit #2)
+ */
+unsigned char ss_get_status_suspend_remote_wu_en_interface_expected[2] = {
+	0x02, 0x00};
+
+/*
+* Expected result is 0x0003 - that means that this interface's is remote
+* wake up capable (bit #1) and was enabled (bit #2)
+*/
+unsigned char ss_get_status_suspend_remote_wu_en_cap_interface_expected[2] = {
+	0x03, 0x00};
diff --git a/tools/usb/unittests/usb/streams_tests.cc b/tools/usb/unittests/usb/streams_tests.cc
new file mode 100644
index 0000000..5954bdb
--- /dev/null
+++ b/tools/usb/unittests/usb/streams_tests.cc
@@ -0,0 +1,243 @@
+/*
+ * streams_tests.h - USB3 streams tests
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <linux/usb/ch9.h>
+
+#include "ut_config.h"
+#include "libusb_utils.h"
+#include "composite_tests.h"
+
+/**
+ * cb_transfer_complete() - Callback supplied to
+ * libusb_fill_bulk_transfer. The callback increases a counter
+ * implemented by the transfer's user_data variable.
+ * @transfer: the transfer that was cpmpleted
+ *
+ */
+static void cb_transfer_complete(struct libusb_transfer *transfer)
+{
+	int *completed = (int*)transfer->user_data;
+	fprintf(stderr, "cb_transfer_complete, user_data is %d \n", *completed);
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
+		fprintf(stderr, "cb_transfer_complete with error %d\n",
+			transfer->status);
+	else
+		(*completed)++;
+}
+
+/**
+ * test_streams_bulk_loopback() - Initiate N bulk OUT transfers
+ * on N streams, and verify reception on bulk IN EP.
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to send
+ * @interface_id: interface id to run the test on
+ * @num_streams: number of streams
+ *
+ * Returns 0 on sucsess -1 for failure
+ */
+int test_streams_bulk_loopback(libusb_device *dev, int data_size,
+			 int interface_id, int num_streams)
+{
+	struct libusb_device_handle *udev;
+	struct libusb_endpoint_descriptor *out_ep, *in_ep;
+	unsigned char *data_out[num_streams];
+	unsigned char *data_in[num_streams];
+	int ret, i, j;
+	struct libusb_transfer *transfer[num_streams];
+	int completed = 0;
+	unsigned int eps = 0;
+
+	if (!dev)
+		return -1;
+
+	if (libusb_open(dev, &udev)) {
+		printf("Couldn't open device\n");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	for (j = 0; j < num_streams; j++) {
+		transfer[j] = libusb_alloc_transfer(0);
+		if (!transfer[j]) {
+			printf("Couldn't alloc transfer\n");
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	for (j = 0; j < num_streams; j++) {
+		data_out[j] = (unsigned char *)malloc(data_size+10);
+		data_in[j] = (unsigned char *)malloc(data_size+10);
+	}
+
+
+	/* Fill in the OUT data buffer with a pattern corresponding to stream_id */
+	for (j = 0; j < num_streams; j++)
+		for (i = 0; i < data_size; i++)
+		{
+			data_out[j][i] = j+1;
+			data_in[j][i] = 0;
+		}
+
+	/* We should reset the gadget so it would expect stream IDs starting
+	   from 1 */
+	if (libusb_reset_device(udev) < 0)
+	{
+		printf("Couldn't reset device");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	out_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_OUT,
+			     LIBUSB_TRANSFER_TYPE_BULK,
+			     interface_id, PIPE_ID_UNDEF);
+
+	if (!in_ep) {
+		printf("Didn't find BULK OUT endpoint!\n");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	in_ep = libusb_utils_get_ep_desc(dev, LIBUSB_ENDPOINT_IN,
+				 LIBUSB_TRANSFER_TYPE_BULK,
+				 interface_id, PIPE_ID_UNDEF);
+
+	if (!in_ep) {
+		printf("Didn't find BULK IN endpoint!\n");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	eps |= (1 << (in_ep->bEndpointAddress & LIBUSB_ENDPOINT_ADDRESS_MASK));
+	eps |= (0x10000 << (out_ep->bEndpointAddress & LIBUSB_ENDPOINT_ADDRESS_MASK));
+
+	printf("Allocting streams for ep map %d\n", eps);
+
+	/* Allocate streams (Current implementation allocates 256 streams) */
+	if (libusb_alloc_streams(udev, eps) < 0)
+	{
+		printf("Codn't alloc streams for OUT EP\n");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	for (j = 0; j < num_streams; j++) {
+		libusb_fill_bulk_transfer(transfer[j], udev, out_ep->bEndpointAddress,
+			data_out[j], data_size, cb_transfer_complete, &completed,
+			BULK_TRANSFERR_TIMEOUT);
+		transfer[j]->flags = LIBUSB_TRANSFER_SHORT_NOT_OK
+		 | LIBUSB_TRANSFER_FREE_TRANSFER;
+	    transfer[j]->stream_id = j+1;
+		if (libusb_submit_transfer(transfer[j]) < 0) {
+			printf("Codn't submit transfer\n");
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	while (completed < num_streams)
+		libusb_handle_events(NULL);
+
+	for (j = 0; j < num_streams; j++) {
+		if (transfer[j]->actual_length != data_size) {
+			printf("The number of bytes actually transferred (%d) != "
+				   "data size (%d)", transfer[j]->actual_length, data_size);
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	completed = 0;
+
+	for (j = 0; j < num_streams; j++) {
+		transfer[j] = libusb_alloc_transfer(0);
+		if (!transfer[j]) {
+			printf("Couldn't alloc transfer\n");
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	for (j = 0; j < num_streams; j++) {
+		libusb_fill_bulk_transfer(transfer[j], udev, in_ep->bEndpointAddress,
+			data_in[j], data_size, cb_transfer_complete, &completed,
+			BULK_TRANSFERR_TIMEOUT);
+		transfer[j]->flags = LIBUSB_TRANSFER_SHORT_NOT_OK
+		 | LIBUSB_TRANSFER_FREE_TRANSFER;
+		transfer[j]->stream_id = j+1;
+		if (libusb_submit_transfer(transfer[j]) < 0) {
+			printf("Codn't submit transfer\n");
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	while (completed < num_streams)
+		libusb_handle_events(NULL);
+
+	for (j = 0; j < num_streams; j++) {
+		if (transfer[j]->actual_length != data_size) {
+			printf("The number of bytes actually transferred (%d) != "
+				"data size (%d)\n", transfer[j]->actual_length, data_size);
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+		if (data_in[j][0] != transfer[j]->stream_id) {
+			printf("Epected data on stream is %d instead of %d\n", data_in[j][0],
+				transfer[j]->stream_id);
+			ret = -1;
+			goto test_bulk_loopback_done;
+		}
+	}
+
+	if (libusb_free_streams(udev, eps) < 0)
+	{
+		printf("Codn't free streams for OUT EP\n");
+		ret = -1;
+		goto test_bulk_loopback_done;
+	}
+
+	ret = 0;
+test_bulk_loopback_done:
+	libusb_close(udev);
+
+	for (j = 0; j < num_streams; j++) {
+		free(data_out[j]);
+		free(data_in[j]);
+	}
+
+	return ret;
+}
+
diff --git a/tools/usb/unittests/usb/streams_tests.h b/tools/usb/unittests/usb/streams_tests.h
new file mode 100644
index 0000000..5b1db91
--- /dev/null
+++ b/tools/usb/unittests/usb/streams_tests.h
@@ -0,0 +1,51 @@
+/*
+ * streams_tests.h - USB3 streams tests
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef STREAMS_TESTS_H
+#define STREAMS_TESTS_H
+
+#include <linux/kernel.h>
+#include "libusb_utils.h"
+
+/**
+ * test_streams_bulk_loopback() - Initiate N bulk OUT transfers
+ * on N streams, and verify reception on bulk IN EP.
+ * @dev: libusb device to test
+ * @data_size: size of the data buffer to send
+ * @interface_id: interface id to run the test on
+ * @num_streams: number of streams
+ *
+ * Returns 0 on sucsess -1 for failure
+ */
+int test_streams_bulk_loopback(libusb_device *dev, int data_size,
+			 int interface_id, int num_streams);
+
+#endif /*STREAMS_TESTS_H*/
diff --git a/tools/usb/unittests/usb/usb_devel_mode.cc b/tools/usb/unittests/usb/usb_devel_mode.cc
new file mode 100644
index 0000000..159a99b
--- /dev/null
+++ b/tools/usb/unittests/usb/usb_devel_mode.cc
@@ -0,0 +1,185 @@
+/*
+ * This file implements the option of running the Unit Test FW in
+ * development mode.
+ *
+  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "usb_devel_mode.h"
+#include "UASP_tests.h"
+
+/* This enum defines the tests that can be run in development mode */
+enum devel_commands{
+	RUN_ALL_TESTS = 1,
+	SEND_SC_INQUIRY,
+	SEND_SC_REQUEST_SENSE,
+	TEST_UNIT_READY,
+	READ_CAPACITY,
+	MODE_SENSE,
+	MODE_SENSE10,
+	ALLOW_MEDIUM_REMOVAL,
+	READ_6,
+	READ_10,
+	READ_12,
+	WRITE_6,
+	WRITE_10,
+	WRITE_12,
+	WRITE10_HUGE,
+	READ_FORMAT_CAPACITIES,
+	TEST_START_STOP_UNIT,
+	TEST_VERIFY,
+	TEST_SYNC_CACHE,
+	TEST_TM_RESET_LUN,
+	TEST_TM_ABORT_TASK,
+	TEST_TM_ABORT_TASK_SET,
+	TEST_TM_RESET_NEXUS,
+	TEST_QUERY_ASYNC_EVENT,
+	TEST_QUERY_TASK,
+	TEST_QUERY_TASK_SET,
+	TEST_TM_TAG_OVERLAPP,
+	TEST_CMD_TAG_OVERLAPP,
+	ILEGAL_CMD  /* Should be the last one! */
+};
+
+struct exec_cmd {
+    int (*func)(struct libusb_device *dev);
+    char test_name[100];
+};
+
+/**
+ * print_mem() - dump memory in the given location
+ * @buf: pointer to the memory buffer to print
+ * @size: size of buffer to print
+ *
+ */
+void print_mem(unsigned char *buf, int size)
+{
+	int i;
+	printf("Memory dump at %x:\n	", buf);
+	for (i = 0; i < size; i++) {
+		printf(" 0x%02x", buf[i]);
+		if (!(i % 24))
+			printf("\n	");
+	}
+	printf("\n");
+}
+
+static int run_all_UASP_tests(struct libusb_device *dev);
+static struct exec_cmd cmd_arr[] = {
+	{run_all_UASP_tests, "All UASP Tests"},
+	{exec_send_inquiry, "INQUIRY CMD-IU (OpCode = 0x12)"},
+	{exec_send_request_sense, "REQUEST_SENSE CMD-IU (OpCode = 0x03)"},
+	{exec_test_unit_ready, "TEST_UNIT_READY (OpCode = 0x00)"},
+	{exec_send_read_capacity, "READ_CAPACITY (OpCode = 0x25)"},
+	{exec_send_mode_sense, "MODE_SENSE6 (OpCode = 0x01)"},
+	{exec_send_mode_sense10, "MODE_SENSE10 (OpCode = 0x5a)"},
+	{exec_send_prevent_allow_removal,
+		"ALLOW_MEDIUM_REMOVAL (OpCode = 0x1e)"},
+	{exec_test_read6, "READ_6 (OpCode = 0x08)"},
+	{exec_test_read10, "READ_10 (OpCode = 0x28)"},
+	{exec_test_read12, "READ_12 (OpCode = 0xa8)"},
+	{exec_test_write6, "WRITED_6 (OpCode = 0x0a)"},
+	{exec_test_write10, "WRITE_10 (OpCode = 0x2a)"},
+	{exec_test_write12, "WRITE_12 (OpCode = 0xaa)"},
+	{exec_test_write_huge, "WRITE10 with huge data"},
+	{exec_test_read_format_capacities,
+		"READ_FORMAT_CAPACITIES (OpCode = 0x23)"},
+	{exec_test_start_stop, "START_STOP_UNIT (OpCode = ox1b)"},
+	{exec_test_verify, "VERIFY (OpCode = 0x2f)"},
+	{exec_test_synchronize_cache, "SYNCHRONIZE CACHE (OpCode = 0x35)"},
+	{exec_test_tm_reset_lun, "TM LOGICAL UNIT RESET (Code = 0x08)"},
+	{exec_test_tm_abort_task, "TM ABORT TASK (Code = 0x01)"},
+	{exec_test_tm_abort_task_set, "TM ABORT TASK SET (Code = 0x02)"},
+	{exec_test_tm_reset_nexus, "TM RESET NEXUS (Code = 0x10)"},
+	{exec_test_tm_query_async_ev, "TM QUERY ASYNC EVENT (Code = 0x82)"},
+	{exec_test_tm_query_task, "TM QUERY TASK (Code = 0x80)"},
+	{exec_test_tm_query_task_set, "TM QUERY TASK SET (Code = 0x81)"},
+	{exec_test_tm_overlapped_tag, "Test TM IU Tag Overlapping"},
+	{exec_test_cmd_overlapped_tag, "Test CMD IU Tag Overlapping"},
+};
+
+static int run_all_UASP_tests(struct libusb_device *dev)
+{
+	int i, rc;
+	for (i = 1; i < ILEGAL_CMD -1; i++) {
+		printf("\n\n Running Test %s:\n", cmd_arr[i].test_name);
+		rc = cmd_arr[i].func(dev);
+		if (rc) {
+			printf("\n Test #%i (%s) Failed!\n", i+1,
+			       cmd_arr[i].test_name);
+			return rc;
+		}
+		sleep(1);
+	}
+	return rc;
+}
+
+int run_in_devel_mode(struct libusb_device *dev)
+{
+	int choice = 0;
+	int ret_val = 0;
+	int i = 0;
+
+	printf("\n\n\n---------------------------------------------"
+	       "---------------------------------------------------\n");
+
+	printf("Choose command to perform:\nUASP commands:\n"
+	       "	0. Exit\n");
+	for (i = 0; i < ILEGAL_CMD - 1; i++)
+		printf("	%d. Run %s test\n", i+1, cmd_arr[i].test_name);
+	printf("Enter your choice: ");
+	(void)scanf("%d",&choice);
+
+	while ((choice > 0) && (choice < ILEGAL_CMD)){
+		if (cmd_arr[choice-1].func)
+			ret_val = cmd_arr[choice-1].func(dev);
+		else
+			printf("Sorry, %d command is not yet implemented\n",
+			       choice);
+
+		printf("\n\n\n---------------------------------------------"
+		       "---------------------------------------------------\n");
+
+		printf("Choose command to perform:\nUASP commands:\n"
+		       "	0. Exit\n");
+		for (i = 0; i < ILEGAL_CMD - 1; i++)
+			printf("	%d. Run %s test\n", i+1,
+				cmd_arr[i].test_name);
+		printf("Enter your choice: ");
+		scanf("%d",&choice);
+	}
+
+	return ret_val;
+}
diff --git a/tools/usb/unittests/usb/usb_devel_mode.h b/tools/usb/unittests/usb/usb_devel_mode.h
new file mode 100644
index 0000000..03d9603
--- /dev/null
+++ b/tools/usb/unittests/usb/usb_devel_mode.h
@@ -0,0 +1,50 @@
+/*
+ * This file defines the option of running the Unit Test FW in
+ * development mode.
+ *
+  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _USB_DEVEL_MODE_H
+#define _USB_DEVEL_MODE_H
+
+#include "libusb_utils.h"
+
+int run_in_devel_mode(struct libusb_device *dev);
+
+
+/**
+ * print_mem() - dump memory in the given location
+ * @buf: pointer to the memory buffer to print
+ * @size: size of buffer to print
+ *
+ */
+void print_mem(unsigned char *buf, int size);
+
+#endif /*_USB_DEVEL_MODE_H*/
diff --git a/tools/usb/unittests/usb/usb_tests.cc b/tools/usb/unittests/usb/usb_tests.cc
new file mode 100644
index 0000000..bbbdbf2
--- /dev/null
+++ b/tools/usb/unittests/usb/usb_tests.cc
@@ -0,0 +1,651 @@
+/*
+ * This file defines the unit tests for a SuperSpeed/HighSpeed USB device.
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <limits.h>
+#include "g_serial_tests.h"
+#include "UASP_tests.h"
+#include "streams_tests.h"
+#include "composite_tests.h"
+#include "libusb_utils.h"
+#include <gtest/gtest.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <argp.h>
+#include "ut_config.h"
+#include "usb_tests.h"
+
+/**
+ * If this flag is set to 1, debug information wil be printed. Received as
+ * input parameter from user
+ */
+int ut_debug = 0;
+
+/**
+ * usb_tests_params - defines the tests parameters
+ * @busnum: the connected usb device bus number
+ * @devnum: the connected usb device number
+ * @vendorid: the connected usb device Vendor ID
+ * @productid: the connected usb deviceProduct ID
+ * @dev: the libusb devise to run the tests on
+ * @dev_speed: The speed of the connected usb device
+ * @num_expected_strms_in_ep: number of expected streams for IN EP's
+ *	ep_comp desc
+ * @num_expected_strms_out_ep: number of expected streams for OUT EP's
+ *	ep_comp desc
+ * @intr_num: number of the interface to run the test on
+ * @devel: Setting this flag to 1 will result in using the UT env for
+ *  	development purposes and none of the test suites will be run
+ * @uasp_dev: Setting this flag to 1 will result in running only the UASP
+ *	test suite
+ * @streams_dev: Setting this flag to 1 will result in running
+ *  only streams tests
+ */
+struct usb_tests_params {
+	int busnum;
+	int devnum;
+	int vendorid;
+	int productid;
+	struct libusb_device *dev;
+	enum usb_device_speed dev_speed;
+	int num_expected_strms_in_ep;
+	int num_expected_strms_out_ep;
+	int intr_num;
+	int devel;
+	int uasp_dev;
+	char gadget_sysfs_path[MAX_STRING_LEN];
+	int streams_dev;
+};
+
+/* Tests parameters */
+static struct usb_tests_params tests_params;
+
+/**
+ * print_params() - This function prints the usb tests parameters
+ * @p:pointer to the usb_tests_params structure
+ *
+ */
+void print_params(struct usb_tests_params *p)
+{
+	printf("busnum    = %d\n"
+	       "devnum    = %d\n"
+	       "vendorid  = %d\n"
+	       "productid = %d\n"
+	       "debug	  = %d\n"
+	       "num_expected_strms_in_ep = %d\n"
+	       "num_expected_strms_out_ep = %d\n"
+	       "interface_number = %d\n"
+	       "devel	  = %d\n"
+	       "uasp_dev	 = %d\n"
+	       "gadget_sysfs_path = %s\n",
+		   "streams_dev	 = %d\n",
+	       p->busnum, p->devnum, p->vendorid, p->productid, ut_debug,
+	       p->num_expected_strms_in_ep, p->num_expected_strms_out_ep,
+	       p->intr_num, p->devel, p->uasp_dev, p->gadget_sysfs_path,
+		   p->streams_dev);
+}
+
+/**
+ * options - Data structures defined for the parameters parsing as
+ * 	described in argp.h
+ *
+ * An array of parameters options to be used by argp to parse the parameters.
+ * The last field of the array should be NULL for terminating the search of
+ * the parameters.
+ */
+static struct argp_option options[] = {
+	/*{name,	key, arg,   flags, doc		group}*/
+	{ "busnum",	1, "integer", 0, "Bus number",	 1 },
+	{ "devnum",	2, "integer", 0, "Device number",1 },
+	{ "productid",	3, "integer", 0, "Product ID",	 2 },
+	{ "vendorid",	4, "integer", 0, "Vendor ID",	 2 },
+	{ "debug",	5, "integer", 0, "Debug Info",	 3 },
+	{ "gtest_output",6,"string",  0, "gtest_output", 3 },
+	{ "num_expected_strms_in_ep",7,"integer",  0,
+		"num_expected_strms for IN EP", 4 },
+	{ "num_expected_strms_out_ep",8,"integer",  0,
+		"num_expected_strms for OUT EP", 4 },
+	{ "interface",	9,  "integer", 0,
+		"interface number to run the tests on", 5},
+	{ "devel",	10, "integer", 0, "Development",  6},
+	{ "uasp_dev",   11, "integer", 0, "Run UASP tests",  6},
+	{ "gadget_sysfs_path", 12, "string", 0, "Gadget SYSFS Path", 6},
+	{ "streams_dev",   13, "integer", 0, "Run streams tests",  6},
+	{0, 0, 0, 0, 0, 0},
+};
+
+/**
+ * parse_opt() - This is an argp parsing function.
+ * @key:
+ * @arg:
+ * @state:
+ *
+ */
+static error_t parse_opt(int key, char *arg, struct argp_state *state)
+{
+	int x;
+	char string[MAX_STRING_LEN];
+
+	struct usb_tests_params *p = (struct usb_tests_params*)state->input;
+	if (arg && key != 12)
+		sscanf(arg, "%i", &x);
+	else if (arg)
+		sscanf(arg, "%s", string);
+
+	switch (key) {
+	case 1:
+		p->busnum = x;
+		break;
+	case 2:
+		p->devnum = x;
+		break;
+	case 3:
+		p->productid = x;
+		break;
+	case 4:
+		p->vendorid = x;
+		break;
+	case 5:
+		ut_debug = x;
+		break;
+	case 7:
+		p->num_expected_strms_in_ep = x;
+		break;
+
+	case 8:
+		p->num_expected_strms_out_ep = x;
+		break;
+	case 9:
+		p->intr_num = x;
+		break;
+	case 10:
+		p->devel = x;
+		break;
+	case 11:
+		p->uasp_dev = x;
+		break;
+	case 12:
+		strcpy(p->gadget_sysfs_path, string);
+		break;
+	case 13:
+		p->streams_dev = x;
+	}
+	return 0;
+}
+
+
+/**
+ * argp - Parsing state.
+ * An argp structure contains a set of options declarations, a function to
+ * deal with parsing one, documentation string, a possible vector of child
+ * argp's, and perhaps a function to filter help output.  When actually
+ * parsing options, getopt is called with the union of all the argp
+ * structures chained together through their CHILD pointers, with conflicts
+ * being resolved in favor of the first occurrence in the chain.
+ *
+ */
+static struct argp argp = { options, parse_opt,
+	"Googletest arguments",		/*args_doc*/
+	"usb tests parameters",		/*doc*/
+	0,				/*children*/
+	0,				/* help_filter*/
+	0				/*argp_domain*/
+};
+
+
+/**
+ * get_dev_speed() - returns the speed of the connected device.
+ *
+ * Return speed of the connected device.
+ * In case of an error return USB_SPEED_UNKNOWN
+ */
+enum usb_device_speed get_dev_speed(void){
+	return tests_params.dev_speed;
+}
+
+/**
+ * This function returns the true if the devel input gflag was
+ * set, meaning none of the test suites should be run.
+ *
+ * Returns bool - the value of tests_params.devel
+ */
+bool is_devel_mode(void)
+{
+	return tests_params.devel;
+}
+
+/**
+ * This function returns the true if the uasp_dev input flag was
+ * set, meaning only the UASP test suite should be run.
+ *
+ * Returns bool - the value of tests_params.uasp_dev
+ */
+bool is_uasp_device(void)
+{
+	return tests_params.uasp_dev;
+}
+
+/**
+ * This function returns the true if the streams_dev input flag
+ * was set, meaning streams tests should be run.
+ *
+ * Returns bool - the value of tests_params.streams_dev
+ */
+bool is_streams_device(void)
+{
+	return tests_params.streams_dev;
+}
+
+/**
+ * get_libusb_dev() - finds and returns the libusb device
+ *
+ * Return pointer to the libusb device or NULL on failier
+ *
+ * This function finds and returns the libusb device according to the input
+ * parameters: either device number and bus number or product id and vendor id
+ *
+ */
+libusb_device *get_libusb_dev(void)
+{
+	if (tests_params.busnum && tests_params.devnum) {
+		tests_params.dev = libusb_utils_get_device_by_num(
+			tests_params.busnum, tests_params.devnum);
+	}
+	else
+		tests_params.dev = libusb_utils_get_device_by_product_vendor(
+			tests_params.vendorid, tests_params.productid);
+	return tests_params.dev;
+}
+
+/**
+ * usb_tests_read_gadget_sysfs_file() - read from gadget sysfs file
+ * @path: path for the gadget sysfs file
+ *
+ * Return the integer read from the file
+ *
+ * This function reads an integer from given gadget sysfs file
+ */
+int usb_tests_read_gadget_sysfs_file(char* path)
+{
+	char filename[MAX_STRING_LEN];
+	FILE* file;
+	ssize_t nread;
+	int data;
+
+	sprintf(filename, "%s%s", tests_params.gadget_sysfs_path, path);
+	file = fopen(filename, "r");
+	if (file == NULL)
+		return -1;
+
+	nread = fscanf(file, "%d", &data);
+	if (nread <= 0)
+		return -1;
+
+	fclose(file);
+	return data;
+}
+
+/**
+ * usb_tests_write_gadget_sysfs_file_int() - writes to gadget sysfs file an
+ * integer value
+ * @path: path for the gadget sysfs file
+ * @value: value to write to the file
+ *
+ * Return 0 for sucsess, -1 for failure
+ *
+ * This function writes an integer from given gadget sysfs file
+ */
+int usb_tests_write_gadget_sysfs_file_int(char* path, int value)
+{
+	char filename[MAX_STRING_LEN];
+	FILE* file;
+	ssize_t nwrite;
+
+	sprintf(filename, "%s%s", tests_params.gadget_sysfs_path, path);
+	file = fopen(filename, "w");
+	if (file == NULL)
+		return -1;
+
+	nwrite = fprintf(file, "%d", value);
+	if (nwrite != 1)
+		return -1;
+
+	fclose(file);
+	return 0;
+}
+
+/**
+ * usb_tests_write_gadget_sysfs_file_str() - writes to gadget
+ * sysfs file a string value
+ * @path: path for the gadget sysfs file
+ * @value: value to write to the file
+ *
+ * Return 0 for sucsess, -1 for failure
+ *
+ * This function writes an integer from given gadget sysfs file
+ */
+int usb_tests_write_gadget_sysfs_file_str(char* path, char *value)
+{
+	char filename[MAX_STRING_LEN];
+	FILE* file;
+	ssize_t nwrite;
+
+	sprintf(filename, "%s%s", tests_params.gadget_sysfs_path, path);
+	file = fopen(filename, "w");
+	if (file == NULL)
+		return -1;
+
+	nwrite = fprintf(file, "%s", value);
+	if (nwrite != strlen(value))
+		return -1;
+
+	fclose(file);
+	return 0;
+}
+
+/**
+ * usb_tests_init() - init the libusb utility to be used by the tests.
+ * @argc: number of command line arguments
+ * @argv: command line arguments array
+ *
+ * Return 0 for success, -1 for failure
+ *
+ * This function initializes the libusb utility to be used by the tests.
+ * This function should be called prior to any libusb functions.
+ */
+int usb_tests_init(int argc, char **argv)
+{
+	int ret_val = 0;
+	memset ((void*)&tests_params, 0, sizeof(tests_params));
+
+	ret_val = argp_parse(&argp, argc, argv, 0, 0, &tests_params);
+	/* Verify input parameters */
+	if ((!tests_params.busnum || !tests_params.devnum) &&
+	    (!tests_params.productid || !tests_params.vendorid)) {
+		printf("Missing input! You must supply either busnum and "
+		       "devnum, or productid and vendorid\n");
+		return -1;
+	}
+
+	libusb_utils_init();
+
+	(void)get_libusb_dev();
+	if (!tests_params.dev) {
+		printf("Wrong input! Couldn't allocate device\n");
+		libusb_utils_exit();
+		return -1;
+	}
+
+	if (!ut_debug)
+		libusb_set_debug(NULL,0);
+
+	tests_params.dev_speed = (enum usb_device_speed)
+					libusb_get_dev_speed(tests_params.dev);
+
+	if (strlen(tests_params.gadget_sysfs_path) == 0)
+		strcpy(tests_params.gadget_sysfs_path,
+		       DEFAULT_GADGET_SYSFS_PATH);
+
+
+	return 0;
+}
+
+/**
+ * usb_tests_exit() - exit the libusb utility.
+ */
+void usb_tests_exit()
+{
+	libusb_utils_exit();
+}
+
+/* HS test cases */
+
+/* HS Descriptors tests */
+TEST(CompositeHSTests, test_hs_descriptors) {
+	EXPECT_EQ(0,test_hs_descriptors(tests_params.dev));
+}
+
+/* HS GET_STATUS tests */
+TEST(CompositeHSTests, test_hs_get_status_default_device) {
+	EXPECT_EQ(0, test_hs_get_status_default_device(tests_params.dev));
+}
+
+TEST(CompositeHSTests, test_hs_get_status_default_interface) {
+	EXPECT_EQ(0,
+		  test_hs_get_status_default_interface(tests_params.dev,
+						  tests_params.intr_num));
+}
+
+TEST(CompositeHSTests, test_hs_get_status_default_ep) {
+	EXPECT_EQ(0, test_hs_get_status_default_ep(tests_params.dev,
+						   tests_params.intr_num));
+}
+
+/* HS SET_FEATURE tests */
+TEST(CompositeHSTests, test_hs_set_feature_suspend_interface) {
+	EXPECT_EQ(0, test_hs_set_feature_suspend_interface(tests_params.dev,
+						   tests_params.intr_num));
+}
+
+TEST(CompositeHSTests, test_hs_set_feature_halt_ep) {
+	EXPECT_EQ(0, test_hs_set_feature_halt_ep(tests_params.dev,
+						 tests_params.intr_num));
+}
+
+/* SS test cases */
+
+/* SS Descriptors tests */
+TEST(CompositeSSTests, test_ss_descriptors) {
+	EXPECT_EQ(0, test_ss_descriptors(tests_params.dev,
+				 tests_params.num_expected_strms_in_ep,
+				 tests_params.num_expected_strms_out_ep));
+}
+
+/* SS GET_STATUS tests */
+TEST(CompositeSSTests, test_ss_get_status_default_device) {
+	EXPECT_EQ(0, test_ss_get_status_default_device(tests_params.dev));
+}
+
+TEST(CompositeSSTests, test_ss_get_status_default_interface) {
+	EXPECT_EQ(0,
+		  test_ss_get_status_default_interface(tests_params.dev,
+						  tests_params.intr_num));
+}
+
+TEST(CompositeSSTests, test_ss_get_status_default_ep) {
+	EXPECT_EQ(0, test_ss_get_status_default_ep(tests_params.dev,
+						   tests_params.intr_num));
+}
+
+/* SS SET_FEATURE tests */
+
+TEST(CompositeSSTests, test_ss_set_feature_u1_device) {
+	EXPECT_EQ(0, test_ss_set_feature_u1_device(tests_params.dev));
+}
+
+TEST(CompositeSSTests, test_ss_set_feature_u2_device) {
+	EXPECT_EQ(0, test_ss_set_feature_u2_device(tests_params.dev));
+}
+
+TEST(CompositeSSTests, test_ss_set_feature_ltm_device) {
+	EXPECT_EQ(0, test_ss_set_feature_ltm_device(tests_params.dev));
+}
+
+TEST(CompositeSSTests, test_ss_set_feature_halt_ep) {
+	EXPECT_EQ(0, test_ss_set_feature_halt_ep(tests_params.dev,
+						 tests_params.intr_num));
+}
+
+TEST(CompositeSSTests, test_ss_set_feature_suspend_low_power_interface) {
+	EXPECT_EQ(0, test_ss_set_feature_suspend_low_power_interface(
+		tests_params.dev, tests_params.intr_num));
+}
+
+TEST(CompositeSSTests, test_ss_set_feature_suspend_remote_wakeup_interface) {
+	EXPECT_EQ(0, test_ss_set_feature_suspend_remote_wakeup_interface(
+		tests_params.dev, tests_params.intr_num));
+}
+
+
+/* General test cases */
+TEST(SerialTests, test_single_bulk_in){
+	EXPECT_EQ(0, test_single_bulk_in(tests_params.dev, 40,
+					 tests_params.intr_num));
+}
+
+TEST(SerialTests, test_single_bulk_out){
+	EXPECT_EQ(0, test_single_bulk_out(tests_params.dev, 40,
+					  tests_params.intr_num));
+}
+
+/* Streams test cases*/
+TEST(StreamsTests, test_streams_bulk_loopback) {
+	EXPECT_EQ(0, test_streams_bulk_loopback(tests_params.dev, 40,
+		tests_params.intr_num, 8));
+}
+
+/* This test should be the last one since it changes the libusb device */
+TEST(DummyTests, test_connect_disconnect) {
+	EXPECT_EQ(0, test_connect_disconnect(tests_params.dev,
+				tests_params.dev_speed,
+				tests_params.num_expected_strms_in_ep,
+				tests_params.num_expected_strms_out_ep));
+}
+
+/* UASP Test cases */
+TEST(UASPTests, exec_send_inquiry) {
+	EXPECT_EQ(0, exec_send_inquiry(tests_params.dev));
+}
+
+TEST(UASPTests, exec_send_request_sense) {
+	EXPECT_EQ(0, exec_send_request_sense(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_unit_ready) {
+	EXPECT_EQ(0, exec_test_unit_ready(tests_params.dev));
+}
+
+
+TEST(UASPTests, exec_send_read_capacity) {
+	EXPECT_EQ(0, exec_send_read_capacity(tests_params.dev));
+}
+
+TEST(UASPTests, exec_send_mode_sense) {
+	EXPECT_EQ(0, exec_send_mode_sense(tests_params.dev));
+}
+
+TEST(UASPTests, exec_send_mode_sense10) {
+	EXPECT_EQ(0, exec_send_mode_sense10(tests_params.dev));
+}
+
+TEST(UASPTests, exec_send_prevent_allow_removal) {
+	EXPECT_EQ(0, exec_send_prevent_allow_removal(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_read6) {
+	EXPECT_EQ(0, exec_test_read6(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_read10) {
+	EXPECT_EQ(0, exec_test_read10(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_read12) {
+	EXPECT_EQ(0, exec_test_read12(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_write6) {
+	EXPECT_EQ(0, exec_test_read12(tests_params.dev));
+}
+TEST(UASPTests, exec_test_write10) {
+	EXPECT_EQ(0, exec_test_read12(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_write12) {
+	EXPECT_EQ(0, exec_test_read12(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_write_huge) {
+	EXPECT_EQ(0, exec_test_write_huge(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_read_format_capacities){
+	EXPECT_EQ(0, exec_test_read_format_capacities(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_start_stop){
+	EXPECT_EQ(0, exec_test_start_stop(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_verify){
+	EXPECT_EQ(0, exec_test_verify(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_synchronize_cache){
+	EXPECT_EQ(0, exec_test_synchronize_cache(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_reset_lun){
+	EXPECT_EQ(0, exec_test_tm_reset_lun(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_abort_task){
+	EXPECT_EQ(0, exec_test_tm_abort_task(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_abort_task_set){
+	EXPECT_EQ(0, exec_test_tm_abort_task_set(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_reset_nexus){
+	EXPECT_EQ(0, exec_test_tm_reset_nexus(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_query_async_ev){
+	EXPECT_EQ(0, exec_test_tm_query_async_ev(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_query_task){
+	EXPECT_EQ(0, exec_test_tm_query_task(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_query_task_set){
+	EXPECT_EQ(0, exec_test_tm_query_task_set(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_tm_overlapped_tag){
+	EXPECT_EQ(0, exec_test_tm_overlapped_tag(tests_params.dev));
+}
+
+TEST(UASPTests, exec_test_cmd_overlapped_tag){
+	EXPECT_EQ(0, exec_test_cmd_overlapped_tag(tests_params.dev));
+}
+
diff --git a/tools/usb/unittests/usb/usb_tests.h b/tools/usb/unittests/usb/usb_tests.h
new file mode 100644
index 0000000..0d1b2ba
--- /dev/null
+++ b/tools/usb/unittests/usb/usb_tests.h
@@ -0,0 +1,146 @@
+/*
+ * usb_tests.h - general usb tests functions
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef USB_TEST_H
+#define USB_TEST_H
+
+extern "C" {
+#include <linux/usb/ch9.h>
+}
+
+#include "libusb.h"
+
+#define GADGET_SUSPENED_SYSFS_PATH "suspened"
+#define GADGET_ZERO_FUNC_SUSPENDED_SYSFS_PATH "sourcesink/func_suspend"
+#define ZERO_GADGET_ZERO_FUNC_WAKEUP_CAPABLE_SYSFS_PATH \
+	"sourcesink/func_wakeup_capable"
+#define ZERO_GADGET_ZERO_FUNC_WAKEUP_ENABLED_SYSFS_PATH \
+	"sourcesink/func_wakeup_enabled"
+#define ZERO_GADGET_ZERO_FUNC_WAKEUP_TRIGGER_SYSFS_PATH \
+	"sourcesink/func_wakeup_trigger"
+
+/**
+ * get_libusb_dev() - finds and returns the libusb device
+ *
+ * Return pointer to the libusb device or NULL on failier
+ *
+ * This function finds and returns the libusb device according to the input
+ * parameters: either device number and bus number or product id and vendor id
+ *
+ */
+libusb_device *get_libusb_dev(void);
+
+
+/**
+ * usb_tests_init() - init the libusb utility to be used by the tests.
+ * @argc: number of command line arguments
+ * @argv: command line arguments array
+ *
+ * Return 0 for sucsess, -1 for failier
+ *
+ * This function initializes the libusb utility to be used by the tests.
+ * This function should be called prior to any libusb functions.
+ */
+int usb_tests_init(int argc, char **argv);
+
+/**
+ * get_dev_speed() - returns the speed of the connected device.
+ *
+ * Return speed of the connected device.
+ * In case of an error return USB_SPEED_UNKNOWN
+ */
+enum usb_device_speed get_dev_speed(void);
+
+/**
+ * usb_tests_exit() - exit the libusb utility.
+ */
+void usb_tests_exit();
+
+/**
+ * This function returns the true if the devel input gflag was
+ * set, meaning none of the test suites should be run.
+ *
+ * Return bool - the value of tests_params.devel
+ */
+bool is_devel_mode(void);
+
+/**
+ * This function returns the true if the uasp_dev input gflag
+ * was set, meaning only the UASP test suite should be run.
+ *
+ * Returns bool - the value of tests_params.uasp_dev
+ */
+bool is_uasp_device(void);
+
+/**
+ * This function returns the true if the streams_dev input flag
+ * was set, meaning streams tests should be run.
+ *
+ * Returns bool - the value of tests_params.streams_dev
+ */
+bool is_streams_device(void);
+
+/*
+ * usb_tests_read_gadget_sysfs_file() - read from gadget sysfs file
+ * @path: path for the gadget sysfs file
+ *
+ * Return the integer read from the file
+ *
+ * This function reads an integer from given gadget sysfs file
+ */
+int usb_tests_read_gadget_sysfs_file(char *path);
+
+/**
+ * usb_tests_write_gadget_sysfs_file_int() - writes to gadget sysfs file an
+ * integer value
+ * @path: path for the gadget sysfs file
+ * @value: value to write to the file
+ *
+ * Return 0 for sucsess, -1 for failure
+ *
+ * This function writes an integer from given gadget sysfs file
+ */
+int usb_tests_write_gadget_sysfs_file_int(char *path, int value);
+
+/**
+ * usb_tests_write_gadget_sysfs_file_str() - writes to gadget
+ * sysfs file a string value
+ * @path: path for the gadget sysfs file
+ * @value: value to write to the file
+ *
+ * Return 0 for sucsess, -1 for failure
+ *
+ * This function writes an integer from given gadget sysfs file
+ */
+int usb_tests_write_gadget_sysfs_file_str(char *path, char *value);
+
+#endif /*USB_TEST_H*/
diff --git a/tools/usb/unittests/usb/usb_tests_main.cc b/tools/usb/unittests/usb/usb_tests_main.cc
new file mode 100644
index 0000000..cabbfbe
--- /dev/null
+++ b/tools/usb/unittests/usb/usb_tests_main.cc
@@ -0,0 +1,83 @@
+/*
+ * usb_tests_main.cc - main file of the Unit Tests Framework
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+
+#include <iostream>
+#include <stdio.h>
+
+#include <gtest/gtest.h>
+#include "usb_tests.h"
+
+#include "usb_devel_mode.h"
+
+int main(int argc, char **argv) {
+
+	int ret_val = 0;
+	char *updated_argv[argc+1];
+	char hs_filter[] = "--gtest_filter=-*SS*:*UASP*:*Streams*";
+	char ss_filter[] = "--gtest_filter=-*HS*:*UASP*:*Streams*";
+	int i;
+
+	if (usb_tests_init(argc, argv))
+		return -1;
+
+    if (is_devel_mode())
+	    return run_in_devel_mode(get_libusb_dev());
+
+	/* get current device speed and update tests filter according to it*/
+	for (i = 0; i < argc; i++) {
+		updated_argv[i] = argv[i];
+	}
+
+	if (is_uasp_device())
+		updated_argv[i] = "--gtest_filter=*UASP*";
+	else if (is_streams_device())
+		updated_argv[i] = "--gtest_filter=*Streams*";
+	else
+		switch (get_dev_speed()) {
+		case USB_SPEED_SUPER:
+			updated_argv[i] = ss_filter;
+			break;
+		default:
+			updated_argv[i] = hs_filter;
+		}
+	argc++;
+
+	testing::InitGoogleTest(&argc, updated_argv);
+
+	ret_val = RUN_ALL_TESTS();
+
+	usb_tests_exit();
+
+	return ret_val;
+}
diff --git a/tools/usb/unittests/usb/ut_config.h b/tools/usb/unittests/usb/ut_config.h
new file mode 100644
index 0000000..9148796
--- /dev/null
+++ b/tools/usb/unittests/usb/ut_config.h
@@ -0,0 +1,89 @@
+/*
+ * ut_config.h - Unittests global variables and defenitions
+ *
+ * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Code Aurora Forum, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef UT_CONFIG
+#define UT_CONFIG
+
+/*
+ * This is the timeout (in millseconds) to wait before giving up
+ * on a bulk transfer due to no response being received.
+ */
+#define BULK_TRANSFERR_TIMEOUT 2000
+
+/*
+ * This is the timeout (in millseconds) to wait before giving up
+ * on a control request due to no response being received.
+ */
+#define CTL_REQ_TRANSFERR_TIMEOUT 2000
+
+/*
+ * This is the timeout (in seconds) to wait for the device to
+ * recconect in connect/disconnect test
+ */
+#define WAIT_FOR_CONN 2
+
+/*
+ * This is control request code to be sent to gadget zero
+ * (soursesink) to initiate a connect/disconnect sequence
+ */
+#define CONN_DISCONN_TEST 0x52
+
+/*
+ * This is control request code to be sent to gadget zero
+ * (soursesink) to set up the bulk buffer size
+ */
+#define SET_BULK_BUF_SIZE 0x5e
+
+/*
+ * These are features selectors of the HALT, U1, U2, LTM ,
+ * SUSPEND & REMOTE_WU for the SET_FEATURE command
+ */
+#define HALT_ENABLE_FEATURE_SEL      0
+#define SUSPEND_ENABLE_FEATURE_SEL   0
+#define U1_ENABLE_FEATURE_SEL        48
+#define U2_ENABLE_FEATURE_SEL        49
+#define LTM_ENABLE_FEATURE_SEL       50
+
+#define FUNC_SUSPEND_OPT_LOW_POWER   0x1
+#define FUNC_SUSPEND_OPT_WAKEUP_EN   0x2
+
+#define MAX_STRING_LEN 255
+#define DEFAULT_GADGET_SYSFS_PATH \
+	"/sys/devices/platform/dummy_udc/gadget/"
+
+/*
+ * If this flag is set to 1, debug information wil be printed.
+ * Received as input parameter from user
+ */
+extern int ut_debug;
+
+#endif /*UT_CONFIG*/
-- 
1.7.0.4

--
Sent by an employee of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux