[RFC/PATCH v4 3/3] uas: Supporting UAS and BOT configuration.

[Shimrit Malichi]

Two configuration were added to the mass storage gadget: BOT (the first one),
and UAS. The linux host can switch between the configurations by changing
the value of bConfigValue in /sys/bus/usb/devices/<your_usb_device>/

Also, a fallback to HS in case SS configuration fails was added.

Signed-off-by: Shimrit Malichi <smalichi@xxxxxxxxxxxxxx>
---
 drivers/usb/gadget/f_mass_storage.c |   92 +---
 drivers/usb/gadget/f_uasp.c         | 1063 ++++++++++++++++++++---------------
 drivers/usb/gadget/f_uasp.h         |  106 +++-
 drivers/usb/gadget/mass_storage.c   |   88 ++--
 drivers/usb/gadget/storage_common.c |   66 +++-
 drivers/usb/gadget/uasp_cmdiu.c     |  176 +++---
 drivers/usb/gadget/uasp_tmiu.c      |   60 +-
 7 files changed, 955 insertions(+), 696 deletions(-)

diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index b777d72..96da3f6 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -317,39 +317,16 @@ static const char fsg_string_interface[] = "Mass Storage";
 struct fsg_dev;
 struct fsg_common;
 
-/* FSF callback functions */
-struct fsg_operations {
-	/*
-	 * Callback function to call when thread exits.  If no
-	 * callback is set or it returns value lower then zero MSF
-	 * will force eject all LUNs it operates on (including those
-	 * marked as non-removable or with prevent_medium_removal flag
-	 * set).
-	 */
-	int (*thread_exits)(struct fsg_common *common);
-
-	/*
-	 * Called prior to ejection.  Negative return means error,
-	 * zero means to continue with ejection, positive means not to
-	 * eject.
-	 */
-	int (*pre_eject)(struct fsg_common *common,
-			 struct fsg_lun *lun, int num);
-	/*
-	 * Called after ejection.  Negative return means error, zero
-	 * or positive is just a success.
-	 */
-	int (*post_eject)(struct fsg_common *common,
-			  struct fsg_lun *lun, int num);
-};
-
 /* Data shared by all the FSG instances. */
 struct fsg_common {
 	struct usb_gadget	*gadget;
 	struct usb_composite_dev *cdev;
+	struct msg_common_data	*msg_common;
 	struct fsg_dev		*fsg, *new_fsg;
 	wait_queue_head_t	fsg_wait;
 
+	struct mutex		*config_mutex;
+
 	/* filesem protects: backing files in use */
 	struct rw_semaphore	filesem;
 
@@ -408,31 +385,6 @@ struct fsg_common {
 	struct kref		ref;
 };
 
-struct fsg_config {
-	unsigned nluns;
-	struct fsg_lun_config {
-		const char *filename;
-		char ro;
-		char removable;
-		char cdrom;
-		char nofua;
-	} luns[FSG_MAX_LUNS];
-
-	const char		*lun_name_format;
-	const char		*thread_name;
-
-	/* Callback functions. */
-	const struct fsg_operations	*ops;
-	/* Gadget's private data. */
-	void			*private_data;
-
-	const char *vendor_name;		/*  8 characters or less */
-	const char *product_name;		/* 16 characters or less */
-	u16 release;
-
-	char			can_stall;
-};
-
 struct fsg_dev {
 	struct usb_function	function;
 	struct usb_gadget	*gadget;	/* Copy of cdev->gadget */
@@ -2364,7 +2316,10 @@ reset:
 			usb_ep_disable(fsg->bulk_out);
 			fsg->bulk_out_enabled = 0;
 		}
-
+		DBG(common,
+		    "%s()- disabled endpoints, releasing config mutex\n",
+		    __func__);
+		mutex_unlock(common->config_mutex);
 		common->fsg = NULL;
 		wake_up(&common->fsg_wait);
 	}
@@ -2373,6 +2328,9 @@ reset:
 	if (!new_fsg || rc)
 		return rc;
 
+	DBG(common, "%s()- Enabling endpoints, taking config mutex\n",
+	    __func__);
+	mutex_lock(common->config_mutex);
 	common->fsg = new_fsg;
 	fsg = common->fsg;
 
@@ -2703,8 +2661,7 @@ static inline void fsg_common_put(struct fsg_common *common)
 
 static struct fsg_common *fsg_common_init(struct fsg_common *common,
 					  struct usb_composite_dev *cdev,
-					  struct fsg_config *cfg,
-					  int start_thread)
+					  struct fsg_config *cfg)
 {
 	struct usb_gadget *gadget = cdev->gadget;
 	struct fsg_buffhd *bh;
@@ -2750,6 +2707,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
 	common->ep0 = gadget->ep0;
 	common->ep0req = cdev->req;
 	common->cdev = cdev;
+	common->config_mutex = &(cfg->config_mutex);
 
 	/* Maybe allocate device-global string IDs, and patch descriptors */
 	if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
@@ -2866,15 +2824,12 @@ buffhds_first_it:
 	spin_lock_init(&common->lock);
 	kref_init(&common->ref);
 
-	/* Tell the thread to start working */
-	if (start_thread) {
-		common->thread_task =
-			kthread_create(fsg_main_thread, common,
-			       cfg->thread_name ?: "file-storage");
-		if (IS_ERR(common->thread_task)) {
-			rc = PTR_ERR(common->thread_task);
-			goto error_release;
-		}
+	common->thread_task =
+		kthread_create(fsg_main_thread, common,
+		       cfg->thread_name ?: "file-storage");
+	if (IS_ERR(common->thread_task)) {
+		rc = PTR_ERR(common->thread_task);
+		goto error_release;
 	}
 	init_completion(&common->thread_notifier);
 	init_waitqueue_head(&common->fsg_wait);
@@ -2905,11 +2860,10 @@ buffhds_first_it:
 	}
 	kfree(pathbuf);
 
-	if (start_thread) {
-		DBG(common, "I/O thread pid: %d\n",
-		    task_pid_nr(common->thread_task));
-		wake_up_process(common->thread_task);
-	}
+	DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
+
+	wake_up_process(common->thread_task);
+
 	return common;
 
 error_luns:
@@ -3200,6 +3154,6 @@ fsg_common_from_params(struct fsg_common *common,
 {
 	struct fsg_config cfg;
 	fsg_config_from_params(&cfg, params);
-	return fsg_common_init(common, cdev, &cfg, 1);
+	return fsg_common_init(common, cdev, &cfg);
 }
 
diff --git a/drivers/usb/gadget/f_uasp.c b/drivers/usb/gadget/f_uasp.c
index 3db5a11..f3d1efa 100644
--- a/drivers/usb/gadget/f_uasp.c
+++ b/drivers/usb/gadget/f_uasp.c
@@ -176,11 +176,9 @@
 #include <linux/kref.h>
 #include <linux/kthread.h>
 #include <linux/string.h>
-#include <linux/usb/ch9.h>
-#include <linux/usb/gadget.h>
-#include <linux/kernel.h>
 #include <linux/usb/storage.h>
 
+#include "f_uasp.h"
 #include "uasp_cmdiu.c"
 #include "uasp_tmiu.c"
 
@@ -201,20 +199,21 @@ uasp_intf_desc = {
 
 /* BULK-in pipe descriptors */
 static struct usb_endpoint_descriptor
-uasp_bulk_in_desc = {
+uasp_fs_bulk_in_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_IN,
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	cpu_to_le16(512),
+	.wMaxPacketSize =	cpu_to_le16(64),
 };
 
-struct usb_pipe_usage_descriptor
-uasp_bulk_in_pipe_usg_desc = {
-	.bLength =		sizeof uasp_bulk_in_pipe_usg_desc,
-	.bDescriptorType =	USB_DT_PIPE_USAGE,
-	.bPipeID =		PIPE_ID_DATA_IN,
-	.Reserved =		0,
+static struct usb_endpoint_descriptor
+uasp_hs_bulk_in_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	cpu_to_le16(512),
 };
 
 struct usb_endpoint_descriptor
@@ -238,22 +237,31 @@ uasp_bulk_in_ep_comp_desc = {
 	.wBytesPerInterval =	0,
 };
 
+struct usb_pipe_usage_descriptor
+uasp_bulk_in_pipe_usg_desc = {
+	.bLength =		sizeof uasp_bulk_in_pipe_usg_desc,
+	.bDescriptorType =	USB_DT_PIPE_USAGE,
+	.bPipeID =		PIPE_ID_DATA_IN,
+	.Reserved =		0,
+};
+
 /* BULK-out pipe descriptors */
 struct usb_endpoint_descriptor
-uasp_bulk_out_desc = {
+uasp_fs_bulk_out_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_OUT,
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	cpu_to_le16(512),
+	.wMaxPacketSize =	cpu_to_le16(64),
 };
 
-struct usb_pipe_usage_descriptor
-uasp_bulk_out_pipe_usg_desc = {
-	.bLength =		sizeof uasp_bulk_out_pipe_usg_desc,
-	.bDescriptorType =	USB_DT_PIPE_USAGE,
-	.bPipeID =		PIPE_ID_DATA_OUT,
-	.Reserved =		0,
+struct usb_endpoint_descriptor
+uasp_hs_bulk_out_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	cpu_to_le16(512),
 };
 
 struct usb_endpoint_descriptor
@@ -277,22 +285,31 @@ uasp_bulk_out_ep_comp_desc = {
 	.wBytesPerInterval =	0,
 };
 
+struct usb_pipe_usage_descriptor
+uasp_bulk_out_pipe_usg_desc = {
+	.bLength =		sizeof uasp_bulk_out_pipe_usg_desc,
+	.bDescriptorType =	USB_DT_PIPE_USAGE,
+	.bPipeID =		PIPE_ID_DATA_OUT,
+	.Reserved =		0,
+};
+
 /* Status pipe - descriptors */
 struct usb_endpoint_descriptor
-uasp_status_in_desc = {
+uasp_fs_status_in_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_IN,
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	cpu_to_le16(512),
+	.wMaxPacketSize =	cpu_to_le16(64),
 };
 
-struct usb_pipe_usage_descriptor
-uasp_status_in_pipe_usg_desc = {
-	.bLength =		sizeof uasp_status_in_pipe_usg_desc,
-	.bDescriptorType =	USB_DT_PIPE_USAGE,
-	.bPipeID =		PIPE_ID_STS,
-	.Reserved =		0,
+struct usb_endpoint_descriptor
+uasp_hs_status_in_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	cpu_to_le16(512),
 };
 
 struct usb_endpoint_descriptor
@@ -316,22 +333,32 @@ uasp_status_in_ep_comp_desc = {
 	.wBytesPerInterval =	0,
 };
 
+
+struct usb_pipe_usage_descriptor
+uasp_status_in_pipe_usg_desc = {
+	.bLength =		sizeof uasp_status_in_pipe_usg_desc,
+	.bDescriptorType =	USB_DT_PIPE_USAGE,
+	.bPipeID =		PIPE_ID_STS,
+	.Reserved =		0,
+};
+
 /* Command pipe descriptors */
 struct usb_endpoint_descriptor
-uasp_command_out_desc = {
+uasp_fs_command_out_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_OUT,
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	cpu_to_le16(512),
+	.wMaxPacketSize =	cpu_to_le16(64),
 };
 
-struct usb_pipe_usage_descriptor
-uasp_command_out_pipe_usg_desc = {
-	.bLength =		sizeof uasp_command_out_pipe_usg_desc,
-	.bDescriptorType =	USB_DT_PIPE_USAGE,
-	.bPipeID =		PIPE_ID_CMD,
-	.Reserved =		0,
+struct usb_endpoint_descriptor
+uasp_hs_command_out_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	cpu_to_le16(512),
 };
 
 struct usb_endpoint_descriptor
@@ -355,16 +382,38 @@ uasp_command_out_ep_comp_desc = {
 	.wBytesPerInterval =	0,
 };
 
+struct usb_pipe_usage_descriptor
+uasp_command_out_pipe_usg_desc = {
+	.bLength =		sizeof uasp_command_out_pipe_usg_desc,
+	.bDescriptorType =	USB_DT_PIPE_USAGE,
+	.bPipeID =		PIPE_ID_CMD,
+	.Reserved =		0,
+};
+
+/* FS configuration function descriptors */
+struct usb_descriptor_header *uasp_fs_function_desc[] = {
+	(struct usb_descriptor_header *) &uasp_intf_desc,
+	(struct usb_descriptor_header *) &uasp_fs_bulk_in_desc,
+	(struct usb_descriptor_header *) &uasp_bulk_in_pipe_usg_desc,
+	(struct usb_descriptor_header *) &uasp_fs_bulk_out_desc,
+	(struct usb_descriptor_header *) &uasp_bulk_out_pipe_usg_desc,
+	(struct usb_descriptor_header *) &uasp_fs_status_in_desc,
+	(struct usb_descriptor_header *) &uasp_status_in_pipe_usg_desc,
+	(struct usb_descriptor_header *) &uasp_fs_command_out_desc,
+	(struct usb_descriptor_header *) &uasp_command_out_pipe_usg_desc,
+	NULL,
+};
+
 /* HS configuration function descriptors */
 struct usb_descriptor_header *uasp_hs_function_desc[] = {
 	(struct usb_descriptor_header *) &uasp_intf_desc,
-	(struct usb_descriptor_header *) &uasp_bulk_in_desc,
+	(struct usb_descriptor_header *) &uasp_hs_bulk_in_desc,
 	(struct usb_descriptor_header *) &uasp_bulk_in_pipe_usg_desc,
-	(struct usb_descriptor_header *) &uasp_bulk_out_desc,
+	(struct usb_descriptor_header *) &uasp_hs_bulk_out_desc,
 	(struct usb_descriptor_header *) &uasp_bulk_out_pipe_usg_desc,
-	(struct usb_descriptor_header *) &uasp_status_in_desc,
+	(struct usb_descriptor_header *) &uasp_hs_status_in_desc,
 	(struct usb_descriptor_header *) &uasp_status_in_pipe_usg_desc,
-	(struct usb_descriptor_header *) &uasp_command_out_desc,
+	(struct usb_descriptor_header *) &uasp_hs_command_out_desc,
 	(struct usb_descriptor_header *) &uasp_command_out_pipe_usg_desc,
 	NULL,
 };
@@ -388,35 +437,61 @@ struct usb_descriptor_header *uasp_ss_function_desc[] = {
 };
 
 /*--------------------------------------------------------------------------*/
+static int uasp_exception_in_progress(struct uasp_common *common)
+{
+	return common->state > UASP_STATE_IDLE;
+}
+
+/* Caller must hold udev->lock */
+static void uasp_wakeup_thread(struct uasp_common *common)
+{
+	/* Tell the main thread that something has happened */
+	common->thread_wakeup_needed = 1;
+	if (common->thread_task)
+		wake_up_process(common->thread_task);
+}
+
 static inline struct uasp_dev *uaspd_from_func(struct usb_function *f)
 {
-	struct fsg_dev		*fsg_dev = fsg_from_func(f);
-	return container_of(fsg_dev, struct uasp_dev, fsg_dev);
+	return container_of(f, struct uasp_dev, function);
+}
+
+static void uasp_raise_exception(struct uasp_common *common,
+				 enum fsg_state new_state)
+{
+	unsigned long		flags;
+
+	/*
+	 * Do nothing if a higher-priority exception is already in progress.
+	 * If a lower-or-equal priority exception is in progress, preempt it
+	 * and notify the main thread by sending it a signal.
+	 */
+	spin_lock_irqsave(&common->lock, flags);
+	if (common->state <= new_state) {
+		common->state = new_state;
+		if (common->thread_task)
+			send_sig_info(SIGUSR1, SEND_SIG_FORCED,
+				      common->thread_task);
+	}
+	spin_unlock_irqrestore(&common->lock, flags);
 }
 
 static void uasp_common_release(struct kref *ref)
 {
 	struct uasp_common *ucommon =
 		container_of(ref, struct uasp_common, ref);
-	struct uasp_lun *ulun;
-	int i;
 
-	/* First stop all lun threads */
-	run_lun_threads(ucommon->udev, LUN_STATE_EXIT);
-	for (i = 0; i < ucommon->common->nluns; i++) {
-		ulun = &(ucommon->uluns[i]);
-		if (ulun->lun_state != LUN_STATE_TERMINATED) {
-			wait_for_completion(&ulun->thread_notifier);
-			/* The cleanup routine waits for this completion also */
-			complete(&ulun->thread_notifier);
-		}
+	/* If the thread isn't already dead, tell it to exit now */
+	if (ucommon->state != UASP_STATE_TERMINATED) {
+		uasp_raise_exception(ucommon, FSG_STATE_EXIT);
+		wait_for_completion(&ucommon->thread_notifier);
 	}
-	fsg_common_release(&(ucommon->common->ref));
+
 	kfree(ucommon->uluns);
+	kfree(ucommon->ubufs);
 	kfree(ucommon);
 }
 
-
 static inline void uasp_common_put(struct uasp_common *common)
 {
 	kref_put(&(common->ref), uasp_common_release);
@@ -427,23 +502,48 @@ static struct uasp_lun *find_lun_by_id(struct uasp_dev *udev, __u8 *lun_id)
 	int i;
 	struct uasp_lun *curlun;
 
-	DBG(udev->ucommon->common, "%s() - Enter.\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter.\n", __func__);
 
-	for (i = 0; i < udev->ucommon->common->nluns; ++i) {
+	for (i = 0; i < udev->ucommon->nluns; ++i) {
 		curlun = &udev->ucommon->uluns[i];
 
 		if (memcmp(lun_id, curlun->lun_id, 8) == 0) {
-			DBG(udev->ucommon->common, "%s() - LUN found\n",
+			DBG(udev->ucommon, "%s() - LUN found\n",
 			    __func__);
 			return curlun;
 		}
 	}
-	DBG(udev->ucommon->common, "%s() - LUN not found\n", __func__);
+	DBG(udev->ucommon, "%s() - LUN not found\n", __func__);
 	return 0;
 }
 
 /**
- * wakeup_lun_thread() - Wakes up the given LUn thread
+ * uasp_sleep_thread() - sleep UASP main thread
+ * @common: pointer to uasp common data structure
+ */
+int uasp_sleep_thread(struct uasp_common *common)
+{
+	int	rc = 0;
+
+	/* Wait until a signal arrives or we are woken up */
+	for (;;) {
+		try_to_freeze();
+		set_current_state(TASK_INTERRUPTIBLE);
+		if (signal_pending(current)) {
+			rc = -EINTR;
+			break;
+		}
+		if (common->thread_wakeup_needed)
+			break;
+		schedule();
+	}
+	__set_current_state(TASK_RUNNING);
+	common->thread_wakeup_needed = 0;
+	return rc;
+}
+
+/**
+ * wakeup_lun_thread() - Wakes up the given LUN thread
  * @lun: the LUN which thread needs wakening
  *
  * NOTE: Caller must hold uasp_lun->lock
@@ -472,31 +572,31 @@ static void command_complete(struct usb_ep *ep, struct usb_request *req)
 	unsigned long flags;
 
 	if (req->actual > 0)
-		dump_msg(udev->ucommon->common, "command", req->buf,
+		dump_msg(udev->ucommon, "command", req->buf,
 			 req->actual);
-	DBG(udev->ucommon->common, "%s() - Enter", __func__);
+	DBG(udev->ucommon, "%s() - Enter", __func__);
 
 	if (req != udev->cmd_buff.outreq) {
-		ERROR(udev->ucommon->common, "(%s) req(%p) != "
+		ERROR(udev->ucommon, "(%s) req(%p) != "
 					     "cmd_buff.outreq(%p), udev=%p,"
 					     " common->state = %d\n",
 		      __func__, req, udev->cmd_buff.outreq, udev,
-		      udev->ucommon->common->state);
+		      udev->ucommon->state);
 	}
 
 	if (req->status == -ECONNRESET) {
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
 		udev->cmd_buff.state = BUF_STATE_EMPTY;
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 		usb_ep_fifo_flush(ep);
 		return;
 	}
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	udev->cmd_buff.state = BUF_STATE_FULL;
-	wakeup_thread(udev->ucommon->common);
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	uasp_wakeup_thread(udev->ucommon);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 }
 
 /**
@@ -520,12 +620,12 @@ void status_complete(struct usb_ep *ep, struct usb_request *req)
 	uint8_t cmd_id = ((uint8_t *)req->context)[0];
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter", __func__);
+	DBG(udev->ucommon, "%s() - Enter", __func__);
 
 	if (req->status == -ECONNRESET)
 		usb_ep_fifo_flush(ep);
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	/* If Sense IU is filled for TM FUNCTION IU */
 	if (cmd_id == IU_ID_TASK_MANAGEMENT) {
 		tmiu = (struct tm_iu *)req->context;
@@ -534,14 +634,14 @@ void status_complete(struct usb_ep *ep, struct usb_request *req)
 			if (req->status == -ERESTART)
 				tmiu->state = COMMAND_STATE_ABORTED;
 			else if (req->status) {
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				    "%s() - TMIU FAILED!!! Status = %d",
 				    __func__, req->status);
 				tmiu->state = COMMAND_STATE_FAILED;
 			} else
 				tmiu->state = COMMAND_STATE_COMPLETED;
 		}
-		DBG(udev->ucommon->common,
+		DBG(udev->ucommon,
 		    "%s() - received IU_ID_TASK_MANAGEMENT "
 		    "(Code = %02x tmiu->state = %d)\n",
 		    __func__, tmiu->tm_function, tmiu->state);
@@ -556,14 +656,14 @@ void status_complete(struct usb_ep *ep, struct usb_request *req)
 			if (req->status == -ERESTART)
 				cmdiu->state = COMMAND_STATE_ABORTED;
 			else if (req->status) {
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				    "%s() - CMDIU FAILED!!! Status = %d",
 				    __func__, req->status);
 				cmdiu->state = COMMAND_STATE_FAILED;
 			} else if (cmdiu->state == COMMAND_STATE_STATUS)
 					cmdiu->state = COMMAND_STATE_COMPLETED;
 		}
-		DBG(udev->ucommon->common, "%s() - received IU_ID_COMMAND"
+		DBG(udev->ucommon, "%s() - received IU_ID_COMMAND"
 					" (OpCode = %02x, smdiu->state = %d)\n",
 		    __func__, cmdiu->cdb[0], cmdiu->state);
 		cmdiu->req_sts = CMD_REQ_COMPLETED;
@@ -571,29 +671,29 @@ void status_complete(struct usb_ep *ep, struct usb_request *req)
 
 		curlun = find_lun_by_id(udev, cmdiu->lun);
 	} else {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s() - received invalid IU (iu_id = %02x)!\n",
 		      __func__, cmd_id);
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 		return;
 	}
 
 	if (curlun) {
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock),
+		spin_unlock_irqrestore(&(udev->ucommon->lock),
 				       flags);
 		spin_lock_irqsave(&(curlun->lock), flags);
 		curlun->pending_requests++;
 		curlun->active_requests--;
 		wakeup_lun_thread(curlun);
 		spin_unlock_irqrestore(&(curlun->lock), flags);
-		spin_lock_irqsave(&(udev->ucommon->common->lock),
+		spin_lock_irqsave(&(udev->ucommon->lock),
 				  flags);
 	} else {
 		udev->pending_requests++;
 		udev->active_requests--;
-		wakeup_thread(udev->ucommon->common);
+		uasp_wakeup_thread(udev->ucommon);
 	}
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 }
 
 /**
@@ -613,14 +713,14 @@ void uasp_bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 	struct cmd_iu *cmdiu;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (req->status == -ECONNRESET)
 		usb_ep_fifo_flush(ep);
 
 	cmdiu = (struct cmd_iu *)req->context;
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	if (cmdiu->state != COMMAND_STATE_ABORTED &&
 	    cmdiu->state != COMMAND_STATE_FAILED) {
 		if (req->status == -ERESTART)
@@ -635,19 +735,19 @@ void uasp_bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 
 	curlun = find_lun_by_id(udev, cmdiu->lun);
 	if (curlun) {
-		spin_unlock_irqrestore(&udev->ucommon->common->lock, flags);
+		spin_unlock_irqrestore(&udev->ucommon->lock, flags);
 		spin_lock_irqsave(&curlun->lock, flags);
 		curlun->pending_requests++;
 		curlun->active_requests--;
 		wakeup_lun_thread(curlun);
 		spin_unlock_irqrestore(&curlun->lock, flags);
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	} else {
 		udev->pending_requests++;
 		udev->active_requests--;
-		wakeup_thread(udev->ucommon->common);
+		uasp_wakeup_thread(udev->ucommon);
 	}
-	spin_unlock_irqrestore(&udev->ucommon->common->lock, flags);
+	spin_unlock_irqrestore(&udev->ucommon->lock, flags);
 }
 
 
@@ -668,12 +768,12 @@ void uasp_bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
 	struct cmd_iu *cmdiu;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (req->status == -ECONNRESET)
 		usb_ep_fifo_flush(ep);
 
-	spin_lock_irqsave(&udev->ucommon->common->lock, flags);
+	spin_lock_irqsave(&udev->ucommon->lock, flags);
 	cmdiu = (struct cmd_iu *)req->context;
 
 	if (cmdiu->state != COMMAND_STATE_ABORTED &&
@@ -689,19 +789,19 @@ void uasp_bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
 
 	curlun = find_lun_by_id(udev, cmdiu->lun);
 	if (curlun) {
-		spin_unlock_irqrestore(&udev->ucommon->common->lock, flags);
+		spin_unlock_irqrestore(&udev->ucommon->lock, flags);
 		spin_lock_irqsave(&curlun->lock, flags);
 		curlun->pending_requests++;
 		curlun->active_requests--;
 		wakeup_lun_thread(curlun);
 		spin_unlock_irqrestore(&curlun->lock, flags);
-		spin_lock_irqsave(&udev->ucommon->common->lock, flags);
+		spin_lock_irqsave(&udev->ucommon->lock, flags);
 	} else {
 		udev->pending_requests++;
 		udev->active_requests--;
-		wakeup_thread(udev->ucommon->common);
+		uasp_wakeup_thread(udev->ucommon);
 	}
-	spin_unlock_irqrestore(&udev->ucommon->common->lock, flags);
+	spin_unlock_irqrestore(&udev->ucommon->lock, flags);
 }
 
 /**
@@ -722,11 +822,11 @@ static void remove_completed_commands(struct uasp_dev *udev,
 	struct tm_iu *tmiu;
 	struct tm_iu *tmp_tmiu;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Remove completed, aborted or failed commands from cmd_queue */
 	list_for_each_entry_safe(cmdiu, tmp_cmdiu, cmd_queue, node) {
-		DBG(udev->ucommon->common, "%s() - cmd_queue cycle"
+		DBG(udev->ucommon, "%s() - cmd_queue cycle"
 					   " cmdiu->state=%d "
 					   " cmdiu->req_sts=%d\n",
 		     __func__, cmdiu->state, cmdiu->req_sts);
@@ -757,13 +857,13 @@ static void remove_completed_commands(struct uasp_dev *udev,
 			if (cmdiu->req_sts == CMD_REQ_IN_PROGRESS)
 				continue;
 		}
-		DBG(udev->ucommon->common, "%s() - deleted cmdiu: "
+		DBG(udev->ucommon, "%s() - deleted cmdiu: "
 				   "cmdiu[0] = %d, cmdiu->state = %d,"
 				   "cmdiu->tag = %d\n",
 		     __func__, cmdiu->cdb[0], cmdiu->state, cmdiu->tag);
 		list_del(&cmdiu->node);
 		if (cmdiu->bh) {
-			DBG(udev->ucommon->common, "%s() - Freeing the "
+			DBG(udev->ucommon, "%s() - Freeing the "
 						   "cmdiu->bh\n", __func__);
 			cmdiu->bh->state = BUF_STATE_EMPTY;
 		}
@@ -778,19 +878,19 @@ static void remove_completed_commands(struct uasp_dev *udev,
 		    tmiu->state != COMMAND_STATE_FAILED)
 			continue;
 
-		DBG(udev->ucommon->common, "%s() - deleted tmiu\n",  __func__);
+		DBG(udev->ucommon, "%s() - deleted tmiu\n",  __func__);
 		list_del(&tmiu->node);
 		if (tmiu->bh) {
-			DBG(udev->ucommon->common, "%s() - Freeing the "
+			DBG(udev->ucommon, "%s() - Freeing the "
 						   "tmiu->bh\n", __func__);
 			tmiu->bh->state = BUF_STATE_EMPTY;
 		}
 		kfree(tmiu);
 	}
 	if (list_empty(cmd_queue) && list_empty(tm_func_queue))
-		DBG(udev->ucommon->common, "%s() - both lists are empty\n",
+		DBG(udev->ucommon, "%s() - both lists are empty\n",
 		    __func__);
-	DBG(udev->ucommon->common, "%s() - exit\n", __func__);
+	DBG(udev->ucommon, "%s() - exit\n", __func__);
 }
 
 /**
@@ -802,40 +902,36 @@ static void remove_completed_commands(struct uasp_dev *udev,
  *
  * Initiates all endpoints and enables them. Allocates buffers and requests.
  */
-static int do_uasp_set_interface(struct uasp_dev *uaspd,
-				 struct fsg_dev *new_fsg)
+static int do_uasp_set_interface(struct uasp_common *ucommon,
+				 struct uasp_dev *new_uaspd)
 {
 	int rc = 0;
 	int i;
-	struct fsg_dev	*fsgd;
-	struct fsg_common *fcommon;
 	unsigned long flags;
+	struct uasp_dev *udev = ucommon->udev;
 
-	if (!uaspd || !uaspd->ucommon || !uaspd->ucommon->common)
+	if (!ucommon)
 		return -EIO;
 
-	DBG(uaspd->ucommon->common, "%s()- Enter\n", __func__);
+	DBG(ucommon, "%s()- Enter\n", __func__);
 
-	fcommon = uaspd->ucommon->common;
-	if (uaspd->ucommon->common->running)
-		DBG(uaspd->ucommon->common, "reset inteface\n");
+	if (ucommon->running)
+		DBG(ucommon, "reset inteface\n");
 
 reset_uasp:
 	/* Deallocate the requests */
-	if (uaspd->ucommon->common->fsg) {
-		fsgd = fcommon->fsg;
-
-		abort_commands(uaspd, &uaspd->cmd_queue, &uaspd->tm_func_queue,
-		       &(uaspd->ucommon->common->lock));
-		remove_completed_commands(uaspd, &uaspd->cmd_queue,
-				   &uaspd->tm_func_queue);
-		uaspd->pending_requests = 0;
-
-		for (i = 0; i < uaspd->ucommon->common->nluns; i++) {
-			struct uasp_lun *ulun = &uaspd->ucommon->uluns[i];
-			abort_commands(uaspd, &ulun->cmd_queue,
+	if (ucommon->udev) {
+		abort_commands(udev, &udev->cmd_queue,
+			       &udev->tm_func_queue, &(udev->ucommon->lock));
+		remove_completed_commands(udev, &udev->cmd_queue,
+					  &udev->tm_func_queue);
+		udev->pending_requests = 0;
+
+		for (i = 0; i < ucommon->nluns; i++) {
+			struct uasp_lun *ulun = &ucommon->uluns[i];
+			abort_commands(udev, &ulun->cmd_queue,
 				       &ulun->tm_func_queue, &(ulun->lock));
-			remove_completed_commands(uaspd, &ulun->cmd_queue,
+			remove_completed_commands(udev, &ulun->cmd_queue,
 					   &ulun->tm_func_queue);
 			spin_lock_irqsave(&(ulun->lock), flags);
 			ulun->pending_requests = 0;
@@ -847,130 +943,142 @@ reset_uasp:
 			spin_unlock_irq(&(ulun->lock));
 		}
 		/* Clear out the controller's fifos */
-		if (fcommon->fsg->bulk_in_enabled)
-			usb_ep_fifo_flush(fcommon->fsg->bulk_in);
-		if (fcommon->fsg->bulk_out_enabled)
-			usb_ep_fifo_flush(fcommon->fsg->bulk_out);
-		usb_ep_fifo_flush(uaspd->ucommon->udev->status);
-		usb_ep_fifo_flush(uaspd->ucommon->udev->command);
-
-		spin_lock_irq(&fcommon->lock);
+		if (udev->bulk_in_enabled)
+			usb_ep_fifo_flush(udev->bulk_in);
+		if (udev->bulk_out_enabled)
+			usb_ep_fifo_flush(udev->bulk_out);
+		usb_ep_fifo_flush(udev->status);
+		usb_ep_fifo_flush(udev->command);
+
+		spin_lock_irq(&ucommon->lock);
 		/* Reset the I/O buffer states and pointers */
 		for (i = 0; i < fsg_num_buffers; ++i) {
-			struct fsg_buffhd *bh = &fcommon->buffhds[i];
+			struct fsg_buffhd *bh =
+				ucommon->ubufs[i].fsg_buff;
 			if (bh->inreq) {
-				usb_ep_free_request(fsgd->bulk_in, bh->inreq);
+				usb_ep_free_request(udev->bulk_in, bh->inreq);
 				bh->inreq = NULL;
 			}
 			if (bh->outreq) {
-				usb_ep_free_request(fsgd->bulk_out, bh->outreq);
+				usb_ep_free_request(udev->bulk_out, bh->outreq);
 				bh->outreq = NULL;
 			}
 			bh->state = BUF_STATE_EMPTY;
 		}
-
+		spin_unlock_irq(&ucommon->lock);
 		/* Deallocate command and status requests */
-		if (uaspd->cmd_buff.inreq) {
-			ERROR(uaspd->ucommon->common,
+		if (udev->cmd_buff.inreq) {
+			ERROR(ucommon,
 			      "%s(): uaspd->cmd_buff.inreq isn't NULL. "
 			      "How can that be???",
 			      __func__);
-			usb_ep_free_request(uaspd->command,
-					    uaspd->cmd_buff.inreq);
-			uaspd->cmd_buff.inreq = NULL;
+			usb_ep_free_request(udev->command,
+					    udev->cmd_buff.inreq);
+			udev->cmd_buff.inreq = NULL;
 		}
-		if (uaspd->cmd_buff.outreq) {
-			usb_ep_free_request(uaspd->command,
-					    uaspd->cmd_buff.outreq);
-			uaspd->cmd_buff.outreq = NULL;
+		if (udev->cmd_buff.outreq) {
+			(void)usb_ep_dequeue(udev->command,
+					     udev->cmd_buff.outreq);
+			usb_ep_free_request(udev->command,
+					    udev->cmd_buff.outreq);
+			udev->cmd_buff.outreq = NULL;
 		}
-		uaspd->cmd_buff.state = BUF_STATE_EMPTY;
-		spin_unlock_irq(&fcommon->lock);
+		udev->cmd_buff.state = BUF_STATE_EMPTY;
 
 		/* Disable the endpoints */
-		if (fsgd->bulk_in_enabled) {
-			usb_ep_disable(fsgd->bulk_in);
-			fsgd->bulk_in_enabled = 0;
+		if (udev->bulk_in_enabled) {
+			usb_ep_disable(udev->bulk_in);
+			udev->bulk_in_enabled = 0;
 		}
-		if (fsgd->bulk_out_enabled) {
-			usb_ep_disable(fsgd->bulk_out);
-			fsgd->bulk_out_enabled = 0;
+		if (udev->bulk_out_enabled) {
+			usb_ep_disable(udev->bulk_out);
+			udev->bulk_out_enabled = 0;
 		}
-		fsgd->bulk_in->desc = NULL;
-		fsgd->bulk_out->desc = NULL;
+		udev->bulk_in->desc = NULL;
+		udev->bulk_out->desc = NULL;
 
-		if (uaspd->cmd_enabled) {
-			usb_ep_disable(uaspd->command);
-			uaspd->cmd_enabled = 0;
+		if (udev->cmd_enabled) {
+			usb_ep_disable(udev->command);
+			udev->cmd_enabled = 0;
 		}
-		if (uaspd->status_enabled) {
-			usb_ep_disable(uaspd->status);
-			uaspd->status_enabled = 0;
+		if (udev->status_enabled) {
+			usb_ep_disable(udev->status);
+			udev->status_enabled = 0;
 		}
-		uaspd->command->desc = NULL;
-		uaspd->status->desc = NULL;
-		DBG(uaspd->ucommon->common, "%s()- disabled endpoints\n",
+		udev->command->desc = NULL;
+		udev->status->desc = NULL;
+		DBG(ucommon,
+		    "%s()- disabled endpoints, releasing config mutex\n",
 		    __func__);
-
-		fcommon->fsg = NULL;
-		wake_up(&fcommon->fsg_wait);
+		mutex_unlock(ucommon->config_mutex);
+		ucommon->udev = NULL;
+		wake_up(&ucommon->uasp_wait);
 	}
 
-	fcommon->running = 0;
-	if (!new_fsg || rc)
+	ucommon->running = 0;
+	if (!new_uaspd || rc) {
+		udev->op_mode = UASP_MODE_UNSET;
 		return rc;
+	}
+	DBG(ucommon, "%s()- Enabling endpoints, taking config mutex\n",
+	    __func__);
+	mutex_lock(ucommon->config_mutex);
+	ucommon->udev = new_uaspd;
+	udev = ucommon->udev;
+	if (!udev->op_mode) {
+		if (udev->forced_hs_mode)
+			udev->op_mode = HS_UASP_MODE;
+		else
+			udev->op_mode =
+				(ucommon->gadget->speed == USB_SPEED_SUPER ?
+				 SS_UASP_MODE : HS_UASP_MODE);
+	}
 
-	fcommon->fsg = new_fsg;
-	fsgd = fcommon->fsg;
-	uaspd->op_mode = (fcommon->gadget->speed == USB_SPEED_SUPER ?
-			  SS_UASP_MODE : HS_UASP_MODE);
-
-	/* Enable the endpoints */
-	config_ep_by_speed(fcommon->gadget, &fsgd->function, fsgd->bulk_in);
-	rc = usb_ep_enable(fsgd->bulk_in);
+	config_ep_by_speed(ucommon->gadget, &udev->function, udev->bulk_in);
+	rc = usb_ep_enable(udev->bulk_in);
 	if (rc)
 		goto reset_uasp;
-	fsgd->bulk_in->driver_data = uaspd;
-	fsgd->bulk_in_enabled = 1;
+	udev->bulk_in->driver_data = udev;
+	udev->bulk_in_enabled = 1;
 
-	config_ep_by_speed(fsgd->common->gadget, &fsgd->function,
-			   fsgd->bulk_out);
-	rc = usb_ep_enable(fsgd->bulk_out);
+	config_ep_by_speed(ucommon->gadget, &udev->function,
+			   udev->bulk_out);
+	rc = usb_ep_enable(udev->bulk_out);
 	if (rc)
 		goto reset_uasp;
-	fsgd->bulk_out->driver_data = uaspd;
-	fsgd->bulk_out_enabled = 1;
+	udev->bulk_out->driver_data = udev;
+	udev->bulk_out_enabled = 1;
 
-	fsgd->common->bulk_out_maxpacket =
-		le16_to_cpu(fsgd->bulk_out->maxpacket);
-	clear_bit(IGNORE_BULK_OUT, &fsgd->atomic_bitflags);
+	/*ucommon->bulk_out_maxpacket =
+		le16_to_cpu(udev->bulk_out->maxpacket);
+	clear_bit(IGNORE_BULK_OUT, &fsgd->atomic_bitflags);*/
 
-	config_ep_by_speed(fsgd->common->gadget, &fsgd->function,
-			   uaspd->command);
-	rc = usb_ep_enable(uaspd->command);
+	config_ep_by_speed(ucommon->gadget, &udev->function,
+			   udev->command);
+	rc = usb_ep_enable(udev->command);
 	if (rc)
 		goto reset_uasp;
-	uaspd->command->driver_data = uaspd;
-	uaspd->cmd_enabled = 1;
+	udev->command->driver_data = udev;
+	udev->cmd_enabled = 1;
 
-	config_ep_by_speed(fsgd->common->gadget, &fsgd->function,
-			   uaspd->status);
-	rc = usb_ep_enable(uaspd->status);
+	config_ep_by_speed(ucommon->gadget, &udev->function,
+			   udev->status);
+	rc = usb_ep_enable(udev->status);
 	if (rc)
 		goto reset_uasp;
-	uaspd->status->driver_data = uaspd;
-	uaspd->status_enabled = 1;
+	udev->status->driver_data = udev;
+	udev->status_enabled = 1;
 
 	/* Allocate the data - requests */
 	for (i = 0; i < fsg_num_buffers; ++i) {
-		struct uasp_buff	*buff = &uaspd->ucommon->ubufs[i];
+		struct uasp_buff	*buff = &ucommon->ubufs[i];
 
-		buff->fsg_buff->inreq = usb_ep_alloc_request(fsgd->bulk_in,
+		buff->fsg_buff->inreq = usb_ep_alloc_request(udev->bulk_in,
 							     GFP_ATOMIC);
 		if (!buff->fsg_buff->inreq)
 			goto reset_uasp;
 
-		buff->fsg_buff->outreq = usb_ep_alloc_request(fsgd->bulk_out,
+		buff->fsg_buff->outreq = usb_ep_alloc_request(udev->bulk_out,
 							     GFP_ATOMIC);
 		if (!buff->fsg_buff->outreq)
 			goto reset_uasp;
@@ -984,24 +1092,24 @@ reset_uasp:
 	}
 
 	/* Allocate command ep request */
-	uaspd->cmd_buff.outreq = usb_ep_alloc_request(uaspd->command,
+	udev->cmd_buff.outreq = usb_ep_alloc_request(udev->command,
 							     GFP_ATOMIC);
-	if (!uaspd->cmd_buff.outreq) {
-		ERROR(uaspd->ucommon->common, "failed allocating outreq for "
+	if (!udev->cmd_buff.outreq) {
+		ERROR(ucommon, "failed allocating outreq for "
 					     "command buffer\n");
 		goto reset_uasp;
 	}
 
-	DBG(uaspd->ucommon->common, "%s() Enebled endpoints. "
+	DBG(ucommon, "%s() Enebled endpoints. "
 				    "Opperation mode = %d\n", __func__,
-				uaspd->op_mode);
-	uaspd->cmd_buff.outreq->buf = &(uaspd->cmd_buff.buf);
-	uaspd->cmd_buff.inreq = NULL;
-	uaspd->cmd_buff.state = BUF_STATE_EMPTY;
-
-	fcommon->running = 1;
-	for (i = 0; i < fsgd->common->nluns; ++i)
-		fsgd->common->luns[i].unit_attention_data = SS_RESET_OCCURRED;
+				udev->op_mode);
+	udev->cmd_buff.outreq->buf = &(udev->cmd_buff.buf);
+	udev->cmd_buff.inreq = NULL;
+	udev->cmd_buff.state = BUF_STATE_EMPTY;
+
+	ucommon->running = 1;
+	for (i = 0; i < ucommon->nluns; ++i)
+		ucommon->uluns[i].lun->unit_attention_data = SS_RESET_OCCURRED;
 	return 0;
 }
 
@@ -1011,12 +1119,10 @@ static void handle_uasp_exception(struct uasp_common *ucommon)
 	int			sig;
 	int			i;
 	struct fsg_buffhd	*bh;
-	enum fsg_state		old_state;
+	enum uasp_state		old_state;
 	int			rc;
 
-	struct fsg_common *fcommon = ucommon->common;
-
-	DBG(ucommon->common, "%s()- Enter\n", __func__);
+	DBG(ucommon, "%s()- Enter\n", __func__);
 
 	/*
 	 * Clear the existing signals.  Anything but SIGUSR1 is converted
@@ -1027,9 +1133,9 @@ static void handle_uasp_exception(struct uasp_common *ucommon)
 		if (!sig)
 			break;
 		if (sig != SIGUSR1) {
-			if (fcommon->state < FSG_STATE_EXIT)
-				DBG(fcommon, "Main thread exiting on signal\n");
-			fcommon->state = FSG_STATE_EXIT;
+			if (ucommon->state < UASP_STATE_EXIT)
+				DBG(ucommon, "Main thread exiting on signal\n");
+			ucommon->state = UASP_STATE_EXIT;
 		}
 	}
 
@@ -1037,51 +1143,42 @@ static void handle_uasp_exception(struct uasp_common *ucommon)
 	 * Reset the I/O buffer states and pointers, the SCSI  state, and the
 	 * exception.  Then invoke the handler.
 	 */
-	spin_lock_irq(&fcommon->lock);
+	spin_lock_irq(&ucommon->lock);
 
 	for (i = 0; i < fsg_num_buffers; ++i) {
-		bh = &fcommon->buffhds[i];
+		bh = ucommon->ubufs[i].fsg_buff;
 		bh->state = BUF_STATE_EMPTY;
 	}
-	old_state = fcommon->state;
-	fcommon->state = FSG_STATE_IDLE;
-	spin_unlock_irq(&fcommon->lock);
+	old_state = ucommon->state;
+	ucommon->state = UASP_STATE_IDLE;
+	spin_unlock_irq(&ucommon->lock);
 
 	/* Carry out any extra actions required for the exception */
 	switch (old_state) {
-	case FSG_STATE_ABORT_BULK_OUT:
-	case FSG_STATE_RESET:
-		/* TODO */
-		break;
-
-	case FSG_STATE_CONFIG_CHANGE:
-		if (fcommon->fsg == fcommon->new_fsg) {
-			DBG(fcommon, "nothing to do. same config\n");
-			break;
-		}
+	case UASP_STATE_CONFIG_CHANGE:
 		/* Enable/disable the interface according to the new_config */
-		rc = do_uasp_set_interface(ucommon->udev, fcommon->new_fsg);
+		rc = do_uasp_set_interface(ucommon, ucommon->new_udev);
 		if (rc != 0)
-			fcommon->fsg = NULL;	/* Reset on errors */
+			ucommon->udev = NULL;	/* Reset on errors */
+		if (ucommon->new_udev)
+			usb_composite_setup_continue(ucommon->cdev);
 		break;
-	case FSG_STATE_EXIT:
-	case FSG_STATE_TERMINATED:
+	case UASP_STATE_EXIT:
+	case UASP_STATE_TERMINATED:
 		/* Free resources */
-		(void)do_uasp_set_interface(ucommon->udev, NULL);
-		spin_lock_irq(&fcommon->lock);
-		fcommon->state = FSG_STATE_TERMINATED;	/* Stop the thread*/
-		spin_unlock_irq(&fcommon->lock);
+		(void)do_uasp_set_interface(ucommon, NULL);
+		spin_lock_irq(&ucommon->lock);
+		ucommon->state = UASP_STATE_TERMINATED;	/* Stop the thread*/
+		spin_unlock_irq(&ucommon->lock);
 		break;
 
-	case FSG_STATE_INTERFACE_CHANGE:
-	case FSG_STATE_DISCONNECT:
-	case FSG_STATE_COMMAND_PHASE:
-	case FSG_STATE_DATA_PHASE:
-	case FSG_STATE_STATUS_PHASE:
-	case FSG_STATE_IDLE:
+	case UASP_STATE_INTERFACE_CHANGE:
+	case UASP_STATE_DISCONNECT:
+	case UASP_STATE_RESET:
+	case UASP_STATE_IDLE:
 		break;
 	}
-	DBG(ucommon->common, "%s()- Exit\n", __func__);
+	DBG(ucommon, "%s()- Exit\n", __func__);
 }
 
 /**
@@ -1121,7 +1218,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 	req = udev->cmd_buff.outreq;
 	*command = NULL;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Id of the received command (tmiu or cmdiu) */
 	cmd_id = ((uint8_t *)req->buf)[0];
@@ -1131,7 +1228,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 	/* Invalid completion status */
 	if (req->status) {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s() - Invalid completion status for command "
 		      "request = -%d\n", __func__, req->status);
 		return -EINVAL;
@@ -1139,7 +1236,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 	/* Check is the data received via command endpoint is a command */
 	if (cmd_id != IU_ID_TASK_MANAGEMENT && cmd_id != IU_ID_COMMAND) {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s() - Invalid data is received\n", __func__);
 		/* TODO: something needs to be done (e.g. halt endpoints) */
 		return -EINVAL;
@@ -1147,7 +1244,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 	/* Invalid count of bytes received for tmiu */
 	if (cmd_id == IU_ID_TASK_MANAGEMENT && req->actual != 16) {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s() - Invalid byte count for tmiu is received = %d\n",
 		       __func__, req->actual);
 		/* TODO: something needs to be done (e.g. halt endpoints) */
@@ -1156,7 +1253,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 	/* Invalid count of bytes received for cmdiu */
 	if (cmd_id == IU_ID_COMMAND && req->actual < 32) {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s() - Invalid byte count for cmdiu is received = %d\n",
 		      __func__, req->actual);
 		/* TODO: something needs to be done (e.g. halt endpoints) */
@@ -1171,7 +1268,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 		tmiu = kmalloc(sizeof(struct tm_iu), GFP_KERNEL);
 
 		if (!tmiu) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s() - No memory for tmiu\n", __func__);
 			return -ENOMEM;
 		}
@@ -1181,7 +1278,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 		cmdiu = kmalloc(sizeof(struct cmd_iu), GFP_KERNEL);
 
 		if (!cmdiu) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s() - No memory for cmdiu\n", __func__);
 			return -ENOMEM;
 		}
@@ -1191,7 +1288,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 	/* Check for overlapping tag */
 	/* Check for tag overlapping over all cmd an tm_func queues */
-	for (i = 0; i < udev->ucommon->common->nluns; ++i) {
+	for (i = 0; i < udev->ucommon->nluns; ++i) {
 		curlun = &udev->ucommon->uluns[i];
 		spin_lock_irqsave(&(curlun->lock), flags);
 
@@ -1221,7 +1318,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 		spin_unlock_irqrestore(&(curlun->lock), flags);
 	}
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	list_for_each_entry(tmp_cmdiu, &udev->cmd_queue, node) {
 		if (tmp_cmdiu->state != COMMAND_STATE_IDLE &&
 		    tmp_cmdiu->state != COMMAND_STATE_DATA &&
@@ -1231,7 +1328,7 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 		/* Overlapped tag found */
 		if (tmp_cmdiu->tag == tag) {
-			spin_unlock_irqrestore(&(udev->ucommon->common->lock),
+			spin_unlock_irqrestore(&(udev->ucommon->lock),
 					       flags);
 			goto overlapped_tag;
 		}
@@ -1244,12 +1341,12 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 
 		/* Overlapped tag found */
 		if (tmp_tmiu->tag == tag) {
-			spin_unlock_irqrestore(&(udev->ucommon->common->lock),
+			spin_unlock_irqrestore(&(udev->ucommon->lock),
 					       flags);
 			goto overlapped_tag;
 		}
 	}
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 	/* No overlapped tag */
 	if (cmd_id == IU_ID_TASK_MANAGEMENT)
@@ -1258,42 +1355,43 @@ static int uasp_command_check(struct uasp_dev *udev, void **command)
 	return 1;
 
 overlapped_tag:
-	ERROR(udev->ucommon->common, "%s() - Overlapped tag found. "
+	ERROR(udev->ucommon, "%s() - Overlapped tag found. "
 				     "Aborting all\n", __func__);
 
 	run_lun_threads(udev, LUN_STATE_OVERLAPPED_TAG);
 
 	/* Wait for luns abort completion. Sleep if luns are in processing */
 	while (!all_lun_state_non_processing(udev)) {
-		DBG(udev->ucommon->common,
+		DBG(udev->ucommon,
 		    "%s() - Luns are in process. Going to sleep\n", __func__);
-		rc = sleep_thread(udev->ucommon->common);
+		rc = uasp_sleep_thread(udev->ucommon);
 		if (rc) {
-			ERROR(udev->ucommon->common,
-			      "%s() - sleep_thread failed! (%d)", __func__, rc);
+			ERROR(udev->ucommon,
+			      "%s() - uasp_sleep_thread failed! (%d)",
+			      __func__, rc);
 			return -EINVAL;
 		}
-		DBG(udev->ucommon->common, "%s() - Wakes up\n", __func__);
+		DBG(udev->ucommon, "%s() - Wakes up\n", __func__);
 		rc = 0;
 	}
 
 	/* Abort none-lun commands */
 	abort_commands(udev, &udev->cmd_queue, &udev->tm_func_queue,
-		       &(udev->ucommon->common->lock));
+		       &(udev->ucommon->lock));
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	udev->pending_requests = 0;
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 	if (cmd_id == IU_ID_TASK_MANAGEMENT) {
 		tmiu = *command;
 
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
-		tmiu->bh = get_buffhd(udev->ucommon->common->buffhds);
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
+		tmiu->bh = get_buffhd(udev->ucommon->ubufs);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 		if (!tmiu->bh) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s(): didnt manage to get buffers for tmiu!\n",
 			       __func__);
 			return -EINVAL;
@@ -1317,12 +1415,12 @@ overlapped_tag:
 	} else {
 		cmdiu = *command;
 
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
-		cmdiu->bh = get_buffhd(udev->ucommon->common->buffhds);
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
+		cmdiu->bh = get_buffhd(udev->ucommon->ubufs);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 		if (!cmdiu->bh) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s(): didnt manage to get buffers for cmdiu!\n",
 			       __func__);
 			return -EINVAL;
@@ -1364,7 +1462,7 @@ static void insert_tm_func_to_list(struct uasp_dev *udev, struct tm_iu *tmiu)
 	struct tm_iu *tmiu1;
 	struct uasp_lun *curlun;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	curlun = find_lun_by_id(udev, tmiu->lun);
 	tmiu->state = COMMAND_STATE_IDLE;
@@ -1449,10 +1547,10 @@ static void insert_cmd_to_list(struct uasp_dev *udev, struct cmd_iu *cmdiu)
 	struct cmd_iu *cmdiu1;
 	struct uasp_lun *curlun;
 
-	DBG(udev->ucommon->common, "%s(): cmdiu->lun = %p\n", __func__,
+	DBG(udev->ucommon, "%s(): cmdiu->lun = %p\n", __func__,
 	    cmdiu->lun);
 
-	DBG(udev->ucommon->common, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+	DBG(udev->ucommon, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
 		cmdiu->lun[0], cmdiu->lun[1], cmdiu->lun[2], cmdiu->lun[3],
 		cmdiu->lun[4], cmdiu->lun[5], cmdiu->lun[6], cmdiu->lun[7]);
 
@@ -1489,7 +1587,7 @@ static void insert_cmd_to_list(struct uasp_dev *udev, struct cmd_iu *cmdiu)
 
 	/* In the case when the queue is empty */
 	list_add_tail(&cmdiu->node, link);
-	DBG(udev->ucommon->common,
+	DBG(udev->ucommon,
 	     "%s() - Cmdiu is added to the tail of the queue\n", __func__);
 }
 
@@ -1510,7 +1608,7 @@ static int get_command(struct uasp_dev *udev)
 	int rc = 0;
 	void *command = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 queue_cmd_ep:
 	/* If command endpoint is not active, activate */
@@ -1525,11 +1623,11 @@ queue_cmd_ep:
 		udev->cmd_buff.outreq->short_not_ok = 1;
 		rc = usb_ep_queue(udev->command, udev->cmd_buff.outreq, 0);
 		if (rc) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s()usb_ep_queue failed = %d\n", __func__, rc);
 			udev->cmd_buff.state = BUF_STATE_EMPTY;
 		}
-		DBG(udev->ucommon->common, "%s() queued command request = %p\n",
+		DBG(udev->ucommon, "%s() queued command request = %p\n",
 		     __func__, udev->cmd_buff.outreq);
 		return rc;
 	}
@@ -1540,13 +1638,13 @@ queue_cmd_ep:
 	rc = uasp_command_check(udev, &command);
 
 	if (rc == 0) {
-		DBG(udev->ucommon->common, "%s() - Received a TMC IU\n",
+		DBG(udev->ucommon, "%s() - Received a TMC IU\n",
 		    __func__);
 		insert_tm_func_to_list(udev, (struct tm_iu *)command);
 		udev->cmd_buff.state = BUF_STATE_EMPTY;
 		goto queue_cmd_ep;
 	} else if (rc == 1) {
-		DBG(udev->ucommon->common, "%s() -Received a CMD IU\n",
+		DBG(udev->ucommon, "%s() -Received a CMD IU\n",
 		    __func__);
 		insert_cmd_to_list(udev, (struct cmd_iu *)command);
 		udev->cmd_buff.state = BUF_STATE_EMPTY;
@@ -1567,9 +1665,9 @@ int all_lun_state_non_processing(struct uasp_dev *udev)
 	struct uasp_lun *curlun;
 	int i;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
-	for (i = 0; i < udev->ucommon->common->nluns; ++i) {
+	for (i = 0; i < udev->ucommon->nluns; ++i) {
 		curlun = &udev->ucommon->uluns[i];
 		if (curlun->lun_state > LUN_STATE_IDLE)
 			return 0;
@@ -1590,8 +1688,8 @@ static int pending_cmd_in_lun(void *data)
 	struct uasp_lun *curlun;
 	int i;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
-	for (i = 0; i < udev->ucommon->common->nluns; ++i) {
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
+	for (i = 0; i < udev->ucommon->nluns; ++i) {
 		curlun = &udev->ucommon->uluns[i];
 		if (curlun->pending_requests)
 			return 1;
@@ -1633,17 +1731,17 @@ void run_lun_threads(struct uasp_dev *udev, int state)
 	int i;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter. State = %d\n",
+	DBG(udev->ucommon, "%s() - Enter. State = %d\n",
 	    __func__, state);
 
-	for (i = 0; i < udev->ucommon->common->nluns; ++i) {
+	for (i = 0; i < udev->ucommon->nluns; ++i) {
 		curlun = &udev->ucommon->uluns[i];
 		spin_lock_irqsave(&(curlun->lock), flags);
 		curlun->lun_state = state;
 		wakeup_lun_thread(curlun);
 		spin_unlock_irqrestore(&(curlun->lock), flags);
 	}
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 }
 
 /**
@@ -1667,7 +1765,7 @@ void abort_commands(struct uasp_dev *udev,
 	struct cmd_iu *cmdiu, *tmp_cmdiu;
 	struct tm_iu *tmiu, *tmp_tmiu;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (!cmd_queue)
 		goto tmiu_part;
@@ -1732,58 +1830,47 @@ tmiu_part:
 void do_uasp(struct uasp_dev *udev)
 {
 	unsigned long		flags;
-	struct fsg_dev		*fsg = &(udev->fsg_dev);
 	struct uasp_common	*ucommon = udev->ucommon;
 	int rc;
 
-	DBG(ucommon->common, "%s() - Enter\n", __func__);
-
-	spin_lock_irqsave(&(fsg->common->lock), flags);
-	if (!exception_in_progress(fsg->common))
-		fsg->common->state = FSG_STATE_COMMAND_PHASE;
-	spin_unlock_irqrestore(&(fsg->common->lock), flags);
+	DBG(ucommon, "%s() - Enter\n", __func__);
 
-	if (exception_in_progress(fsg->common))
+	if (uasp_exception_in_progress(ucommon))
 		return;
 
 	if (get_command(udev))
 		return;
 
-	spin_lock_irqsave(&(fsg->common->lock), flags);
-	if (!exception_in_progress(fsg->common))
-		fsg->common->state = FSG_STATE_DATA_PHASE;
-	spin_unlock_irqrestore(&(fsg->common->lock), flags);
-
-	if (exception_in_progress(fsg->common))
+	if (uasp_exception_in_progress(ucommon))
 		return;
 
-	spin_lock_irqsave(&(ucommon->common->lock), flags);
+	spin_lock_irqsave(&(ucommon->lock), flags);
 	udev->pending_requests = 0;
-	spin_unlock_irqrestore(&(ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(ucommon->lock), flags);
 
 	do_tmiu(udev, NULL);
-	if (exception_in_progress(fsg->common))
+	if (uasp_exception_in_progress(ucommon))
 		return;
 
 	do_cmdiu(udev, NULL);
-	if (exception_in_progress(fsg->common))
+	if (uasp_exception_in_progress(ucommon))
 		return;
 
 	remove_completed_commands(udev, &udev->cmd_queue, &udev->tm_func_queue);
 
-	spin_lock_irqsave(&(fsg->common->lock), flags);
-	if (!exception_in_progress(fsg->common)) {
-		fsg->common->state = FSG_STATE_IDLE;
-		spin_unlock_irqrestore(&(fsg->common->lock), flags);
+	spin_lock_irqsave(&(ucommon->lock), flags);
+	if (!uasp_exception_in_progress(ucommon)) {
+		ucommon->state = UASP_STATE_IDLE;
+		spin_unlock_irqrestore(&(ucommon->lock), flags);
 		run_lun_threads(udev, LUN_STATE_PROCESSING);
 	} else
-		spin_unlock_irqrestore(&(fsg->common->lock), flags);
+		spin_unlock_irqrestore(&(ucommon->lock), flags);
 
 	rc = 0;
 	while (!rc) {
 		/* If exception is in progress */
-		if (exception_in_progress(ucommon->common)) {
-			DBG(ucommon->common,
+		if (uasp_exception_in_progress(ucommon)) {
+			DBG(ucommon,
 			    "%s() - Exception is in progress\n", __func__);
 			return;
 		}
@@ -1791,39 +1878,39 @@ void do_uasp(struct uasp_dev *udev)
 		/* Sleep if luns are in processing */
 		rc = all_lun_state_non_processing(udev);
 		if (!rc) {
-			DBG(ucommon->common,
+			DBG(ucommon,
 			    "%s() - Luns are in process\n", __func__);
 			goto sleep;
 		}
 
 		/* Wake up if command is received */
 		if (udev->cmd_buff.state == BUF_STATE_FULL) {
-			DBG(ucommon->common,
+			DBG(ucommon,
 			    "%s() - Command is received\n", __func__);
 			return;
 		}
 
 		/* Wake up if there are pending requests in luns */
 		if (pending_cmd_in_lun(udev)) {
-			DBG(ucommon->common,
+			DBG(ucommon,
 			    "%s() - Pending requests in LUN\n", __func__);
 			return;
 		}
 
 		/* Wake up if there are pending requests */
 		if (udev->pending_requests) {
-			DBG(ucommon->common,
+			DBG(ucommon,
 			    "%s() - Pending requests in device\n",
 			     __func__);
 			return;
 		}
 sleep:
 		/* Try to sleep */
-		DBG(ucommon->common, "%s() - Going to sleep\n", __func__);
-		rc = sleep_thread(fsg->common);
+		DBG(ucommon, "%s() - Going to sleep\n", __func__);
+		rc = uasp_sleep_thread(ucommon);
 		if (rc)
 			return;
-		DBG(ucommon->common, "%s() - Wakes up\n", __func__);
+		DBG(ucommon, "%s() - Wakes up\n", __func__);
 
 		rc = 0;
 	}
@@ -1867,7 +1954,7 @@ static int lun_exception_in_progress(struct uasp_lun *curlun)
 static void handle_lun_exception(struct uasp_dev *udev, struct uasp_lun *curlun)
 {
 	unsigned long flags;
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Abort all commands and remove them from lists */
 	abort_commands(udev, &curlun->cmd_queue, &curlun->tm_func_queue,
@@ -1890,7 +1977,7 @@ static void handle_lun_exception(struct uasp_dev *udev, struct uasp_lun *curlun)
 		break;
 	}
 	spin_unlock_irqrestore(&(curlun->lock), flags);
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 }
 
 /**
@@ -1915,15 +2002,15 @@ static int uasp_lun_thread(void *param)
 	if (!ulun)
 		return  -1;
 	udev = ulun->dev;
-	DBG(udev->ucommon->common, "%s() - Enter for lun_id = %d\n", __func__,
+	DBG(udev->ucommon, "%s() - Enter for lun_id = %d\n", __func__,
 					ulun->lun_id[7]);
 
 	while (ulun->lun_state != LUN_STATE_TERMINATED) {
-		DBG(udev->ucommon->common, "%s() - Wakes up\n", __func__);
+		DBG(udev->ucommon, "%s() - Wakes up\n", __func__);
 
 		if (lun_exception_in_progress(ulun)) {
-			DBG(udev->ucommon->common,
-			    "%s() - exception_in_progress!"
+			DBG(udev->ucommon,
+			    "%s() - uasp_exception_in_progress!"
 			      " ulun->lun_state=%d\n", __func__,
 			    ulun->lun_state);
 			handle_lun_exception(udev, ulun);
@@ -1934,8 +2021,8 @@ static int uasp_lun_thread(void *param)
 		 * If the main thread isn't running, no need to run lun threads
 		 * as well.
 		 */
-		if (!udev->ucommon->common->running) {
-			DBG(udev->ucommon->common,
+		if (!udev->ucommon->running) {
+			DBG(udev->ucommon,
 			    "%s() - uasp thread main thread not running - "
 			    "going to sleep...\n", __func__);
 			sleep_lun_thread(ulun);
@@ -1959,22 +2046,22 @@ static int uasp_lun_thread(void *param)
 		if (lun_exception_in_progress(ulun))
 			continue;
 
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
 		if (!lun_exception_in_progress(ulun)) {
 			ulun->lun_state = LUN_STATE_IDLE;
-			wakeup_thread(udev->ucommon->common);
+			uasp_wakeup_thread(udev->ucommon);
 		}
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
-		DBG(udev->ucommon->common, "%s() - Going to sleep\n", __func__);
+		DBG(udev->ucommon, "%s() - Going to sleep\n", __func__);
 		sleep_lun_thread(ulun);
 		continue;
 	}
 
-	DBG(udev->ucommon->common, "uasp lun main loop: exiting\n");
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	DBG(udev->ucommon, "uasp lun main loop: exiting\n");
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	ulun->lun_thread_task = NULL;
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 	/* Let the unbind and cleanup routines know the thread has exited */
 	complete_and_exit(&ulun->thread_notifier, 0);
 	return 0;
@@ -1993,8 +2080,6 @@ static int uasp_lun_thread(void *param)
 static int uasp_main_thread(void *param)
 {
 	struct uasp_common *ucommon = (struct uasp_common *)param;
-	struct fsg_common  *common = ucommon->common;
-
 	/*
 	 * Allow the thread to be killed by a signal, but set the signal mask
 	 * to block everything but INT, TERM, KILL, and USR1.
@@ -2015,41 +2100,41 @@ static int uasp_main_thread(void *param)
 	set_fs(get_ds());
 
 		/* The main loop */
-	while (common->state != FSG_STATE_TERMINATED) {
-		DBG(common, "uasp main loop: continuing\n");
-		if (exception_in_progress(ucommon->common) ||
+	while (ucommon->state != UASP_STATE_TERMINATED) {
+		DBG(ucommon, "uasp main loop: continuing\n");
+		if (uasp_exception_in_progress(ucommon) ||
 		    signal_pending(current)) {
-			DBG(common, "uasp thread main loop: exception\n");
+			DBG(ucommon, "uasp thread main loop: exception\n");
 			handle_uasp_exception(ucommon);
 			continue;
 		}
 
-		if (!common->running) {
-			DBG(common, "uasp thread main loop: not running\n");
-			sleep_thread(ucommon->common);
+		if (!ucommon->running) {
+			DBG(ucommon, "uasp thread main loop: not running\n");
+			uasp_sleep_thread(ucommon);
 			continue;
 		}
 		do_uasp(ucommon->udev);
 	}
 
-	DBG(common, "uasp main loop: exiting\n");
+	DBG(ucommon, "uasp main loop: exiting\n");
 
-	spin_lock_irq(&common->lock);
-	common->thread_task = NULL;
-	spin_unlock_irq(&common->lock);
+	spin_lock_irq(&ucommon->lock);
+	ucommon->thread_task = NULL;
+	spin_unlock_irq(&ucommon->lock);
 
-	if (!common->ops || !common->ops->thread_exits ||
-	    common->ops->thread_exits(common) < 0) {
+	if (!ucommon->ops || !ucommon->ops->thread_exits ||
+	    ucommon->ops->thread_exits(ucommon) < 0) {
 		struct uasp_lun	*ulun = ucommon->uluns;
 		unsigned i ;
-		down_write(&common->filesem);
-		for (i = 0; i < common->nluns; i++, ulun++)
+		down_write(&ucommon->filesem);
+		for (i = 0; i < ucommon->nluns; i++, ulun++)
 			close_lun(ulun);
-		up_write(&common->filesem);
+		up_write(&ucommon->filesem);
 	}
 
 	/* Let the unbind and cleanup routines know the thread has exited */
-	complete_and_exit(&common->thread_notifier, 0);
+	complete_and_exit(&ucommon->thread_notifier, 0);
 
 	return 0;
 }
@@ -2063,74 +2148,107 @@ static int uasp_main_thread(void *param)
  * This function should be called after (struct fsg_common) common was already
  * initiated by fsg_common_init
  */
-static struct uasp_common *uasp_common_init(struct fsg_common *common,
-					  struct usb_composite_dev *cdev,
-					    struct fsg_config *cfg)
+static struct uasp_common *uasp_common_init(struct msg_common_data *common,
+					  struct usb_composite_dev *cdev)
 {
 	struct fsg_lun *flun;
 	struct uasp_lun *ulun;
 	struct uasp_common	*ucommon;
-	int nluns = common->nluns;
-	int i, rc;
+	int i, rc = 0;
 
-	if (!common || !cdev || !cfg)
+	if (!common || !cdev)
 		return NULL;
 
-	DBG(common, "%s() - Enter\n", __func__);
+	DBG(cdev, "%s() - Enter\n", __func__);
 
 	ucommon = kzalloc(sizeof *ucommon, GFP_KERNEL);
 	if (unlikely(!ucommon))
 		return NULL;
 
-	/* Save reference to fsg_common structure in ucommon */
-	ucommon->common = common;
-
-	/* Allocate the uLUNs and init them according to fsg_common luns */
-	ulun = kzalloc(nluns * sizeof *ulun, GFP_KERNEL);
+	ucommon->msg_common = common;
+	/*Allocate the uLUNs and init them according to fsg_common luns */
+	ulun = kzalloc(common->config.nluns * sizeof *ulun, GFP_KERNEL);
 	if (!ulun) {
 		kfree(ucommon);
 		return ERR_PTR(-ENOMEM);
 	}
 	ucommon->uluns = ulun;
+	ucommon->nluns = common->config.nluns;
 
 	/* Create the reference between ulun and fsg_lun */
-	for (i = 0, flun = common->luns; i < nluns;
+	for (i = 0, flun = common->fcommon->luns; i < common->config.nluns;
 				++i, ++flun, ++ulun)
 		ulun->lun = flun;
 
+	ucommon->ops = common->config.uasp_ops;
+	ucommon->gadget = cdev->gadget;
+	ucommon->cdev = cdev;
+	ucommon->config_mutex = &(common->config.config_mutex);
+
 	/*
-	 * Buffers in ubufs are static -- no need for additional allocation.
-	 * Connect each ubuf to fsg_buff from the buffhds cyclic list
+	 * Allocate the buffers in ubufs and connect each ubuf to fsg_buff
+	 * from the buffhds cyclic list
 	 */
+	ucommon->ubufs = kzalloc(sizeof(struct uasp_buff)*fsg_num_buffers,
+				 GFP_KERNEL);
+	if (!ucommon->ubufs)
+		goto error_release;
+
 	for (i = 0; i < fsg_num_buffers; i++) {
-		ucommon->ubufs[i].fsg_buff = &(common->buffhds[i]);
+		ucommon->ubufs[i].fsg_buff = &(common->fcommon->buffhds[i]);
 		ucommon->ubufs[i].ep = NULL;
 		ucommon->ubufs[i].stream_id = 0;
 	}
 
-	kref_init(&ucommon->ref);
+	/* Prepare inquiryString */
+	if (common->config.release != 0xffff) {
+		i = common->config.release;
+	} else {
+		i = usb_gadget_controller_number(cdev->gadget);
+		if (i >= 0) {
+			i = 0x0300 + i;
+		} else {
+			WARNING(ucommon, "controller '%s' not recognized\n",
+				cdev->gadget->name);
+			i = 0x0399;
+		}
+	}
+	snprintf(ucommon->inquiry_string, sizeof ucommon->inquiry_string,
+		 "%-8s%-16s%04x", common->config.vendor_name ?: "Linux",
+		 /* Assume product name dependent on the first LUN */
+		 common->config.product_name ?: (common->fcommon->luns->cdrom
+				     ? "File-Stor UAS-Gadget"
+				     : "File-CD UAS-Gadget"),
+		 i);
+
 	/* Tell the thread to start working */
-	common->thread_task =
+	ucommon->thread_task =
 		kthread_create(uasp_main_thread, (void *)ucommon,
-			       cfg->thread_name ?: "file-storage-UASP");
-	if (IS_ERR(common->thread_task)) {
-		rc = PTR_ERR(common->thread_task);
+			       common->config.thread_name ?:
+			       "file-storage-UASP");
+	if (IS_ERR(ucommon->thread_task)) {
+		rc = PTR_ERR(ucommon->thread_task);
 		goto error_release;
 	}
 
 
 	/* Information */
-	INFO(common, UASP_DRIVER_DESC ", version: " UASP_DRIVER_VERSION "\n");
-	DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
+	INFO(ucommon, UASP_DRIVER_DESC ", version: " UASP_DRIVER_VERSION "\n");
+	DBG(ucommon, "I/O thread pid: %d created for UASP Gdaget\n",
+	    task_pid_nr(ucommon->thread_task));
+
+	kref_init(&ucommon->ref);
+	init_waitqueue_head(&ucommon->uasp_wait);
+	init_completion(&ucommon->thread_notifier);
 
-	wake_up_process(common->thread_task);
+	wake_up_process(ucommon->thread_task);
 
 	return ucommon;
 
 error_release:
-	common->state = FSG_STATE_TERMINATED;	/* The thread is dead */
+	ucommon->state = UASP_STATE_TERMINATED;	/* The thread is dead */
 	/* Call uasp_common_release() directly, ref might be not initialised */
-	uasp_common_release(&common->ref);
+	uasp_common_release(&ucommon->ref);
 	return ERR_PTR(rc);
 }
 
@@ -2151,7 +2269,7 @@ static int finish_lun_init(struct uasp_dev *udev)
 		return -EIO;
 
 	for (i = 0, ulun = udev->ucommon->uluns;
-	       i < udev->ucommon->common->nluns; i++, ulun++) {
+	       i < udev->ucommon->nluns; i++, ulun++) {
 		/* TODO: this is a workaround, fix later */
 		memset(ulun->lun_id, 0, 8);
 		ulun->lun_id[0] = i;
@@ -2163,8 +2281,8 @@ static int finish_lun_init(struct uasp_dev *udev)
 
 		/* Create and start lun threads */
 		sprintf(thread_name, "uasp-lun-thread%d", i);
-		DBG(udev->ucommon->common,
-		    "creating & starting lun thread: thread_name = %s\n",
+		DBG(udev->ucommon,
+		    "creating lun thread: thread_name = %s\n",
 		    thread_name);
 
 		ulun->lun_thread_task = kthread_create(uasp_lun_thread,
@@ -2177,7 +2295,6 @@ static int finish_lun_init(struct uasp_dev *udev)
 		init_completion(&ulun->thread_notifier);
 		wake_up_process(ulun->lun_thread_task);
 	}
-	INFO(udev->ucommon->common, "All lun threads are started\n");
 	return rc;
 
 err_lun_init:
@@ -2193,71 +2310,110 @@ err_lun_init:
  *
  * Return 0 on succeed, error code on failure
  *
- * TODO: Add fall back to usb_ep_autoconfig() if usb_ep_autoconfig_ss() fails.
- *       In that case mark somehow that we can only operate in HS mode
  */
 static int __init uasp_bind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct uasp_dev		*uaspd = uaspd_from_func(f);
-	struct fsg_dev		*fsgd = &(uaspd->fsg_dev);
 	struct usb_gadget	*gadget = c->cdev->gadget;
 	int			rc;
 	int			i;
+	int			hs_mode = 0;
 	struct usb_ep		*ep;
 
-	fsgd->common->gadget = gadget;
+	uaspd->ucommon->gadget = gadget;
 
 	/* Allocate new interface */
 	i = usb_interface_id(c, f);
 	if (i < 0)
 		return i;
 	uasp_intf_desc.bInterfaceNumber = i;
-	fsgd->interface_number = i;
 
-	/* Find all the endpoints we will use */
-	ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bulk_in_desc,
-				  &uasp_bulk_in_ep_comp_desc);
-	if (!ep)
-		goto autoconf_fail;
+	if (gadget_is_superspeed(c->cdev->gadget)) {
+		ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bulk_in_desc,
+					  &uasp_bulk_in_ep_comp_desc);
+		if (!ep) {
+			ERROR(uaspd->ucommon,
+			      "%s(): Unable to autoconfigure endpoints"
+			      " in SS mode. Falling back to HS mode...\n",
+			      __func__);
+			goto fall_back_to_hs;
+		}
+	} else {
+fall_back_to_hs:
+		hs_mode = 1;
+		uaspd->op_mode = HS_UASP_MODE;
+		uaspd->forced_hs_mode = 1;
+		ep = usb_ep_autoconfig(gadget, &uasp_fs_bulk_in_desc);
+		if (!ep)
+			goto autoconf_fail;
+	}
 	ep->driver_data = uaspd;	/* claim the endpoint */
-	fsgd->bulk_in = ep;
+	uaspd->bulk_in = ep;
 
-	ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bulk_out_desc,
+	if (hs_mode)
+		ep = usb_ep_autoconfig(gadget, &uasp_fs_bulk_out_desc);
+	else
+		ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bulk_out_desc,
 				  &uasp_bulk_out_ep_comp_desc);
 	if (!ep)
 		goto autoconf_fail;
 	ep->driver_data = uaspd;	/* claim the endpoint */
-	fsgd->bulk_out = ep;
+	uaspd->bulk_out = ep;
 
-	ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_status_in_desc,
+	if (hs_mode)
+		ep = usb_ep_autoconfig(gadget, &uasp_fs_status_in_desc);
+	else
+		ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_status_in_desc,
 				  &uasp_status_in_ep_comp_desc);
 	if (!ep)
 		goto autoconf_fail;
 	ep->driver_data = uaspd;	/* claim the endpoint */
 	uaspd->status = ep;
 
-	ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_command_out_desc,
+	if (hs_mode)
+		ep = usb_ep_autoconfig(gadget, &uasp_fs_command_out_desc);
+	else
+		ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_command_out_desc,
 				  &uasp_command_out_ep_comp_desc);
 	if (!ep)
 		goto autoconf_fail;
 	ep->driver_data = uaspd;	/* claim the endpoint */
 	uaspd->command = ep;
 
-	/* Assume endpoint addresses are the same for both speeds */
-	uasp_bulk_in_desc.bEndpointAddress =
-		uasp_ss_bulk_in_desc.bEndpointAddress;
-	uasp_bulk_out_desc.bEndpointAddress =
-		uasp_ss_bulk_out_desc.bEndpointAddress;
-	uasp_status_in_desc.bEndpointAddress =
-		uasp_ss_status_in_desc.bEndpointAddress;
-	uasp_command_out_desc.bEndpointAddress =
-		uasp_ss_command_out_desc.bEndpointAddress;
-	f->ss_descriptors = uasp_ss_function_desc;
+	if (hs_mode) {
+		if (gadget_is_dualspeed(c->cdev->gadget)) {
+			uasp_hs_bulk_in_desc.bEndpointAddress =
+				uasp_fs_bulk_in_desc.bEndpointAddress;
+			uasp_hs_bulk_out_desc.bEndpointAddress =
+				uasp_fs_bulk_out_desc.bEndpointAddress;
+			uasp_hs_status_in_desc.bEndpointAddress =
+				uasp_fs_status_in_desc.bEndpointAddress;
+			uasp_hs_command_out_desc.bEndpointAddress =
+				uasp_fs_command_out_desc.bEndpointAddress;
+		}
+	} else { /* SuperSpeed configuration sucseeded */
+		uasp_fs_bulk_in_desc.bEndpointAddress =
+			uasp_ss_bulk_in_desc.bEndpointAddress;
+		uasp_hs_bulk_in_desc.bEndpointAddress =
+			uasp_ss_bulk_in_desc.bEndpointAddress;
+		uasp_fs_bulk_out_desc.bEndpointAddress =
+			uasp_ss_bulk_out_desc.bEndpointAddress;
+		uasp_hs_bulk_out_desc.bEndpointAddress =
+			uasp_ss_bulk_out_desc.bEndpointAddress;
+		uasp_fs_status_in_desc.bEndpointAddress =
+			uasp_ss_status_in_desc.bEndpointAddress;
+		uasp_hs_status_in_desc.bEndpointAddress =
+			uasp_ss_status_in_desc.bEndpointAddress;
+		uasp_fs_command_out_desc.bEndpointAddress =
+			uasp_ss_command_out_desc.bEndpointAddress;
+		uasp_hs_command_out_desc.bEndpointAddress =
+			uasp_ss_command_out_desc.bEndpointAddress;
+	}
 
 	return 0;
 
 autoconf_fail:
-	ERROR(fsgd->common, "unable to autoconfigure all endpoints\n");
+	ERROR(uaspd->ucommon, "unable to autoconfigure all endpoints\n");
 	rc = -ENOTSUPP;
 	return rc;
 }
@@ -2265,14 +2421,28 @@ autoconf_fail:
 static void uasp_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct uasp_dev		*uaspd = uaspd_from_func(f);
+	struct uasp_lun *ulun;
+	int i;
+
+	DBG(uaspd->ucommon, "%s() - Enter\n", __func__);
 
-	DBG(uaspd->fsg_dev.common, "unbind\n");
-	if (uaspd->fsg_dev.common->fsg == &(uaspd->fsg_dev)) {
-		uaspd->fsg_dev.common->new_fsg = NULL;
-		raise_exception(uaspd->fsg_dev.common, FSG_STATE_CONFIG_CHANGE);
+	/* First stop all lun threads */
+	run_lun_threads(uaspd, LUN_STATE_EXIT);
+	for (i = 0; i < uaspd->ucommon->nluns; i++) {
+		ulun = &(uaspd->ucommon->uluns[i]);
+		if (ulun->lun_state != LUN_STATE_TERMINATED) {
+			wait_for_completion(&ulun->thread_notifier);
+			/* The cleanup routine waits for this completion also */
+			complete(&ulun->thread_notifier);
+		}
+	}
+
+	DBG(uaspd->ucommon, "%s(): Stoped all LUN threads\n", __func__);
+	if (uaspd->ucommon->udev) {
+		uaspd->ucommon->new_udev = NULL;
+		uasp_raise_exception(uaspd->ucommon, UASP_STATE_CONFIG_CHANGE);
 		/* TODO: make interruptible or killable somehow? */
-		wait_event(uaspd->fsg_dev.common->fsg_wait,
-			   !uaspd->ucommon->common->fsg);
+		wait_event(uaspd->ucommon->uasp_wait, !uaspd->ucommon->udev);
 	}
 	uasp_common_put(uaspd->ucommon);
 	kfree(uaspd->cmd_buff.buf);
@@ -2281,18 +2451,32 @@ static void uasp_unbind(struct usb_configuration *c, struct usb_function *f)
 
 static int uasp_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
-	struct fsg_dev *fsg = fsg_from_func(f);
-	fsg->common->new_fsg = fsg;
-	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
-	return 0;
+	struct uasp_dev *udev = uaspd_from_func(f);
+	int i;
+
+	if (!udev->ucommon->udev) {
+		struct uasp_lun *ulun;
+		DBG(udev->ucommon,
+		    "%s() - Waking up UASP main thread\n", __func__);
+		wake_up_process(udev->ucommon->thread_task);
+
+		/* Wakeup LUN threads */
+		for (i = 0, ulun = udev->ucommon->uluns;
+			       i < udev->ucommon->nluns; i++, ulun++)
+			wake_up_process(ulun->lun_thread_task);
+		INFO(udev->ucommon, "All lun threads are started\n");
+	}
+	udev->ucommon->new_udev = udev;
+	uasp_raise_exception(udev->ucommon, UASP_STATE_CONFIG_CHANGE);
+	return USB_GADGET_DELAYED_STATUS;
 }
 
 static void uasp_disable(struct usb_function *f)
 {
 	struct uasp_dev *udev = uaspd_from_func(f);
 
-	udev->fsg_dev.common->new_fsg = NULL;
-	raise_exception(udev->fsg_dev.common, FSG_STATE_CONFIG_CHANGE);
+	udev->ucommon->new_udev = NULL;
+	uasp_raise_exception(udev->ucommon, UASP_STATE_CONFIG_CHANGE);
 }
 
 /**
@@ -2309,7 +2493,6 @@ static void uasp_disable(struct usb_function *f)
  */
 static int uasp_add(struct usb_composite_dev *cdev,
 		   struct usb_configuration *c,
-		   struct fsg_common *common,
 		   struct uasp_common *ucommon)
 {
 	struct uasp_dev *uaspd;
@@ -2319,18 +2502,17 @@ static int uasp_add(struct usb_composite_dev *cdev,
 	if (unlikely(!uaspd))
 		return -ENOMEM;
 
-	uaspd->fsg_dev.function.name		= UASP_DRIVER_DESC;
-	uaspd->fsg_dev.function.strings		= fsg_strings_array;
-	uaspd->fsg_dev.function.descriptors	= uasp_hs_function_desc;
-	uaspd->fsg_dev.function.hs_descriptors	= uasp_hs_function_desc;
-	uaspd->fsg_dev.function.bind		= uasp_bind;
-	uaspd->fsg_dev.function.unbind		= uasp_unbind;
-	uaspd->fsg_dev.function.set_alt		= uasp_set_alt;
-	uaspd->fsg_dev.function.disable		= uasp_disable;
-
-	uaspd->fsg_dev.common			= common;
+	uaspd->function.name		= UASP_DRIVER_DESC;
+	uaspd->function.strings		= fsg_strings_array;
+	uaspd->function.descriptors	= uasp_fs_function_desc;
+	uaspd->function.hs_descriptors	= uasp_hs_function_desc;
+	uaspd->function.ss_descriptors	= uasp_ss_function_desc;
+	uaspd->function.bind		= uasp_bind;
+	uaspd->function.unbind		= uasp_unbind;
+	uaspd->function.set_alt		= uasp_set_alt;
+	uaspd->function.disable		= uasp_disable;
 
-	uaspd->ucommon = ucommon;
+	uaspd->ucommon			= ucommon;
 
 	/* Init the command and status buffers */
 	uaspd->cmd_buff.buf = kmalloc(FSG_BUFLEN, GFP_KERNEL);
@@ -2339,7 +2521,6 @@ static int uasp_add(struct usb_composite_dev *cdev,
 		goto uasp_add_err;
 	}
 
-	ucommon->udev = uaspd;
 	rc = finish_lun_init(uaspd);
 	if (rc)
 		goto uasp_add_err;
@@ -2353,7 +2534,7 @@ static int uasp_add(struct usb_composite_dev *cdev,
 	 * recovery we increment it only when call to usb_add_function() was
 	 * successful.
 	 */
-	rc = usb_add_function(c, &uaspd->fsg_dev.function);
+	rc = usb_add_function(c, &uaspd->function);
 
 	if (likely(rc == 0))
 		kref_get(&ucommon->ref);
diff --git a/drivers/usb/gadget/f_uasp.h b/drivers/usb/gadget/f_uasp.h
index 63ade00..3f1e042 100644
--- a/drivers/usb/gadget/f_uasp.h
+++ b/drivers/usb/gadget/f_uasp.h
@@ -18,6 +18,15 @@
 #define _F_UASP_H
 
 #include <linux/kernel.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/completion.h>
+#include <linux/kref.h>
+#include <linux/kthread.h>
+#include <linux/rwsem.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 
@@ -79,30 +88,80 @@ struct uasp_buff {
 	unsigned		stream_id:16;
 };
 
+struct uasp_common;
+struct uasp_lun;
+struct uasp_dev;
+
+enum uasp_state {
+	UASP_STATE_IDLE = 0,
+	UASP_STATE_RESET,
+	UASP_STATE_INTERFACE_CHANGE,
+	UASP_STATE_CONFIG_CHANGE,
+	UASP_STATE_DISCONNECT,
+	UASP_STATE_EXIT,
+	UASP_STATE_TERMINATED
+};
+
 /**
  * struct uasp_common - Common data shared by all UASP devices
+ * @gadget: pointer to the gadget driver
  * @udev: Programming view of uasp device.
- * @common: points to fsg_common in fsg_dev
- * @ubufs: buffers to be used by the uasp device. Each element in
- *	ubufs[i].fsg_buff points to a fsg_buffhd struct from fsg_common data
- *	structure
- * @uluns: luns of the uasp device. Each element in uluns[i].lun points to a
- *	fsg_lun array element from fsg_common data structure
- *
- * Extends the struct fsg_common structure.
+ * @new_udev: Programming view of new uasp device. Used in configuration switch
+ * @uasp_wait: wait queue
+ * @filesem: filesem protects: backing files in use
+ * @lock: lock protects: state, all the req_busy's
+ * @ubufs: buffers to be used by the uasp device.
+ * @uluns: luns of the uasp device.
+ * @nluns: number of luns
+ * @state: For exception handling
+ * @running: set to 1 if the UASP interface is active
+ * @ops: Callback functions.
+ * @private_data: Gadget's private data.
+ * @inquiry_string: Vendor (8 chars), product (16 chars), release (4 hexadecimal
+ *  digits) and NULL byte
+ * @ref:
  */
 struct uasp_common {
-	struct uasp_dev		*udev;
-	struct fsg_common	*common;
-	struct uasp_buff	ubufs[fsg_num_buffers];
+	struct usb_gadget	*gadget;
+	struct usb_composite_dev *cdev;
+	struct msg_common_data	*msg_common;
+	struct uasp_dev		*udev, *new_udev;
+	wait_queue_head_t	uasp_wait;
+
+	struct mutex		*config_mutex;
+
+	struct rw_semaphore	filesem;
+	spinlock_t		lock;
+
+	struct uasp_buff	*ubufs;
 	struct uasp_lun		*uluns;
+
+	unsigned int		nluns;
+	enum uasp_state		state;
+	unsigned int		running:1;
+
+	int			thread_wakeup_needed;
+	struct completion	thread_notifier;
+	struct task_struct	*thread_task;
+
+	const struct fsg_operations	*ops;
+
+	char inquiry_string[8 + 16 + 4 + 1];
+
 	struct kref		ref;
 };
 
 /**
  * struct uasp_dev - Programming view of the uasp device
- * @fsg_dev: pointer to the fsg_dev this struct extends
+ * @function: usb function
+ * @gadget: Copy of cdev->gadget
  * @ucommon: pointer to the common data of the device
+ * @bulk_in_enabled: set to 1 when BULK IN ep is enabled
+ * @bulk_out_enabled: set to 1 when BULK OUT ep is enabled
+ * @cmd_enabled: set to 1 when COMMAND ep is enabled
+ * @status_enabled: set to 1 when STATUS ep is enabled
+ * @bulk_in: BULK IN endpoint
+ * @bulk_out: BULK OUT endpoint
  * @status: status endpoint
  * @command: command endpoint
  * @cmd_buff: buffer used for receiving commannd IUs
@@ -117,19 +176,27 @@ struct uasp_common {
  * Extends the struct fsg_dev structure.
  */
 struct uasp_dev {
-	struct fsg_dev		fsg_dev;
-
+	struct usb_function	function;
+	struct usb_gadget	*gadget;
 	struct uasp_common	*ucommon;
+
+	unsigned int		bulk_in_enabled:1;
+	unsigned int		bulk_out_enabled:1;
+	unsigned int		cmd_enabled:1;
+	unsigned int		status_enabled:1;
+
+	struct usb_ep		*bulk_in;
+	struct usb_ep		*bulk_out;
 	struct usb_ep		*status;
 	struct usb_ep		*command;
+
 	struct fsg_buffhd	cmd_buff;
 
-#define HS_UASP_MODE		0
-#define SS_UASP_MODE		1
+#define UASP_MODE_UNSET		0
+#define HS_UASP_MODE		1
+#define SS_UASP_MODE		2
 	uint8_t			op_mode;
-
-	unsigned int		cmd_enabled;
-	unsigned int		status_enabled;
+	unsigned int		forced_hs_mode;
 
 	struct list_head	cmd_queue;
 	struct list_head	tm_func_queue;
@@ -453,4 +520,5 @@ int all_lun_state_non_processing(struct uasp_dev *udev);
  */
 void close_lun(struct uasp_lun *ulun);
 
+int uasp_sleep_thread(struct uasp_common *common);
 #endif /* _F_UASP_H */
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index b7d9e7e..5e4c3d2 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -28,9 +28,7 @@
  */
 
 
-#include <linux/kernel.h>
 #include <linux/utsname.h>
-#include <linux/usb/ch9.h>
 
 
 /*-------------------------------------------------------------------------*/
@@ -95,9 +93,11 @@ static struct fsg_module_parameters mod_data = {
 FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
 
 static unsigned long msg_registered;
+static struct msg_common_data msg_common;
+
 static void msg_cleanup(void);
 
-static int msg_thread_exits(struct fsg_common *common)
+static int msg_thread_exits(void *common)
 {
 	msg_cleanup();
 	return 0;
@@ -105,13 +105,9 @@ static int msg_thread_exits(struct fsg_common *common)
 
 static int __init msg_do_config(struct usb_configuration *c)
 {
-	static const struct fsg_operations ops = {
-		.thread_exits = msg_thread_exits,
-	};
 	static struct fsg_common common;
 
 	struct fsg_common *retp;
-	struct fsg_config config;
 	int ret;
 
 	if (gadget_is_otg(c->cdev->gadget)) {
@@ -119,14 +115,11 @@ static int __init msg_do_config(struct usb_configuration *c)
 		c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 	}
 
-	fsg_config_from_params(&config, &mod_data);
-	config.ops = &ops;
-
 	/* Init fsg_common and start the fsg main thread */
-	retp = fsg_common_init(&common, c->cdev, &config, 1);
+	retp = fsg_common_init(&common, c->cdev, &msg_common.config);
 	if (IS_ERR(retp))
 		return PTR_ERR(retp);
-
+	common.msg_common = &msg_common;
 	ret = fsg_bind_config(c->cdev, c, &common);
 	fsg_common_put(&common);
 	return ret;
@@ -140,25 +133,14 @@ static struct usb_configuration msg_config_driver = {
 
 static int __init uasp_do_config(struct usb_configuration *c)
 {
-	static const struct fsg_operations ops = {
-		.thread_exits = msg_thread_exits,
-	};
-
-	struct fsg_common *fcommon;
 	struct uasp_common *ucommon;
-	struct fsg_config config;
 	int ret = 0;
 
-	fsg_config_from_params(&config, &mod_data);
-	config.ops = &ops;
-	fcommon = fsg_common_init(0, c->cdev, &config, 0);
-	if (IS_ERR(fcommon))
-		return PTR_ERR(fcommon);
-
-	ucommon = uasp_common_init(fcommon, c->cdev, &config);
+	ucommon = uasp_common_init(&msg_common, c->cdev);
 	if (IS_ERR(ucommon))
 		return PTR_ERR(ucommon);
-	ret = uasp_add(c->cdev, c, fcommon, ucommon);
+	msg_common.ucommon = ucommon;
+	ret = uasp_add(c->cdev, c, ucommon);
 	uasp_common_put(ucommon);
 
 	return ret;
@@ -174,36 +156,38 @@ static struct usb_configuration uasp_config_driver = {
 
 /****************************** Gadget Bind ******************************/
 
-bool use_uasp ;
-module_param(use_uasp, bool, S_IRUGO | S_IWUSR);
 static int __init msg_bind(struct usb_composite_dev *cdev)
 {
 	int status;
-
+	struct usb_function		*fsg_func;
+	static const struct fsg_operations ops = {
+		.thread_exits = msg_thread_exits,
+	};
 	dev_info(&cdev->gadget->dev,
 		 DRIVER_DESC ", version: " DRIVER_VERSION "\n");
 
-	if (use_uasp) {
-		/*
-		 * TODO: fix the bellow!
-		 * Right now the host always chooses the first configuration.
-		 * Untill this is fixed, if we want the device to opperate in
-		 * UASP mode we switch the configurations numbers
-		 */
-		msg_config_driver.bConfigurationValue = 2;
-		uasp_config_driver.bConfigurationValue = 1;
-		/* register uasp configuration */
-		status = usb_add_config(cdev, &uasp_config_driver,
-					uasp_do_config);
-		if (status < 0)
-			return status;
-	} else {
-		/* register our second configuration */
-		status = usb_add_config(cdev, &msg_config_driver,
-					msg_do_config);
-		if (status < 0)
-			return status;
-	}
+	fsg_config_from_params(&msg_common.config, &mod_data);
+	msg_common.config.ops = &ops;
+	msg_common.config.uasp_ops = &ops;
+	mutex_init(&msg_common.config.config_mutex);
+
+	/* register MS-BOT configuration */
+	status = usb_add_config(cdev, &msg_config_driver,
+				msg_do_config);
+	if (status < 0)
+		return status;
+
+	fsg_func = list_first_entry(&msg_config_driver.functions,
+						    struct usb_function,
+						    list);
+	msg_common.fcommon = (fsg_from_func(fsg_func))->common;
+
+	/* Register MS-UAS configuration */
+	status = usb_add_config(cdev, &uasp_config_driver, uasp_do_config);
+	if (status < 0)
+		return status;
+
+
 	set_bit(0, &msg_registered);
 	return 0;
 }
@@ -233,5 +217,9 @@ static void msg_cleanup(void)
 {
 	if (test_and_clear_bit(0, &msg_registered))
 		usb_composite_unregister(&msg_driver);
+	memset(&msg_common.config, 0, sizeof(struct fsg_config));
+
+	msg_common.fcommon = NULL;
+	msg_common.ucommon = NULL;
 }
 module_exit(msg_cleanup);
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 4937ad6..6e84b27 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -46,7 +46,7 @@
 /*
  * When USB_GADGET_DEBUG_FILES is defined the module param num_buffers
  * sets the number of pipeline buffers (length of the fsg_buffhd array).
- * The valid range of num_buffers is: num >= 2 && num <= 4.
+ * The valid range of num_buffers is: num >= 256 && num <= 1024.
  */
 
 
@@ -252,6 +252,70 @@ struct fsg_lun {
 
 #define fsg_lun_is_open(curlun)	((curlun)->filp != NULL)
 
+/* FSF callback functions */
+struct fsg_operations {
+	/*
+	 * Callback function to call when thread exits.  If no
+	 * callback is set or it returns value lower then zero MSF
+	 * will force eject all LUNs it operates on (including those
+	 * marked as non-removable or with prevent_medium_removal flag
+	 * set).
+	 */
+	int (*thread_exits)(void *common);
+
+	/*
+	 * Called prior to ejection.  Negative return means error,
+	 * zero means to continue with ejection, positive means not to
+	 * eject.
+	 */
+	int (*pre_eject)(void *common,
+			 struct fsg_lun *lun, int num);
+	/*
+	 * Called after ejection.  Negative return means error, zero
+	 * or positive is just a success.
+	 */
+	int (*post_eject)(void *common,
+			  struct fsg_lun *lun, int num);
+};
+
+/* Maximal number of LUNs supported in mass storage function */
+#define FSG_MAX_LUNS	8
+
+struct fsg_config {
+	unsigned nluns;
+	struct fsg_lun_config {
+		const char *filename;
+		char ro;
+		char removable;
+		char cdrom;
+		char nofua;
+	} luns[FSG_MAX_LUNS];
+
+	const char			*lun_name_format;
+	const char			*thread_name;
+
+	/* Callback functions. */
+	const struct fsg_operations	*ops;
+	/* UAS Callback functions. */
+	const struct fsg_operations	*uasp_ops;
+	/* Gadget's private data. */
+	void				*private_data;
+	struct mutex			config_mutex;
+
+	const char *vendor_name;		/*  8 characters or less */
+	const char *product_name;		/* 16 characters or less */
+	u16 release;
+
+	char				can_stall;
+};
+
+struct msg_common_data {
+	struct fsg_config	config;
+	struct fsg_common	*fcommon;
+	struct uasp_common	*ucommon;
+};
+
+
 static struct fsg_lun *fsg_lun_from_dev(struct device *dev)
 {
 	return container_of(dev, struct fsg_lun, dev);
diff --git a/drivers/usb/gadget/uasp_cmdiu.c b/drivers/usb/gadget/uasp_cmdiu.c
index 8836945..61902e4 100644
--- a/drivers/usb/gadget/uasp_cmdiu.c
+++ b/drivers/usb/gadget/uasp_cmdiu.c
@@ -27,14 +27,14 @@
  * This function tries to find a free buffer for COMMAND IU or
  * TM FUNCTION IU processing.
  */
-struct fsg_buffhd *get_buffhd(struct fsg_buffhd *bh)
+struct fsg_buffhd *get_buffhd(struct uasp_buff *bh)
 {
 	int i;
 
 	for (i = 0; i < fsg_num_buffers; i++) {
-		if (bh[i].state == BUF_STATE_EMPTY) {
-			bh[i].state = BUF_STATE_BUSY;
-			return &bh[i];
+		if (bh[i].fsg_buff->state == BUF_STATE_EMPTY) {
+			bh[i].fsg_buff->state = BUF_STATE_BUSY;
+			return bh[i].fsg_buff;
 		}
 	}
 
@@ -56,12 +56,12 @@ static __u32 check_cmdiu(struct uasp_dev *udev,
 {
 	__u32 ua_data = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (!curlun || !curlun->lun) {
 		if (cmdiu->cdb[0] != INQUIRY &&
 		    cmdiu->cdb[0] != REQUEST_SENSE) {
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			      "%s() - Logical unit is not supported\n",
 			      __func__);
 			return SS_LOGICAL_UNIT_NOT_SUPPORTED;
@@ -70,18 +70,24 @@ static __u32 check_cmdiu(struct uasp_dev *udev,
 		if (curlun->lun->unit_attention_data &&
 		    cmdiu->cdb[0] != INQUIRY &&
 		    cmdiu->cdb[0] != REQUEST_SENSE) {
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			    "%s() - There is an unit attention condition\n",
 			    __func__);
 			ua_data = curlun->lun->unit_attention_data;
 			curlun->lun->unit_attention_data = SS_NO_SENSE;
 			return ua_data;
 		}
+			/* HACK!!! REMOVE!!! */
+		if (curlun->lun->unit_attention_data == SS_RESET_OCCURRED &&
+			cmdiu->cdb[0] == INQUIRY) {
+			curlun->lun->unit_attention_data = SS_NO_SENSE;
+			DBG(udev->ucommon, "check_cmdiu() - "
+			       "HACK!!! RESETTING  unit attention condition\n");
+		}
 	}
 
 	if (curlun && !(curlun->lun->filp) && needs_medium) {
-		DBG(udev->ucommon->common,
-		    "%s() - Medium is not present\n", __func__);
+		DBG(udev->ucommon, "%s() - Medium is not present\n", __func__);
 		return SS_MEDIUM_NOT_PRESENT;
 	}
 
@@ -102,7 +108,7 @@ void fill_sense_iu(struct uasp_dev *udev,
 	       __u8 status,
 	       __u32 sense_data)
 {
-	DBG(udev->ucommon->common, "%s() - Status = %02x\n", __func__, status);
+	DBG(udev->ucommon, "%s() - Status = %02x\n", __func__, status);
 
 	siu->iu_id = IU_ID_SENSE;
 	siu->reserved1 = 0;
@@ -147,14 +153,14 @@ static int do_uasp_inquiry(struct uasp_dev *udev,
 			struct cmd_iu *cmdiu)
 {
 	struct fsg_buffhd *bh = cmdiu->bh;
-	struct fsg_common *common = udev->ucommon->common;
+	struct uasp_common *ucommon = udev->ucommon;
 	struct usb_request *req = bh->inreq;
 	__u8 *buf = (__u8 *)bh->buf;
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 	int rc = 0;
 
-	DBG(common, "%s() - Enter\n", __func__);
+	DBG(ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		/* Check is cmdiu is filled correctly */
@@ -162,7 +168,7 @@ static int do_uasp_inquiry(struct uasp_dev *udev,
 
 		/* If error sent status with sense data */
 		if (sense) {
-			ERROR(common, "%s() - Error condition\n", __func__);
+			ERROR(ucommon, "%s() - Error condition\n", __func__);
 			status = STATUS_CHECK_CONDITION;
 			cmdiu->state = COMMAND_STATE_STATUS;
 		} else if (udev->op_mode == HS_UASP_MODE)
@@ -213,8 +219,8 @@ static int do_uasp_inquiry(struct uasp_dev *udev,
 				buf[5] = 0;	/* No special options */
 				buf[6] = 0;
 				buf[7] = 0;
-				memcpy(buf + 8, common->inquiry_string,
-				       sizeof(common->inquiry_string));
+				memcpy(buf + 8, ucommon->inquiry_string,
+				       sizeof(ucommon->inquiry_string));
 			}
 
 			fill_usb_request(req, bh->buf,
@@ -224,7 +230,7 @@ static int do_uasp_inquiry(struct uasp_dev *udev,
 				 be16_to_cpup(&cmdiu->tag),
 				 uasp_bulk_in_complete, udev->op_mode);
 
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
@@ -286,7 +292,7 @@ static int do_uasp_request_sense(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		/* Check is cmdiu is filled correctly */
@@ -377,7 +383,7 @@ static int do_uasp_request_sense(struct uasp_dev *udev,
 					 be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_in_complete, udev->op_mode);
 
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
@@ -401,7 +407,7 @@ static int do_uasp_request_sense(struct uasp_dev *udev,
 		break;
 	}
 
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return rc;
 }
 
@@ -424,7 +430,7 @@ static int do_uasp_test_unit_ready(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Check is cmdiu is filled correctly */
 	sense = check_cmdiu(udev, curlun, cmdiu, 0);
@@ -472,7 +478,7 @@ static int do_uasp_mode_sense(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		sense = check_cmdiu(udev, curlun, cmdiu, 0);
@@ -592,7 +598,7 @@ static int do_uasp_mode_sense(struct uasp_dev *udev,
 			fill_usb_request(req, buf0, len, 0, cmdiu, 0,
 					 be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_in_complete, udev->op_mode);
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
@@ -637,7 +643,7 @@ static int do_uasp_prevent_allow(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Check is cmdiu is filled correctly */
 	sense = check_cmdiu(udev, curlun, cmdiu, 0);
@@ -699,11 +705,11 @@ static int do_uasp_read(struct uasp_dev *udev,
 	__u8 status = STATUS_GOOD;
 	int rc = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		if (!curlun) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			       "%s() - Error condition - curlun = NULL\n",
 			       __func__);
 			sense = SS_LOGICAL_UNIT_NOT_SUPPORTED;
@@ -759,7 +765,7 @@ static int do_uasp_read(struct uasp_dev *udev,
 			cmdiu->state = COMMAND_STATE_DATA;
 
 		cmdiu->req_sts = CMD_REQ_NOT_SUBMITTED;
-		DBG(udev->ucommon->common, "%s() lba = %d, file_offset = %d,"
+		DBG(udev->ucommon, "%s() lba = %d, file_offset = %d,"
 					   " xfer_len = %d\n",
 		__func__, lba, cmdiu->file_offset, cmdiu->xfer_len);
 	}
@@ -867,19 +873,19 @@ send_more_data:		/*
 			fill_usb_request(req, bh->buf, nread, 0,
 					 cmdiu, 0, be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_in_complete, udev->op_mode);
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
 		} else if (cmdiu->req_sts == CMD_REQ_IN_PROGRESS) {
 			/* Completion of sent data is not received yet */
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			    "%s() - completion for bh is not received",
 			     __func__);
 			break;
 		} else {
 			/* Completion of the sent data is done */
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			    "%s() - COMMAND_STATE_DATA for bh\n", __func__);
 			if (cmdiu->xfer_len == 0)
 				goto send_status;
@@ -926,7 +932,7 @@ static int do_uasp_read_capacity(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		/* Check is cmdiu is filled correctly */
@@ -987,7 +993,7 @@ static int do_uasp_read_capacity(struct uasp_dev *udev,
 					 cmdiu, 0, be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_in_complete, udev->op_mode);
 
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
@@ -1034,7 +1040,7 @@ static int do_uasp_read_format_capacities(struct uasp_dev *udev,
 	__u8 status = STATUS_GOOD;
 	int rc = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (cmdiu->state == COMMAND_STATE_IDLE) {
 		/* Check is cmdiu is filled correctly */
@@ -1096,7 +1102,7 @@ static int do_uasp_read_format_capacities(struct uasp_dev *udev,
 					 cmdiu, 0, be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_in_complete, udev->op_mode);
 
-			cmdiu->ep = udev->fsg_dev.bulk_in;
+			cmdiu->ep = udev->bulk_in;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 1;
 			break;
@@ -1118,7 +1124,7 @@ static int do_uasp_read_format_capacities(struct uasp_dev *udev,
 		break;
 	}
 
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return rc;
 }
 
@@ -1143,7 +1149,7 @@ static int do_uasp_start_stop(struct uasp_dev *udev,
 	__u8 status = STATUS_GOOD;
 	int start, loej;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	start = cmdiu->cdb[4] & 0x01;
 	loej = cmdiu->cdb[4] & 0x02;
@@ -1190,7 +1196,7 @@ static int do_uasp_start_stop(struct uasp_dev *udev,
 		} else {
 			/* Are we allowed to unload the media? */
 			if (curlun->lun->prevent_medium_removal) {
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				    "%s(): unload attempt prevented\n",
 				    __func__);
 				sense = SS_MEDIUM_REMOVAL_PREVENTED;
@@ -1199,10 +1205,10 @@ static int do_uasp_start_stop(struct uasp_dev *udev,
 			}
 
 			/* Simulate an unload/eject */
-			if (udev->ucommon->common->ops &&
-			    udev->ucommon->common->ops->pre_eject) {
-				int r = udev->ucommon->common->ops->pre_eject(
-					udev->ucommon->common, curlun->lun,
+			if (udev->ucommon->ops &&
+			    udev->ucommon->ops->pre_eject) {
+				int r = udev->ucommon->ops->pre_eject(
+					udev->ucommon, curlun->lun,
 					curlun - udev->ucommon->uluns);
 				if (unlikely(r < 0))
 					status = STATUS_CHECK_CONDITION;
@@ -1210,18 +1216,17 @@ static int do_uasp_start_stop(struct uasp_dev *udev,
 					goto do_uasp_start_stop_done;
 			}
 
-			up_read(&(udev->ucommon->common->filesem));
-			down_write(&(udev->ucommon->common->filesem));
+			up_read(&(udev->ucommon->filesem));
+			down_write(&(udev->ucommon->filesem));
 			close_lun(curlun);
-			up_write(&(udev->ucommon->common->filesem));
-			down_read(&(udev->ucommon->common->filesem));
-
-			if (udev->ucommon->common->ops &&
-			    udev->ucommon->common->ops->post_eject) {
-				if (udev->ucommon->common->ops->
-				    post_eject(udev->ucommon->common,
-					       curlun->lun,
-					       curlun - udev->ucommon->uluns)
+			up_write(&(udev->ucommon->filesem));
+			down_read(&(udev->ucommon->filesem));
+
+			if (udev->ucommon->ops &&
+			    udev->ucommon->ops->post_eject) {
+				if (udev->ucommon->ops->
+				    post_eject(udev->ucommon, curlun->lun,
+					curlun - udev->ucommon->uluns)
 				    < 0)
 					status = STATUS_CHECK_CONDITION;
 			}
@@ -1237,7 +1242,7 @@ do_uasp_start_stop_done:
 			 udev->op_mode);
 	cmdiu->ep = udev->status;
 
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return 1;
 }
 
@@ -1267,7 +1272,7 @@ static int do_uasp_verify(struct uasp_dev *udev,
 	__u32 sense = SS_NO_SENSE;
 	__u8 status = STATUS_GOOD;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	file_offset = (get_unaligned_be32(&cmdiu->cdb[2]) << 9);
 	ver_len = (get_unaligned_be32(&cmdiu->cdb[7]) << 9);
@@ -1354,7 +1359,7 @@ static int do_uasp_verify(struct uasp_dev *udev,
 			 be16_to_cpup(&cmdiu->tag), status_complete,
 			 udev->op_mode);
 	cmdiu->ep = udev->status;
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return 1;
 }
 
@@ -1386,10 +1391,10 @@ static int do_uasp_write(struct uasp_dev *udev,
 	__u8 status = STATUS_GOOD;
 	int rc = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	if (!curlun) {
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		       "%s() - Error condition - curlun = NULL\n",
 		       __func__);
 		sense = SS_LOGICAL_UNIT_NOT_SUPPORTED;
@@ -1474,7 +1479,7 @@ static int do_uasp_write(struct uasp_dev *udev,
 		else
 			cmdiu->state = COMMAND_STATE_DATA;
 		cmdiu->req_sts = CMD_REQ_NOT_SUBMITTED;
-		DBG(udev->ucommon->common, "%s() lba = %d, file_offset = %d,"
+		DBG(udev->ucommon, "%s() lba = %d, file_offset = %d,"
 					   " xfer_len = %d\n",
 		__func__, lba, cmdiu->file_offset, cmdiu->xfer_len);
 	}
@@ -1549,11 +1554,11 @@ get_more_data:	if (cmdiu->req_sts == CMD_REQ_NOT_SUBMITTED) {
 			fill_usb_request(req, bh->buf, amount, 0,
 					 cmdiu, 0, be16_to_cpup(&cmdiu->tag),
 					 uasp_bulk_out_complete, udev->op_mode);
-			DBG(udev->ucommon->common, "%s() fill_usb_request for"
+			DBG(udev->ucommon, "%s() fill_usb_request for"
 						   " out endpoint, amout = %d",
 				__func__, amount);
 
-			cmdiu->ep = udev->fsg_dev.bulk_out;
+			cmdiu->ep = udev->bulk_out;
 			cmdiu->req_sts = CMD_REQ_IN_PROGRESS;
 			rc = 2;
 			break;
@@ -1577,7 +1582,7 @@ get_more_data:	if (cmdiu->req_sts == CMD_REQ_NOT_SUBMITTED) {
 				 * request for this command, we should abort
 				 * all submitted requests for this command
 				 */
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				    "%s() - Host aborted the command\n",
 				    __func__);
 				goto send_status;
@@ -1586,7 +1591,7 @@ get_more_data:	if (cmdiu->req_sts == CMD_REQ_NOT_SUBMITTED) {
 			amount = req->actual;
 			if (curlun->lun->file_length - cmdiu->file_offset <
 				amount) {
-				ERROR(udev->ucommon->common,
+				ERROR(udev->ucommon,
 				      "%s(): write %u @ %llu beyond end %llu\n",
 				      __func__, amount,
 				      (unsigned long long)cmdiu->file_offset,
@@ -1601,18 +1606,18 @@ get_more_data:	if (cmdiu->req_sts == CMD_REQ_NOT_SUBMITTED) {
 			nwritten = vfs_write(curlun->lun->filp,
 					(char __user *) bh->buf,
 					amount, &file_offset_tmp);
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			    "%s(): file write %u @ %llu -> %d\n", __func__,
 			    amount, (unsigned long long)cmdiu->file_offset,
 					(int)nwritten);
 
 			if (nwritten < 0) {
-				ERROR(udev->ucommon->common,
+				ERROR(udev->ucommon,
 				      "%s(): error in file write: %d\n",
 				      __func__, (int)nwritten);
 				nwritten = 0;
 			} else if (nwritten < amount) {
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				      "%s(): partial file write: %d/%u\n",
 				    __func__, (int)nwritten, amount);
 				nwritten -= (nwritten & 511);
@@ -1633,7 +1638,7 @@ get_more_data:	if (cmdiu->req_sts == CMD_REQ_NOT_SUBMITTED) {
 			}
 
 			if (cmdiu->xfer_len == 0) {
-				DBG(udev->ucommon->common,
+				DBG(udev->ucommon,
 				      "%s() - cmdiu->xferlen = 0, "
 				      "send status\n", __func__);
 				goto send_status;
@@ -1657,7 +1662,7 @@ send_status:
 		break;
 	}
 
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return rc;
 }
 
@@ -1682,7 +1687,7 @@ static int do_uasp_synchronize_cache(struct uasp_dev *udev,
 	uint8_t status = STATUS_GOOD;
 	int rc;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Check is cmdiu is filled correctly */
 	sense = check_cmdiu(udev, curlun, cmdiu, 0);
@@ -1707,7 +1712,7 @@ static int do_uasp_synchronize_cache(struct uasp_dev *udev,
 		 udev->op_mode);
 	cmdiu->ep = udev->status;
 
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 	return 1;
 }
 
@@ -1727,11 +1732,11 @@ static void process_cmdiu(struct uasp_dev *udev,
 	struct usb_request *req;
 	int rc = 0;
 
-	DBG(udev->ucommon->common, "%s() Enter. (cmdiu->cdb[0]=%04x)\n",
+	DBG(udev->ucommon, "%s() Enter. (cmdiu->cdb[0]=%04x)\n",
 	    __func__, cmdiu->cdb[0]);
 
 	/* We're using the backing file */
-	down_read(&udev->ucommon->common->filesem);
+	down_read(&udev->ucommon->filesem);
 	switch (cmdiu->cdb[0]) {
 	case INQUIRY:
 		rc = do_uasp_inquiry(udev, curlun, cmdiu);
@@ -1781,7 +1786,7 @@ static void process_cmdiu(struct uasp_dev *udev,
 	case RESERVE:
 	case SEND_DIAGNOSTIC:
 	default:
-		ERROR(udev->ucommon->common,
+		ERROR(udev->ucommon,
 		      "%s(): Unsupported  command = %x\n",
 		    __func__, cmdiu->cdb[0]);
 		cmdiu->state = COMMAND_STATE_STATUS;
@@ -1798,7 +1803,7 @@ static void process_cmdiu(struct uasp_dev *udev,
 		break;
 	}
 
-	up_read(&udev->ucommon->common->filesem);
+	up_read(&udev->ucommon->filesem);
 	if (rc) {
 		if (rc == 1) {
 			req = cmdiu->bh->inreq;
@@ -1808,11 +1813,11 @@ static void process_cmdiu(struct uasp_dev *udev,
 			cmdiu->bh->outreq_busy = 1;
 		}
 		if (usb_ep_queue(cmdiu->ep, req, 0)) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s()usb_ep_queue failed\n",  __func__);
 			cmdiu->state = COMMAND_STATE_FAILED;
 		} else {
-			DBG(udev->ucommon->common,
+			DBG(udev->ucommon,
 			    "%s() - process_cmdiu: queued req to ep\n",
 			    __func__);
 			if (curlun) {
@@ -1821,10 +1826,10 @@ static void process_cmdiu(struct uasp_dev *udev,
 				spin_unlock_irqrestore(&(curlun->lock), flags);
 			} else {
 				spin_lock_irqsave(
-					&(udev->ucommon->common->lock), flags);
+					&(udev->ucommon->lock), flags);
 				udev->active_requests++;
 				spin_unlock_irqrestore(
-					&(udev->ucommon->common->lock), flags);
+					&(udev->ucommon->lock), flags);
 			}
 		}
 	}
@@ -1843,7 +1848,7 @@ void do_cmdiu(struct uasp_dev *udev, struct uasp_lun *curlun)
 	struct cmd_iu *cmdiu, *tmp;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Select the cmd_queue from which cmdius should be processed */
 	if (curlun)
@@ -1852,18 +1857,18 @@ void do_cmdiu(struct uasp_dev *udev, struct uasp_lun *curlun)
 		link = &udev->cmd_queue;
 
 	list_for_each_entry_safe(cmdiu, tmp, link, node) {
-		DBG(udev->ucommon->common, "%s() - Rolling over cmdiu queue\n",
+		DBG(udev->ucommon, "%s() - Rolling over cmdiu queue\n",
 		     __func__);
 
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
 		if (cmdiu->state == COMMAND_STATE_IDLE) {
 			/* Try to get buffers for cmdiu processing */
-			cmdiu->bh = get_buffhd(udev->ucommon->common->buffhds);
-			spin_unlock_irqrestore(&(udev->ucommon->common->lock),
+			cmdiu->bh = get_buffhd(udev->ucommon->ubufs);
+			spin_unlock_irqrestore(&(udev->ucommon->lock),
 					       flags);
 
 			if (!cmdiu->bh) {
-				ERROR(udev->ucommon->common,
+				ERROR(udev->ucommon,
 				      "%s() -Didn't manage to get buffers for "
 				      "cmdiu!\n", __func__);
 				continue;
@@ -1872,15 +1877,14 @@ void do_cmdiu(struct uasp_dev *udev, struct uasp_lun *curlun)
 			   cmdiu->state == COMMAND_STATE_RR_WR) {
 			if (cmdiu->req_sts == CMD_REQ_COMPLETED)
 				spin_unlock_irqrestore(
-					&(udev->ucommon->common->lock), flags);
+					&(udev->ucommon->lock), flags);
 			else {
 				spin_unlock_irqrestore(
-					&(udev->ucommon->common->lock), flags);
+					&(udev->ucommon->lock), flags);
 				continue;
 			}
 		} else {
-			spin_unlock_irqrestore(&(udev->ucommon->common->lock),
-					       flags);
+			spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 			continue;
 		}
 
diff --git a/drivers/usb/gadget/uasp_tmiu.c b/drivers/usb/gadget/uasp_tmiu.c
index 5f70424..8f8fd86 100644
--- a/drivers/usb/gadget/uasp_tmiu.c
+++ b/drivers/usb/gadget/uasp_tmiu.c
@@ -32,7 +32,7 @@ void fill_response_iu(struct uasp_dev *udev,
 	       uint32_t resp_info,
 	       uint8_t status)
 {
-	DBG(udev->ucommon->common, "%s() - Enter. Status = %02x\n", __func__,
+	DBG(udev->ucommon, "%s() - Enter. Status = %02x\n", __func__,
 	    status);
 	riu->iu_id = IU_ID_RESPONSE;
 	riu->reserved = 0;
@@ -61,7 +61,7 @@ static void reset_lun(struct uasp_dev *udev,
 	uint8_t status;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
@@ -108,7 +108,7 @@ static void abort_task(struct uasp_dev *udev,
 	unsigned long flags;
 	uint8_t status;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
 		status = RESPONSE_INCORRECT_LUN;
@@ -121,7 +121,7 @@ static void abort_task(struct uasp_dev *udev,
 			goto found;
 
 	/* Command with specified ipt_tag not found */
-	DBG(udev->ucommon->common, "%s(): cmdiu with tag %04x wasn't found\n",
+	DBG(udev->ucommon, "%s(): cmdiu with tag %04x wasn't found\n",
 	    __func__, tmiu->task_tag);
 	cmdiu = 0;
 
@@ -177,7 +177,7 @@ static void abort_task_set(struct uasp_dev *udev,
 	uint8_t status;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
@@ -215,7 +215,7 @@ static void reset_nexus(struct uasp_dev *udev,
 	uint8_t status;
 	int rc = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	riu = (struct response_iu *)tmiu->bh->buf;
 
@@ -226,26 +226,27 @@ static void reset_nexus(struct uasp_dev *udev,
 	 * Sleep if luns are in processing
 	 */
 	while (!all_lun_state_non_processing(udev)) {
-		DBG(udev->ucommon->common,
+		DBG(udev->ucommon,
 		    "%s() - Luns are in process. Going to sleep\n", __func__);
-		rc = sleep_thread(udev->ucommon->common);
+		rc = uasp_sleep_thread(udev->ucommon);
 		if (rc) {
-			ERROR(udev->ucommon->common,
-			      "%s() - sleep_thread failed! (%d)", __func__, rc);
+			ERROR(udev->ucommon,
+			      "%s() - uasp_sleep_thread failed! (%d)",
+			      __func__, rc);
 			status = RESPONSE_TM_FUNCTION_FAILED;
 			goto reset_nexus_fill_response;
 		}
-		DBG(udev->ucommon->common, "%s() - Wakes up\n", __func__);
+		DBG(udev->ucommon, "%s() - Wakes up\n", __func__);
 		rc = 0;
 	}
 
 	/* Abort general commands and tmius */
 	abort_commands(udev, &udev->cmd_queue, &udev->tm_func_queue,
-		       &(udev->ucommon->common->lock));
+		       &(udev->ucommon->lock));
 
-	spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
+	spin_lock_irqsave(&(udev->ucommon->lock), flags);
 	udev->pending_requests = 0;
-	spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+	spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 	status = RESPONSE_TM_FUNCTION_COMPLETE;
 reset_nexus_fill_response:
@@ -255,7 +256,7 @@ reset_nexus_fill_response:
 			 0, (void *)tmiu, 0, be16_to_cpup(&tmiu->tag),
 			 status_complete, udev->op_mode);
 	tmiu->ep = udev->status;
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 }
 
 /**
@@ -277,7 +278,7 @@ static void query_unit_attention(struct uasp_dev *udev,
 	uint8_t status;
 	uint32_t resp_info = 0;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
 		status = RESPONSE_INCORRECT_LUN;
@@ -324,7 +325,7 @@ static void query_task(struct uasp_dev *udev,
 	unsigned long flags;
 	uint8_t status = RESPONSE_TM_FUNCTION_COMPLETE;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
 		status = RESPONSE_INCORRECT_LUN;
@@ -371,7 +372,7 @@ static void query_task_set(struct uasp_dev *udev,
 	unsigned long flags;
 	uint8_t status;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 	riu = (struct response_iu *)tmiu->bh->buf;
 	if (!curlun) {
 		status = RESPONSE_INCORRECT_LUN;
@@ -400,7 +401,7 @@ q_task_set_fill_response:
 			 0, (void *)tmiu, 0, be16_to_cpup(&tmiu->tag),
 			 status_complete, udev->op_mode);
 	tmiu->ep = udev->status;
-	DBG(udev->ucommon->common, "%s() - Exit\n", __func__);
+	DBG(udev->ucommon, "%s() - Exit\n", __func__);
 }
 
 /**
@@ -448,7 +449,7 @@ static void process_tmiu(struct uasp_dev *udev,
 		break;
 
 	default:
-		ERROR(udev->ucommon->common, "%s(): Unsupported  tmiu = %x\n",
+		ERROR(udev->ucommon, "%s(): Unsupported  tmiu = %x\n",
 		    __func__, tmiu->tm_function);
 		riu = (struct response_iu *)tmiu->bh->inreq->buf;
 		fill_response_iu(udev, riu, tmiu->tag, 0,
@@ -464,8 +465,7 @@ static void process_tmiu(struct uasp_dev *udev,
 
 	tmiu->state = COMMAND_STATE_STATUS;
 	if (usb_ep_queue(tmiu->ep, tmiu->bh->inreq, 0)) {
-		ERROR(udev->ucommon->common,
-			      "%s()usb_ep_queue failed\n",  __func__);
+		ERROR(udev->ucommon, "%s()usb_ep_queue failed\n",  __func__);
 		tmiu->state = COMMAND_STATE_FAILED;
 	} else {
 		tmiu->bh->inreq_busy = 1;
@@ -474,10 +474,10 @@ static void process_tmiu(struct uasp_dev *udev,
 			curlun->active_requests++;
 			spin_unlock_irqrestore(&(curlun->lock), flags);
 		} else {
-			spin_lock_irqsave(&(udev->ucommon->common->lock),
+			spin_lock_irqsave(&(udev->ucommon->lock),
 					  flags);
 			udev->active_requests++;
-			spin_unlock_irqrestore(&(udev->ucommon->common->lock),
+			spin_unlock_irqrestore(&(udev->ucommon->lock),
 					       flags);
 		}
 	}
@@ -497,7 +497,7 @@ void do_tmiu(struct uasp_dev *udev, struct uasp_lun *curlun)
 	struct tm_iu *tmiu, *tmp;
 	unsigned long flags;
 
-	DBG(udev->ucommon->common, "%s() - Enter\n", __func__);
+	DBG(udev->ucommon, "%s() - Enter\n", __func__);
 
 	/* Select the tm_func_queue from which tmius should be processed */
 	if (curlun)
@@ -505,19 +505,19 @@ void do_tmiu(struct uasp_dev *udev, struct uasp_lun *curlun)
 	else
 		link = &udev->tm_func_queue;
 
-	DBG(udev->ucommon->common, "%s() - Rolling over tmiu queue\n",
+	DBG(udev->ucommon, "%s() - Rolling over tmiu queue\n",
 	     __func__);
 	list_for_each_entry_safe(tmiu, tmp, link, node) {
 		if (tmiu->state != COMMAND_STATE_IDLE)
 			continue;
 
 		/* Try to get buffer for tmiu provessing */
-		spin_lock_irqsave(&(udev->ucommon->common->lock), flags);
-		tmiu->bh = get_buffhd(udev->ucommon->common->buffhds);
-		spin_unlock_irqrestore(&(udev->ucommon->common->lock), flags);
+		spin_lock_irqsave(&(udev->ucommon->lock), flags);
+		tmiu->bh = get_buffhd(udev->ucommon->ubufs);
+		spin_unlock_irqrestore(&(udev->ucommon->lock), flags);
 
 		if (!tmiu->bh) {
-			ERROR(udev->ucommon->common,
+			ERROR(udev->ucommon,
 			      "%s() -Didnt manage to get buffers for tmiu!\n",
 			      __func__);
 			continue;
-- 
1.7.6

--
Sent by a Consultant for Qualcomm Innovation Center, Inc.
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/