142 files changed, 10857 insertions, 6269 deletions

diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 1ae2bf39d84b..3cba892b83a2 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -28,6 +28,7 @@ obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF) += host/
 obj-$(CONFIG_USB_FUSBH200_HCD)  += host/
 obj-$(CONFIG_USB_FOTG210_HCD)   += host/
+obj-$(CONFIG_USB_MAX3421_HCD)   += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
 
@@ -58,4 +59,4 @@ obj-$(CONFIG_USB_CHIPIDEA)	+= chipidea/
 obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs/
 obj-$(CONFIG_USB_GADGET)        += gadget/
 
-obj-$(CONFIG_USB_COMMON)        += usb-common.o
+obj-$(CONFIG_USB_COMMON)        += common/
diff --git a/drivers/usb/chipidea/Makefile b/drivers/usb/chipidea/Makefile
index 480bd4d5710a..2f099c7df7b5 100644
--- a/drivers/usb/chipidea/Makefile
+++ b/drivers/usb/chipidea/Makefile
@@ -6,6 +6,7 @@ ci_hdrc-y				:= core.o otg.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_UDC)      += udc.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_HOST)     += host.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_DEBUG)    += debug.o
+ci_hdrc-$(CONFIG_USB_OTG_FSM)           += otg_fsm.o
 
 # Glue/Bridge layers go here
 
diff --git a/drivers/usb/chipidea/bits.h b/drivers/usb/chipidea/bits.h
index 83d06c1455b7..ca57e3dcd3d5 100644
--- a/drivers/usb/chipidea/bits.h
+++ b/drivers/usb/chipidea/bits.h
@@ -44,9 +44,14 @@
 #define DEVICEADDR_USBADR     (0x7FUL << 25)
 
 /* PORTSC */
+#define PORTSC_CCS            BIT(0)
+#define PORTSC_CSC            BIT(1)
+#define PORTSC_PEC            BIT(3)
+#define PORTSC_OCC            BIT(5)
 #define PORTSC_FPR            BIT(6)
 #define PORTSC_SUSP           BIT(7)
 #define PORTSC_HSP            BIT(9)
+#define PORTSC_PP             BIT(12)
 #define PORTSC_PTC            (0x0FUL << 16)
 #define PORTSC_PHCD(d)        ((d) ? BIT(22) : BIT(23))
 /* PTS and PTW for non lpm version only */
@@ -56,6 +61,9 @@
 #define PORTSC_PTW            BIT(28)
 #define PORTSC_STS            BIT(29)
 
+#define PORTSC_W1C_BITS                                         \
+        (PORTSC_CSC | PORTSC_PEC | PORTSC_OCC)
+
 /* DEVLC */
 #define DEVLC_PFSC            BIT(23)
 #define DEVLC_PSPD            (0x03UL << 25)
@@ -72,6 +80,8 @@
 
 /* OTGSC */
 #define OTGSC_IDPU            BIT(5)
+#define OTGSC_HADP            BIT(6)
+#define OTGSC_HABA            BIT(7)
 #define OTGSC_ID              BIT(8)
 #define OTGSC_AVV             BIT(9)
 #define OTGSC_ASV             BIT(10)
diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
index e206406ae1d9..9563cb56d564 100644
--- a/drivers/usb/chipidea/ci.h
+++ b/drivers/usb/chipidea/ci.h
@@ -17,6 +17,7 @@
 #include <linux/irqreturn.h>
 #include <linux/usb.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg-fsm.h>
 
 /******************************************************************************
  * DEFINE
@@ -139,6 +140,8 @@ struct hw_bank {
  * @roles: array of supported roles for this controller
  * @role: current role
  * @is_otg: if the device is otg-capable
+ * @fsm: otg finite state machine
+ * @fsm_timer: pointer to timer list of otg fsm
  * @work: work for role changing
  * @wq: workqueue thread
  * @qh_pool: allocation pool for queue heads
@@ -174,6 +177,8 @@ struct ci_hdrc {
         struct ci_role_driver           *roles[CI_ROLE_END];
         enum ci_role                    role;
         bool                            is_otg;
+        struct otg_fsm                  fsm;
+        struct ci_otg_fsm_timer_list    *fsm_timer;
         struct work_struct              work;
         struct workqueue_struct         *wq;
 
@@ -319,6 +324,24 @@ static inline u32 hw_test_and_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
         return (val & mask) >> __ffs(mask);
 }
 
+/**
+ * ci_otg_is_fsm_mode: runtime check if otg controller
+ * is in otg fsm mode.
+ */
+static inline bool ci_otg_is_fsm_mode(struct ci_hdrc *ci)
+{
+#ifdef CONFIG_USB_OTG_FSM
+        return ci->is_otg && ci->roles[CI_ROLE_HOST] &&
+                                        ci->roles[CI_ROLE_GADGET];
+#else
+        return false;
+#endif
+}
+
+u32 hw_read_intr_enable(struct ci_hdrc *ci);
+
+u32 hw_read_intr_status(struct ci_hdrc *ci);
+
 int hw_device_reset(struct ci_hdrc *ci, u32 mode);
 
 int hw_port_test_set(struct ci_hdrc *ci, u8 mode);
diff --git a/drivers/usb/chipidea/ci_hdrc_msm.c b/drivers/usb/chipidea/ci_hdrc_msm.c
index 2d51d852b474..d72b9d2de2c5 100644
--- a/drivers/usb/chipidea/ci_hdrc_msm.c
+++ b/drivers/usb/chipidea/ci_hdrc_msm.c
@@ -47,6 +47,7 @@ static void ci_hdrc_msm_notify_event(struct ci_hdrc *ci, unsigned event)
 
 static struct ci_hdrc_platform_data ci_hdrc_msm_platdata = {
         .name                   = "ci_hdrc_msm",
+        .capoffset              = DEF_CAPOFFSET,
         .flags                  = CI_HDRC_REGS_SHARED |
                                   CI_HDRC_REQUIRE_TRANSCEIVER |
                                   CI_HDRC_DISABLE_STREAMING,
@@ -57,9 +58,21 @@ static struct ci_hdrc_platform_data ci_hdrc_msm_platdata = {
 static int ci_hdrc_msm_probe(struct platform_device *pdev)
 {
         struct platform_device *plat_ci;
+        struct usb_phy *phy;
 
         dev_dbg(&pdev->dev, "ci_hdrc_msm_probe\n");
 
+        /*
+         * OTG(PHY) driver takes care of PHY initialization, clock management,
+         * powering up VBUS, mapping of registers address space and power
+         * management.
+         */
+        phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
+        if (IS_ERR(phy))
+                return PTR_ERR(phy);
+
+        ci_hdrc_msm_platdata.phy = phy;
+
         plat_ci = ci_hdrc_add_device(&pdev->dev,
                                 pdev->resource, pdev->num_resources,
                                 &ci_hdrc_msm_platdata);
@@ -86,10 +99,19 @@ static int ci_hdrc_msm_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id msm_ci_dt_match[] = {
+        { .compatible = "qcom,ci-hdrc", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, msm_ci_dt_match);
+
 static struct platform_driver ci_hdrc_msm_driver = {
         .probe = ci_hdrc_msm_probe,
         .remove = ci_hdrc_msm_remove,
-        .driver = { .name = "msm_hsusb", },
+        .driver = {
+                .name = "msm_hsusb",
+                .of_match_table = msm_ci_dt_match,
+        },
 };
 
 module_platform_driver(ci_hdrc_msm_driver);
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 1cd5d0ba587c..619d13e29995 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -23,7 +23,7 @@
  * - BUS:    bus glue code, bus abstraction layer
  *
  * Compile Options
- * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
+ * - CONFIG_USB_CHIPIDEA_DEBUG: enable debug facilities
  * - STALL_IN:  non-empty bulk-in pipes cannot be halted
  *              if defined mass storage compliance succeeds but with warnings
  *              => case 4: Hi >  Dn
@@ -42,10 +42,6 @@
  * - Not Supported: 15 & 16 (ISO)
  *
  * TODO List
- * - OTG
- * - Interrupt Traffic
- * - GET_STATUS(device) - always reports 0
- * - Gadget API (majority of optional features)
  * - Suspend & Remote Wakeup
  */
 #include <linux/delay.h>
@@ -74,6 +70,7 @@
 #include "host.h"
 #include "debug.h"
 #include "otg.h"
+#include "otg_fsm.h"
 
 /* Controller register map */
 static const u8 ci_regs_nolpm[] = {
@@ -140,6 +137,26 @@ static int hw_alloc_regmap(struct ci_hdrc *ci, bool is_lpm)
 }
 
 /**
+ * hw_read_intr_enable: returns interrupt enable register
+ *
+ * This function returns register data
+ */
+u32 hw_read_intr_enable(struct ci_hdrc *ci)
+{
+        return hw_read(ci, OP_USBINTR, ~0);
+}
+
+/**
+ * hw_read_intr_status: returns interrupt status register
+ *
+ * This function returns register data
+ */
+u32 hw_read_intr_status(struct ci_hdrc *ci)
+{
+        return hw_read(ci, OP_USBSTS, ~0);
+}
+
+/**
  * hw_port_test_set: writes port test mode (execute without interruption)
  * @mode: new value
  *
@@ -179,11 +196,10 @@ static void ci_hdrc_enter_lpm(struct ci_hdrc *ci, bool enable)
                 hw_write(ci, reg, PORTSC_PHCD(ci->hw_bank.lpm),
                                 0);
                 /* 
-                 * The controller needs at least 1ms to reflect
-                 * PHY's status, the PHY also needs some time (less
+                 * the PHY needs some time (less
                  * than 1ms) to leave low power mode.
                  */
-                usleep_range(1500, 2000);
+                usleep_range(1000, 1100);
         }
 }
 
@@ -392,8 +408,14 @@ static irqreturn_t ci_irq(int irq, void *data)
         irqreturn_t ret = IRQ_NONE;
         u32 otgsc = 0;
 
-        if (ci->is_otg)
-                otgsc = hw_read(ci, OP_OTGSC, ~0);
+        if (ci->is_otg) {
+                otgsc = hw_read_otgsc(ci, ~0);
+                if (ci_otg_is_fsm_mode(ci)) {
+                        ret = ci_otg_fsm_irq(ci);
+                        if (ret == IRQ_HANDLED)
+                                return ret;
+                }
+        }
 
         /*
          * Handle id change interrupt, it indicates device/host function
@@ -401,9 +423,9 @@ static irqreturn_t ci_irq(int irq, void *data)
          */
         if (ci->is_otg && (otgsc & OTGSC_IDIE) && (otgsc & OTGSC_IDIS)) {
                 ci->id_event = true;
-                ci_clear_otg_interrupt(ci, OTGSC_IDIS);
-                disable_irq_nosync(ci->irq);
-                queue_work(ci->wq, &ci->work);
+                /* Clear ID change irq status */
+                hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS);
+                ci_otg_queue_work(ci);
                 return IRQ_HANDLED;
         }
 
@@ -413,9 +435,9 @@ static irqreturn_t ci_irq(int irq, void *data)
          */
         if (ci->is_otg && (otgsc & OTGSC_BSVIE) && (otgsc & OTGSC_BSVIS)) {
                 ci->b_sess_valid_event = true;
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                disable_irq_nosync(ci->irq);
-                queue_work(ci->wq, &ci->work);
+                /* Clear BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS);
+                ci_otg_queue_work(ci);
                 return IRQ_HANDLED;
         }
 
@@ -533,11 +555,8 @@ static void ci_get_otg_capable(struct ci_hdrc *ci)
                 ci->is_otg = (hw_read(ci, CAP_DCCPARAMS,
                                 DCCPARAMS_DC | DCCPARAMS_HC)
                                         == (DCCPARAMS_DC | DCCPARAMS_HC));
-        if (ci->is_otg) {
+        if (ci->is_otg)
                 dev_dbg(ci->dev, "It is OTG capable controller\n");
-                ci_disable_otg_interrupt(ci, OTGSC_INT_EN_BITS);
-                ci_clear_otg_interrupt(ci, OTGSC_INT_STATUS_BITS);
-        }
 }
 
 static int ci_hdrc_probe(struct platform_device *pdev)
@@ -599,6 +618,13 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(dev, "unable to init phy: %d\n", ret);
                 return ret;
+        } else {
+                /* 
+                 * The delay to sync PHY's status, the maximum delay is
+                 * 2ms since the otgsc uses 1ms timer to debounce the
+                 * PHY's input
+                 */
+                usleep_range(2000, 2500);
         }
 
         ci->hw_bank.phys = res->start;
@@ -633,6 +659,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         }
 
         if (ci->is_otg) {
+                /* Disable and clear all OTG irq */
+                hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
+                                                        OTGSC_INT_STATUS_BITS);
                 ret = ci_hdrc_otg_init(ci);
                 if (ret) {
                         dev_err(dev, "init otg fails, ret = %d\n", ret);
@@ -642,13 +671,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
 
         if (ci->roles[CI_ROLE_HOST] && ci->roles[CI_ROLE_GADGET]) {
                 if (ci->is_otg) {
-                        /*
-                         * ID pin needs 1ms debouce time,
-                         * we delay 2ms for safe.
-                         */
-                        mdelay(2);
                         ci->role = ci_otg_role(ci);
-                        ci_enable_otg_interrupt(ci, OTGSC_IDIE);
+                        /* Enable ID change irq */
+                        hw_write_otgsc(ci, OTGSC_IDIE, OTGSC_IDIE);
                 } else {
                         /*
                          * If the controller is not OTG capable, but support
@@ -667,10 +692,13 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ci->role == CI_ROLE_GADGET)
                 ci_handle_vbus_change(ci);
 
-        ret = ci_role_start(ci, ci->role);
-        if (ret) {
-                dev_err(dev, "can't start %s role\n", ci_role(ci)->name);
-                goto stop;
+        if (!ci_otg_is_fsm_mode(ci)) {
+                ret = ci_role_start(ci, ci->role);
+                if (ret) {
+                        dev_err(dev, "can't start %s role\n",
+                                                ci_role(ci)->name);
+                        goto stop;
+                }
         }
 
         platform_set_drvdata(pdev, ci);
@@ -679,6 +707,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ret)
                 goto stop;
 
+        if (ci_otg_is_fsm_mode(ci))
+                ci_hdrc_otg_fsm_start(ci);
+
         ret = dbg_create_files(ci);
         if (!ret)
                 return 0;
@@ -711,6 +742,7 @@ static struct platform_driver ci_hdrc_driver = {
         .remove = ci_hdrc_remove,
         .driver = {
                 .name   = "ci_hdrc",
+                .owner  = THIS_MODULE,
         },
 };
 
diff --git a/drivers/usb/chipidea/debug.c b/drivers/usb/chipidea/debug.c
index 96d899aee473..7cccab6ff308 100644
--- a/drivers/usb/chipidea/debug.c
+++ b/drivers/usb/chipidea/debug.c
@@ -7,11 +7,15 @@
 #include <linux/uaccess.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/phy.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/otg-fsm.h>
 
 #include "ci.h"
 #include "udc.h"
 #include "bits.h"
 #include "debug.h"
+#include "otg.h"
 
 /**
  * ci_device_show: prints information about device capabilities and status
@@ -204,6 +208,80 @@ static const struct file_operations ci_requests_fops = {
         .release        = single_release,
 };
 
+int ci_otg_show(struct seq_file *s, void *unused)
+{
+        struct ci_hdrc *ci = s->private;
+        struct otg_fsm *fsm;
+
+        if (!ci || !ci_otg_is_fsm_mode(ci))
+                return 0;
+
+        fsm = &ci->fsm;
+
+        /* ------ State ----- */
+        seq_printf(s, "OTG state: %s\n\n",
+                usb_otg_state_string(ci->transceiver->state));
+
+        /* ------ State Machine Variables ----- */
+        seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop);
+
+        seq_printf(s, "a_bus_req: %d\n", fsm->a_bus_req);
+
+        seq_printf(s, "a_srp_det: %d\n", fsm->a_srp_det);
+
+        seq_printf(s, "a_vbus_vld: %d\n", fsm->a_vbus_vld);
+
+        seq_printf(s, "b_conn: %d\n", fsm->b_conn);
+
+        seq_printf(s, "adp_change: %d\n", fsm->adp_change);
+
+        seq_printf(s, "power_up: %d\n", fsm->power_up);
+
+        seq_printf(s, "a_bus_resume: %d\n", fsm->a_bus_resume);
+
+        seq_printf(s, "a_bus_suspend: %d\n", fsm->a_bus_suspend);
+
+        seq_printf(s, "a_conn: %d\n", fsm->a_conn);
+
+        seq_printf(s, "b_bus_req: %d\n", fsm->b_bus_req);
+
+        seq_printf(s, "b_bus_suspend: %d\n", fsm->b_bus_suspend);
+
+        seq_printf(s, "b_se0_srp: %d\n", fsm->b_se0_srp);
+
+        seq_printf(s, "b_ssend_srp: %d\n", fsm->b_ssend_srp);
+
+        seq_printf(s, "b_sess_vld: %d\n", fsm->b_sess_vld);
+
+        seq_printf(s, "b_srp_done: %d\n", fsm->b_srp_done);
+
+        seq_printf(s, "drv_vbus: %d\n", fsm->drv_vbus);
+
+        seq_printf(s, "loc_conn: %d\n", fsm->loc_conn);
+
+        seq_printf(s, "loc_sof: %d\n", fsm->loc_sof);
+
+        seq_printf(s, "adp_prb: %d\n", fsm->adp_prb);
+
+        seq_printf(s, "id: %d\n", fsm->id);
+
+        seq_printf(s, "protocol: %d\n", fsm->protocol);
+
+        return 0;
+}
+
+static int ci_otg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ci_otg_show, inode->i_private);
+}
+
+static const struct file_operations ci_otg_fops = {
+        .open                   = ci_otg_open,
+        .read                   = seq_read,
+        .llseek                 = seq_lseek,
+        .release                = single_release,
+};
+
 static int ci_role_show(struct seq_file *s, void *data)
 {
         struct ci_hdrc *ci = s->private;
@@ -253,6 +331,50 @@ static const struct file_operations ci_role_fops = {
         .release        = single_release,
 };
 
+int ci_registers_show(struct seq_file *s, void *unused)
+{
+        struct ci_hdrc *ci = s->private;
+        u32 tmp_reg;
+
+        if (!ci)
+                return 0;
+
+        /* ------ Registers ----- */
+        tmp_reg = hw_read_intr_enable(ci);
+        seq_printf(s, "USBINTR reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read_intr_status(ci);
+        seq_printf(s, "USBSTS reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_USBMODE, ~0);
+        seq_printf(s, "USBMODE reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_USBCMD, ~0);
+        seq_printf(s, "USBCMD reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_PORTSC, ~0);
+        seq_printf(s, "PORTSC reg: %08x\n", tmp_reg);
+
+        if (ci->is_otg) {
+                tmp_reg = hw_read_otgsc(ci, ~0);
+                seq_printf(s, "OTGSC reg: %08x\n", tmp_reg);
+        }
+
+        return 0;
+}
+
+static int ci_registers_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ci_registers_show, inode->i_private);
+}
+
+static const struct file_operations ci_registers_fops = {
+        .open                   = ci_registers_open,
+        .read                   = seq_read,
+        .llseek                 = seq_lseek,
+        .release                = single_release,
+};
+
 /**
  * dbg_create_files: initializes the attribute interface
  * @ci: device
@@ -287,8 +409,21 @@ int dbg_create_files(struct ci_hdrc *ci)
         if (!dent)
                 goto err;
 
+        if (ci_otg_is_fsm_mode(ci)) {
+                dent = debugfs_create_file("otg", S_IRUGO, ci->debugfs, ci,
+                                        &ci_otg_fops);
+                if (!dent)
+                        goto err;
+        }
+
         dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
                                    &ci_role_fops);
+        if (!dent)
+                goto err;
+
+        dent = debugfs_create_file("registers", S_IRUGO, ci->debugfs, ci,
+                                &ci_registers_fops);
+
         if (dent)
                 return 0;
 err:
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index a8ac6c16dac9..a93d950e9468 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -67,7 +67,11 @@ static int host_start(struct ci_hdrc *ci)
         ehci->has_tdi_phy_lpm = ci->hw_bank.lpm;
         ehci->imx28_write_fix = ci->imx28_write_fix;
 
-        if (ci->platdata->reg_vbus) {
+        /*
+         * vbus is always on if host is not in OTG FSM mode,
+         * otherwise should be controlled by OTG FSM
+         */
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) {
                 ret = regulator_enable(ci->platdata->reg_vbus);
                 if (ret) {
                         dev_err(ci->dev,
@@ -78,10 +82,17 @@ static int host_start(struct ci_hdrc *ci)
         }
 
         ret = usb_add_hcd(hcd, 0, 0);
-        if (ret)
+        if (ret) {
                 goto disable_reg;
-        else
+        } else {
+                struct usb_otg *otg = ci->transceiver->otg;
+
                 ci->hcd = hcd;
+                if (otg) {
+                        otg->host = &hcd->self;
+                        hcd->self.otg_port = 1;
+                }
+        }
 
         if (ci->platdata->flags & CI_HDRC_DISABLE_STREAMING)
                 hw_write(ci, OP_USBMODE, USBMODE_CI_SDIS, USBMODE_CI_SDIS);
@@ -89,7 +100,7 @@ static int host_start(struct ci_hdrc *ci)
         return ret;
 
 disable_reg:
-        if (ci->platdata->reg_vbus)
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci))
                 regulator_disable(ci->platdata->reg_vbus);
 
 put_hcd:
@@ -105,7 +116,7 @@ static void host_stop(struct ci_hdrc *ci)
         if (hcd) {
                 usb_remove_hcd(hcd);
                 usb_put_hcd(hcd);
-                if (ci->platdata->reg_vbus)
+                if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci))
                         regulator_disable(ci->platdata->reg_vbus);
         }
 }
diff --git a/drivers/usb/chipidea/otg.c b/drivers/usb/chipidea/otg.c
index 39bd7ec8bf75..a048b08b9d4d 100644
--- a/drivers/usb/chipidea/otg.c
+++ b/drivers/usb/chipidea/otg.c
@@ -11,8 +11,8 @@
  */
 
 /*
- * This file mainly handles otgsc register, it may include OTG operation
- * in the future.
+ * This file mainly handles otgsc register, OTG fsm operations for HNP and SRP
+ * are also included.
  */
 
 #include <linux/usb/otg.h>
@@ -22,6 +22,26 @@
 #include "ci.h"
 #include "bits.h"
 #include "otg.h"
+#include "otg_fsm.h"
+
+/**
+ * hw_read_otgsc returns otgsc register bits value.
+ * @mask: bitfield mask
+ */
+u32 hw_read_otgsc(struct ci_hdrc *ci, u32 mask)
+{
+        return hw_read(ci, OP_OTGSC, mask);
+}
+
+/**
+ * hw_write_otgsc updates target bits of OTGSC register.
+ * @mask: bitfield mask
+ * @data: to be written
+ */
+void hw_write_otgsc(struct ci_hdrc *ci, u32 mask, u32 data)
+{
+        hw_write(ci, OP_OTGSC, mask | OTGSC_INT_STATUS_BITS, data);
+}
 
 /**
  * ci_otg_role - pick role based on ID pin state
@@ -29,8 +49,7 @@
  */
 enum ci_role ci_otg_role(struct ci_hdrc *ci)
 {
-        u32 sts = hw_read(ci, OP_OTGSC, ~0);
-        enum ci_role role = sts & OTGSC_ID
+        enum ci_role role = hw_read_otgsc(ci, OTGSC_ID)
                 ? CI_ROLE_GADGET
                 : CI_ROLE_HOST;
 
@@ -39,14 +58,10 @@ enum ci_role ci_otg_role(struct ci_hdrc *ci)
 
 void ci_handle_vbus_change(struct ci_hdrc *ci)
 {
-        u32 otgsc;
-
         if (!ci->is_otg)
                 return;
 
-        otgsc = hw_read(ci, OP_OTGSC, ~0);
-
-        if (otgsc & OTGSC_BSV)
+        if (hw_read_otgsc(ci, OTGSC_BSV))
                 usb_gadget_vbus_connect(&ci->gadget);
         else
                 usb_gadget_vbus_disconnect(&ci->gadget);
@@ -76,6 +91,11 @@ static void ci_otg_work(struct work_struct *work)
 {
         struct ci_hdrc *ci = container_of(work, struct ci_hdrc, work);
 
+        if (ci_otg_is_fsm_mode(ci) && !ci_otg_fsm_work(ci)) {
+                enable_irq(ci->irq);
+                return;
+        }
+
         if (ci->id_event) {
                 ci->id_event = false;
                 ci_handle_id_switch(ci);
@@ -102,6 +122,9 @@ int ci_hdrc_otg_init(struct ci_hdrc *ci)
                 return -ENODEV;
         }
 
+        if (ci_otg_is_fsm_mode(ci))
+                return ci_hdrc_otg_fsm_init(ci);
+
         return 0;
 }
 
@@ -115,6 +138,9 @@ void ci_hdrc_otg_destroy(struct ci_hdrc *ci)
                 flush_workqueue(ci->wq);
                 destroy_workqueue(ci->wq);
         }
-        ci_disable_otg_interrupt(ci, OTGSC_INT_EN_BITS);
-        ci_clear_otg_interrupt(ci, OTGSC_INT_STATUS_BITS);
+        /* Disable all OTG irq and clear status */
+        hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
+                                                OTGSC_INT_STATUS_BITS);
+        if (ci_otg_is_fsm_mode(ci))
+                ci_hdrc_otg_fsm_remove(ci);
 }
diff --git a/drivers/usb/chipidea/otg.h b/drivers/usb/chipidea/otg.h
index 449bee07f4fe..9ecb598e48f0 100644
--- a/drivers/usb/chipidea/otg.h
+++ b/drivers/usb/chipidea/otg.h
@@ -11,25 +11,16 @@
 #ifndef __DRIVERS_USB_CHIPIDEA_OTG_H
 #define __DRIVERS_USB_CHIPIDEA_OTG_H
 
-static inline void ci_clear_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        /* Only clear request bits */
-        hw_write(ci, OP_OTGSC, OTGSC_INT_STATUS_BITS, bits);
-}
-
-static inline void ci_enable_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        hw_write(ci, OP_OTGSC, bits | OTGSC_INT_STATUS_BITS, bits);
-}
-
-static inline void ci_disable_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        hw_write(ci, OP_OTGSC, bits | OTGSC_INT_STATUS_BITS, 0);
-}
-
+u32 hw_read_otgsc(struct ci_hdrc *ci, u32 mask);
+void hw_write_otgsc(struct ci_hdrc *ci, u32 mask, u32 data);
 int ci_hdrc_otg_init(struct ci_hdrc *ci);
 void ci_hdrc_otg_destroy(struct ci_hdrc *ci);
 enum ci_role ci_otg_role(struct ci_hdrc *ci);
 void ci_handle_vbus_change(struct ci_hdrc *ci);
+static inline void ci_otg_queue_work(struct ci_hdrc *ci)
+{
+        disable_irq_nosync(ci->irq);
+        queue_work(ci->wq, &ci->work);
+}
 
 #endif /* __DRIVERS_USB_CHIPIDEA_OTG_H */
diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c
new file mode 100644
index 000000000000..caaabc58021e
--- /dev/null
+++ b/drivers/usb/chipidea/otg_fsm.c
@@ -0,0 +1,842 @@
+/*
+ * otg_fsm.c - ChipIdea USB IP core OTG FSM driver
+ *
+ * Copyright (C) 2014 Freescale Semiconductor, Inc.
+ *
+ * Author: Jun Li
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This file mainly handles OTG fsm, it includes OTG fsm operations
+ * for HNP and SRP.
+ *
+ * TODO List
+ * - ADP
+ * - OTG test device
+ */
+
+#include <linux/usb/otg.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/chipidea.h>
+#include <linux/regulator/consumer.h>
+
+#include "ci.h"
+#include "bits.h"
+#include "otg.h"
+#include "otg_fsm.h"
+
+static struct ci_otg_fsm_timer *otg_timer_initializer
+(struct ci_hdrc *ci, void (*function)(void *, unsigned long),
+                        unsigned long expires, unsigned long data)
+{
+        struct ci_otg_fsm_timer *timer;
+
+        timer = devm_kzalloc(ci->dev, sizeof(struct ci_otg_fsm_timer),
+                                                                GFP_KERNEL);
+        if (!timer)
+                return NULL;
+        timer->function = function;
+        timer->expires = expires;
+        timer->data = data;
+        return timer;
+}
+
+/* Add for otg: interact with user space app */
+static ssize_t
+get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_req(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0') {
+                ci->fsm.a_bus_req = 0;
+        } else if (buf[0] == '1') {
+                /* If a_bus_drop is TRUE, a_bus_req can't be set */
+                if (ci->fsm.a_bus_drop) {
+                        mutex_unlock(&ci->fsm.lock);
+                        return count;
+                }
+                ci->fsm.a_bus_req = 1;
+        }
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
+
+static ssize_t
+get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_drop);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_drop(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0') {
+                ci->fsm.a_bus_drop = 0;
+        } else if (buf[0] == '1') {
+                ci->fsm.a_bus_drop = 1;
+                ci->fsm.a_bus_req = 0;
+        }
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop,
+                                                set_a_bus_drop);
+
+static ssize_t
+get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.b_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_b_bus_req(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0')
+                ci->fsm.b_bus_req = 0;
+        else if (buf[0] == '1')
+                ci->fsm.b_bus_req = 1;
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
+
+static ssize_t
+set_a_clr_err(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '1')
+                ci->fsm.a_clr_err = 1;
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
+
+static struct attribute *inputs_attrs[] = {
+        &dev_attr_a_bus_req.attr,
+        &dev_attr_a_bus_drop.attr,
+        &dev_attr_b_bus_req.attr,
+        &dev_attr_a_clr_err.attr,
+        NULL,
+};
+
+static struct attribute_group inputs_attr_group = {
+        .name = "inputs",
+        .attrs = inputs_attrs,
+};
+
+/*
+ * Add timer to active timer list
+ */
+static void ci_otg_add_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+{
+        struct ci_otg_fsm_timer *tmp_timer;
+        struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+
+        if (t >= NUM_CI_OTG_FSM_TIMERS)
+                return;
+
+        /*
+         * Check if the timer is already in the active list,
+         * if so update timer count
+         */
+        list_for_each_entry(tmp_timer, active_timers, list)
+                if (tmp_timer == timer) {
+                        timer->count = timer->expires;
+                        return;
+                }
+
+        timer->count = timer->expires;
+        list_add_tail(&timer->list, active_timers);
+
+        /* Enable 1ms irq */
+        if (!(hw_read_otgsc(ci, OTGSC_1MSIE)))
+                hw_write_otgsc(ci, OTGSC_1MSIE, OTGSC_1MSIE);
+}
+
+/*
+ * Remove timer from active timer list
+ */
+static void ci_otg_del_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+{
+        struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
+        struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+
+        if (t >= NUM_CI_OTG_FSM_TIMERS)
+                return;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list)
+                if (tmp_timer == timer)
+                        list_del(&timer->list);
+
+        /* Disable 1ms irq if there is no any active timer */
+        if (list_empty(active_timers))
+                hw_write_otgsc(ci, OTGSC_1MSIE, 0);
+}
+
+/*
+ * Reduce timer count by 1, and find timeout conditions.
+ * Called by otg 1ms timer interrupt
+ */
+static inline int ci_otg_tick_timer(struct ci_hdrc *ci)
+{
+        struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+        int expired = 0;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list) {
+                tmp_timer->count--;
+                /* check if timer expires */
+                if (!tmp_timer->count) {
+                        list_del(&tmp_timer->list);
+                        tmp_timer->function(ci, tmp_timer->data);
+                        expired = 1;
+                }
+        }
+
+        /* disable 1ms irq if there is no any timer active */
+        if ((expired == 1) && list_empty(active_timers))
+                hw_write_otgsc(ci, OTGSC_1MSIE, 0);
+
+        return expired;
+}
+
+/* The timeout callback function to set time out bit */
+static void set_tmout(void *ptr, unsigned long indicator)
+{
+        *(int *)indicator = 1;
+}
+
+static void set_tmout_and_fsm(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+
+        ci_otg_queue_work(ci);
+}
+
+static void a_wait_vfall_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+        /* Disable port power */
+        hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP, 0);
+        /* Clear exsiting DP irq */
+        hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
+        /* Enable data pulse irq */
+        hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE);
+        ci_otg_queue_work(ci);
+}
+
+static void b_ase0_brst_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+        if (!hw_read_otgsc(ci, OTGSC_BSV))
+                ci->fsm.b_sess_vld = 0;
+
+        ci_otg_queue_work(ci);
+}
+
+static void b_ssend_srp_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+
+        /* only vbus fall below B_sess_vld in b_idle state */
+        if (ci->transceiver->state == OTG_STATE_B_IDLE)
+                ci_otg_queue_work(ci);
+}
+
+static void b_sess_vld_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        /* Check if A detached */
+        if (!(hw_read_otgsc(ci, OTGSC_BSV))) {
+                ci->fsm.b_sess_vld = 0;
+                ci_otg_add_timer(ci, B_SSEND_SRP);
+                ci_otg_queue_work(ci);
+        }
+}
+
+static void b_data_pulse_end(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        ci->fsm.b_srp_done = 1;
+        ci->fsm.b_bus_req = 0;
+        if (ci->fsm.power_up)
+                ci->fsm.power_up = 0;
+
+        hw_write_otgsc(ci, OTGSC_HABA, 0);
+
+        ci_otg_queue_work(ci);
+}
+
+/* Initialize timers */
+static int ci_otg_init_timers(struct ci_hdrc *ci)
+{
+        struct otg_fsm *fsm = &ci->fsm;
+
+        /* FSM used timers */
+        ci->fsm_timer->timer_list[A_WAIT_VRISE] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_VRISE,
+                        (unsigned long)&fsm->a_wait_vrise_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_VRISE] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_WAIT_VFALL] =
+                otg_timer_initializer(ci, &a_wait_vfall_tmout_func,
+                TA_WAIT_VFALL, (unsigned long)&fsm->a_wait_vfall_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_VFALL] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_WAIT_BCON] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_BCON,
+                                (unsigned long)&fsm->a_wait_bcon_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_BCON] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_AIDL_BDIS] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_AIDL_BDIS,
+                                (unsigned long)&fsm->a_aidl_bdis_tmout);
+        if (ci->fsm_timer->timer_list[A_AIDL_BDIS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_BIDL_ADIS] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_BIDL_ADIS,
+                                (unsigned long)&fsm->a_bidl_adis_tmout);
+        if (ci->fsm_timer->timer_list[A_BIDL_ADIS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_ASE0_BRST] =
+                otg_timer_initializer(ci, &b_ase0_brst_tmout_func, TB_ASE0_BRST,
+                                        (unsigned long)&fsm->b_ase0_brst_tmout);
+        if (ci->fsm_timer->timer_list[B_ASE0_BRST] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SE0_SRP] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TB_SE0_SRP,
+                                        (unsigned long)&fsm->b_se0_srp);
+        if (ci->fsm_timer->timer_list[B_SE0_SRP] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SSEND_SRP] =
+                otg_timer_initializer(ci, &b_ssend_srp_tmout_func, TB_SSEND_SRP,
+                                        (unsigned long)&fsm->b_ssend_srp);
+        if (ci->fsm_timer->timer_list[B_SSEND_SRP] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SRP_FAIL] =
+                otg_timer_initializer(ci, &set_tmout, TB_SRP_FAIL,
+                                (unsigned long)&fsm->b_srp_done);
+        if (ci->fsm_timer->timer_list[B_SRP_FAIL] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_DATA_PLS] =
+                otg_timer_initializer(ci, &b_data_pulse_end, TB_DATA_PLS, 0);
+        if (ci->fsm_timer->timer_list[B_DATA_PLS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SESS_VLD] = otg_timer_initializer(ci,
+                                        &b_sess_vld_tmout_func, TB_SESS_VLD, 0);
+        if (ci->fsm_timer->timer_list[B_SESS_VLD] == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+/* -------------------------------------------------------------*/
+/* Operations that will be called from OTG Finite State Machine */
+/* -------------------------------------------------------------*/
+static void ci_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (t < NUM_OTG_FSM_TIMERS)
+                ci_otg_add_timer(ci, t);
+        return;
+}
+
+static void ci_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (t < NUM_OTG_FSM_TIMERS)
+                ci_otg_del_timer(ci, t);
+        return;
+}
+
+/*
+ * A-device drive vbus: turn on vbus regulator and enable port power
+ * Data pulse irq should be disabled while vbus is on.
+ */
+static void ci_otg_drv_vbus(struct otg_fsm *fsm, int on)
+{
+        int ret;
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on) {
+                /* Enable power power */
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP,
+                                                        PORTSC_PP);
+                if (ci->platdata->reg_vbus) {
+                        ret = regulator_enable(ci->platdata->reg_vbus);
+                        if (ret) {
+                                dev_err(ci->dev,
+                                "Failed to enable vbus regulator, ret=%d\n",
+                                ret);
+                                return;
+                        }
+                }
+                /* Disable data pulse irq */
+                hw_write_otgsc(ci, OTGSC_DPIE, 0);
+
+                fsm->a_srp_det = 0;
+                fsm->power_up = 0;
+        } else {
+                if (ci->platdata->reg_vbus)
+                        regulator_disable(ci->platdata->reg_vbus);
+
+                fsm->a_bus_drop = 1;
+                fsm->a_bus_req = 0;
+        }
+}
+
+/*
+ * Control data line by Run Stop bit.
+ */
+static void ci_otg_loc_conn(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on)
+                hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
+        else
+                hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
+}
+
+/*
+ * Generate SOF by host.
+ * This is controlled through suspend/resume the port.
+ * In host mode, controller will automatically send SOF.
+ * Suspend will block the data on the port.
+ */
+static void ci_otg_loc_sof(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on)
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_FPR,
+                                                        PORTSC_FPR);
+        else
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_SUSP,
+                                                        PORTSC_SUSP);
+}
+
+/*
+ * Start SRP pulsing by data-line pulsing,
+ * no v-bus pulsing followed
+ */
+static void ci_otg_start_pulse(struct otg_fsm *fsm)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        /* Hardware Assistant Data pulse */
+        hw_write_otgsc(ci, OTGSC_HADP, OTGSC_HADP);
+
+        ci_otg_add_timer(ci, B_DATA_PLS);
+}
+
+static int ci_otg_start_host(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        mutex_unlock(&fsm->lock);
+        if (on) {
+                ci_role_stop(ci);
+                ci_role_start(ci, CI_ROLE_HOST);
+        } else {
+                ci_role_stop(ci);
+                hw_device_reset(ci, USBMODE_CM_DC);
+                ci_role_start(ci, CI_ROLE_GADGET);
+        }
+        mutex_lock(&fsm->lock);
+        return 0;
+}
+
+static int ci_otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        mutex_unlock(&fsm->lock);
+        if (on)
+                usb_gadget_vbus_connect(&ci->gadget);
+        else
+                usb_gadget_vbus_disconnect(&ci->gadget);
+        mutex_lock(&fsm->lock);
+
+        return 0;
+}
+
+static struct otg_fsm_ops ci_otg_ops = {
+        .drv_vbus = ci_otg_drv_vbus,
+        .loc_conn = ci_otg_loc_conn,
+        .loc_sof = ci_otg_loc_sof,
+        .start_pulse = ci_otg_start_pulse,
+        .add_timer = ci_otg_fsm_add_timer,
+        .del_timer = ci_otg_fsm_del_timer,
+        .start_host = ci_otg_start_host,
+        .start_gadget = ci_otg_start_gadget,
+};
+
+int ci_otg_fsm_work(struct ci_hdrc *ci)
+{
+        /*
+         * Don't do fsm transition for B device
+         * when there is no gadget class driver
+         */
+        if (ci->fsm.id && !(ci->driver) &&
+                ci->transceiver->state < OTG_STATE_A_IDLE)
+                return 0;
+
+        if (otg_statemachine(&ci->fsm)) {
+                if (ci->transceiver->state == OTG_STATE_A_IDLE) {
+                        /*
+                         * Further state change for cases:
+                         * a_idle to b_idle; or
+                         * a_idle to a_wait_vrise due to ID change(1->0), so
+                         * B-dev becomes A-dev can try to start new session
+                         * consequently; or
+                         * a_idle to a_wait_vrise when power up
+                         */
+                        if ((ci->fsm.id) || (ci->id_event) ||
+                                                (ci->fsm.power_up))
+                                ci_otg_queue_work(ci);
+                        if (ci->id_event)
+                                ci->id_event = false;
+                } else if (ci->transceiver->state == OTG_STATE_B_IDLE) {
+                        if (ci->fsm.b_sess_vld) {
+                                ci->fsm.power_up = 0;
+                                /*
+                                 * Further transite to b_periphearl state
+                                 * when register gadget driver with vbus on
+                                 */
+                                ci_otg_queue_work(ci);
+                        }
+                }
+        }
+        return 0;
+}
+
+/*
+ * Update fsm variables in each state if catching expected interrupts,
+ * called by otg fsm isr.
+ */
+static void ci_otg_fsm_event(struct ci_hdrc *ci)
+{
+        u32 intr_sts, otg_bsess_vld, port_conn;
+        struct otg_fsm *fsm = &ci->fsm;
+
+        intr_sts = hw_read_intr_status(ci);
+        otg_bsess_vld = hw_read_otgsc(ci, OTGSC_BSV);
+        port_conn = hw_read(ci, OP_PORTSC, PORTSC_CCS);
+
+        switch (ci->transceiver->state) {
+        case OTG_STATE_A_WAIT_BCON:
+                if (port_conn) {
+                        fsm->b_conn = 1;
+                        fsm->a_bus_req = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_IDLE:
+                if (otg_bsess_vld && (intr_sts & USBi_PCI) && port_conn) {
+                        fsm->b_sess_vld = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if ((intr_sts & USBi_SLI) && port_conn && otg_bsess_vld) {
+                        fsm->a_bus_suspend = 1;
+                        ci_otg_queue_work(ci);
+                } else if (intr_sts & USBi_PCI) {
+                        if (fsm->a_bus_suspend == 1)
+                                fsm->a_bus_suspend = 0;
+                }
+                break;
+        case OTG_STATE_B_HOST:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->a_conn = 0;
+                        fsm->b_bus_req = 0;
+                        ci_otg_queue_work(ci);
+                        ci_otg_add_timer(ci, B_SESS_VLD);
+                }
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                if (intr_sts & USBi_SLI) {
+                         fsm->b_bus_suspend = 1;
+                        /*
+                         * Init a timer to know how long this suspend
+                         * will contine, if time out, indicates B no longer
+                         * wants to be host role
+                         */
+                         ci_otg_add_timer(ci, A_BIDL_ADIS);
+                }
+
+                if (intr_sts & USBi_URI)
+                        ci_otg_del_timer(ci, A_BIDL_ADIS);
+
+                if (intr_sts & USBi_PCI) {
+                        if (fsm->b_bus_suspend == 1) {
+                                ci_otg_del_timer(ci, A_BIDL_ADIS);
+                                fsm->b_bus_suspend = 0;
+                        }
+                }
+                break;
+        case OTG_STATE_A_SUSPEND:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->b_conn = 0;
+
+                        /* if gadget driver is binded */
+                        if (ci->driver) {
+                                /* A device to be peripheral mode */
+                                ci->gadget.is_a_peripheral = 1;
+                        }
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_A_HOST:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->b_conn = 0;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                if ((intr_sts & USBi_PCI) && port_conn) {
+                        fsm->a_conn = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+/*
+ * ci_otg_irq - otg fsm related irq handling
+ * and also update otg fsm variable by monitoring usb host and udc
+ * state change interrupts.
+ * @ci: ci_hdrc
+ */
+irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
+{
+        irqreturn_t retval =  IRQ_NONE;
+        u32 otgsc, otg_int_src = 0;
+        struct otg_fsm *fsm = &ci->fsm;
+
+        otgsc = hw_read_otgsc(ci, ~0);
+        otg_int_src = otgsc & OTGSC_INT_STATUS_BITS & (otgsc >> 8);
+        fsm->id = (otgsc & OTGSC_ID) ? 1 : 0;
+
+        if (otg_int_src) {
+                if (otg_int_src & OTGSC_1MSIS) {
+                        hw_write_otgsc(ci, OTGSC_1MSIS, OTGSC_1MSIS);
+                        retval = ci_otg_tick_timer(ci);
+                        return IRQ_HANDLED;
+                } else if (otg_int_src & OTGSC_DPIS) {
+                        hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
+                        fsm->a_srp_det = 1;
+                        fsm->a_bus_drop = 0;
+                } else if (otg_int_src & OTGSC_IDIS) {
+                        hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS);
+                        if (fsm->id == 0) {
+                                fsm->a_bus_drop = 0;
+                                fsm->a_bus_req = 1;
+                                ci->id_event = true;
+                        }
+                } else if (otg_int_src & OTGSC_BSVIS) {
+                        hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS);
+                        if (otgsc & OTGSC_BSV) {
+                                fsm->b_sess_vld = 1;
+                                ci_otg_del_timer(ci, B_SSEND_SRP);
+                                ci_otg_del_timer(ci, B_SRP_FAIL);
+                                fsm->b_ssend_srp = 0;
+                        } else {
+                                fsm->b_sess_vld = 0;
+                                if (fsm->id)
+                                        ci_otg_add_timer(ci, B_SSEND_SRP);
+                        }
+                } else if (otg_int_src & OTGSC_AVVIS) {
+                        hw_write_otgsc(ci, OTGSC_AVVIS, OTGSC_AVVIS);
+                        if (otgsc & OTGSC_AVV) {
+                                fsm->a_vbus_vld = 1;
+                        } else {
+                                fsm->a_vbus_vld = 0;
+                                fsm->b_conn = 0;
+                        }
+                }
+                ci_otg_queue_work(ci);
+                return IRQ_HANDLED;
+        }
+
+        ci_otg_fsm_event(ci);
+
+        return retval;
+}
+
+void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
+{
+        ci_otg_queue_work(ci);
+}
+
+int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
+{
+        int retval = 0;
+        struct usb_otg *otg;
+
+        otg = devm_kzalloc(ci->dev,
+                        sizeof(struct usb_otg), GFP_KERNEL);
+        if (!otg) {
+                dev_err(ci->dev,
+                "Failed to allocate usb_otg structure for ci hdrc otg!\n");
+                return -ENOMEM;
+        }
+
+        otg->phy = ci->transceiver;
+        otg->gadget = &ci->gadget;
+        ci->fsm.otg = otg;
+        ci->transceiver->otg = ci->fsm.otg;
+        ci->fsm.power_up = 1;
+        ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0;
+        ci->transceiver->state = OTG_STATE_UNDEFINED;
+        ci->fsm.ops = &ci_otg_ops;
+
+        mutex_init(&ci->fsm.lock);
+
+        ci->fsm_timer = devm_kzalloc(ci->dev,
+                        sizeof(struct ci_otg_fsm_timer_list), GFP_KERNEL);
+        if (!ci->fsm_timer) {
+                dev_err(ci->dev,
+                "Failed to allocate timer structure for ci hdrc otg!\n");
+                return -ENOMEM;
+        }
+
+        INIT_LIST_HEAD(&ci->fsm_timer->active_timers);
+        retval = ci_otg_init_timers(ci);
+        if (retval) {
+                dev_err(ci->dev, "Couldn't init OTG timers\n");
+                return retval;
+        }
+
+        retval = sysfs_create_group(&ci->dev->kobj, &inputs_attr_group);
+        if (retval < 0) {
+                dev_dbg(ci->dev,
+                        "Can't register sysfs attr group: %d\n", retval);
+                return retval;
+        }
+
+        /* Enable A vbus valid irq */
+        hw_write_otgsc(ci, OTGSC_AVVIE, OTGSC_AVVIE);
+
+        if (ci->fsm.id) {
+                ci->fsm.b_ssend_srp =
+                        hw_read_otgsc(ci, OTGSC_BSV) ? 0 : 1;
+                ci->fsm.b_sess_vld =
+                        hw_read_otgsc(ci, OTGSC_BSV) ? 1 : 0;
+                /* Enable BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIE, OTGSC_BSVIE);
+        }
+
+        return 0;
+}
+
+void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
+{
+        sysfs_remove_group(&ci->dev->kobj, &inputs_attr_group);
+}
diff --git a/drivers/usb/chipidea/otg_fsm.h b/drivers/usb/chipidea/otg_fsm.h
new file mode 100644
index 000000000000..94c085f456a9
--- /dev/null
+++ b/drivers/usb/chipidea/otg_fsm.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2014 Freescale Semiconductor, Inc.
+ *
+ * Author: Jun Li
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __DRIVERS_USB_CHIPIDEA_OTG_FSM_H
+#define __DRIVERS_USB_CHIPIDEA_OTG_FSM_H
+
+#include <linux/usb/otg-fsm.h>
+
+/*
+ *  A-DEVICE timing  constants
+ */
+
+/* Wait for VBUS Rise  */
+#define TA_WAIT_VRISE        (100)      /* a_wait_vrise: section 7.1.2
+                                         * a_wait_vrise_tmr: section 7.4.5.1
+                                         * TA_VBUS_RISE <= 100ms, section 4.4
+                                         * Table 4-1: Electrical Characteristics
+                                         * ->DC Electrical Timing
+                                         */
+/* Wait for VBUS Fall  */
+#define TA_WAIT_VFALL        (1000)     /* a_wait_vfall: section 7.1.7
+                                         * a_wait_vfall_tmr: section: 7.4.5.2
+                                         */
+/* Wait for B-Connect */
+#define TA_WAIT_BCON         (10000)    /* a_wait_bcon: section 7.1.3
+                                         * TA_WAIT_BCON: should be between 1100
+                                         * and 30000 ms, section 5.5, Table 5-1
+                                         */
+/* A-Idle to B-Disconnect */
+#define TA_AIDL_BDIS         (5000)     /* a_suspend min 200 ms, section 5.2.1
+                                         * TA_AIDL_BDIS: section 5.5, Table 5-1
+                                         */
+/* B-Idle to A-Disconnect */
+#define TA_BIDL_ADIS         (500)      /* TA_BIDL_ADIS: section 5.2.1
+                                         * 500ms is used for B switch to host
+                                         * for safe
+                                         */
+
+/*
+ * B-device timing constants
+ */
+
+/* Data-Line Pulse Time*/
+#define TB_DATA_PLS          (10)       /* b_srp_init,continue 5~10ms
+                                         * section:5.1.3
+                                         */
+/* SRP Fail Time  */
+#define TB_SRP_FAIL          (6000)     /* b_srp_init,fail time 5~6s
+                                         * section:5.1.6
+                                         */
+/* A-SE0 to B-Reset  */
+#define TB_ASE0_BRST         (155)      /* minimum 155 ms, section:5.3.1 */
+/* SE0 Time Before SRP */
+#define TB_SE0_SRP           (1000)     /* b_idle,minimum 1s, section:5.1.2 */
+/* SSEND time before SRP */
+#define TB_SSEND_SRP         (1500)     /* minimum 1.5 sec, section:5.1.2 */
+
+#define TB_SESS_VLD          (1000)
+
+enum ci_otg_fsm_timer_index {
+        /*
+         * CI specific timers, start from the end
+         * of standard and auxiliary OTG timers
+         */
+        B_DATA_PLS = NUM_OTG_FSM_TIMERS,
+        B_SSEND_SRP,
+        B_SESS_VLD,
+
+        NUM_CI_OTG_FSM_TIMERS,
+};
+
+struct ci_otg_fsm_timer {
+        unsigned long expires;  /* Number of count increase to timeout */
+        unsigned long count;    /* Tick counter */
+        void (*function)(void *, unsigned long);        /* Timeout function */
+        unsigned long data;     /* Data passed to function */
+        struct list_head list;
+};
+
+struct ci_otg_fsm_timer_list {
+        struct ci_otg_fsm_timer *timer_list[NUM_CI_OTG_FSM_TIMERS];
+        struct list_head active_timers;
+};
+
+#ifdef CONFIG_USB_OTG_FSM
+
+int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci);
+int ci_otg_fsm_work(struct ci_hdrc *ci);
+irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci);
+void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci);
+void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci);
+
+#else
+
+static inline int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
+{
+        return 0;
+}
+
+static inline int ci_otg_fsm_work(struct ci_hdrc *ci)
+{
+        return -ENXIO;
+}
+
+static inline irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
+{
+        return IRQ_NONE;
+}
+
+static inline void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
+{
+
+}
+
+static inline void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
+{
+
+}
+
+#endif
+
+#endif /* __DRIVERS_USB_CHIPIDEA_OTG_FSM_H */
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index 7739c64ef259..69425b3cb6b7 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -20,6 +20,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg-fsm.h>
 #include <linux/usb/chipidea.h>
 
 #include "ci.h"
@@ -27,6 +28,7 @@
 #include "bits.h"
 #include "debug.h"
 #include "otg.h"
+#include "otg_fsm.h"
 
 /* control endpoint description */
 static const struct usb_endpoint_descriptor
@@ -242,26 +244,6 @@ static int hw_port_is_high_speed(struct ci_hdrc *ci)
 }
 
 /**
- * hw_read_intr_enable: returns interrupt enable register
- *
- * This function returns register data
- */
-static u32 hw_read_intr_enable(struct ci_hdrc *ci)
-{
-        return hw_read(ci, OP_USBINTR, ~0);
-}
-
-/**
- * hw_read_intr_status: returns interrupt status register
- *
- * This function returns register data
- */
-static u32 hw_read_intr_status(struct ci_hdrc *ci)
-{
-        return hw_read(ci, OP_USBSTS, ~0);
-}
-
-/**
  * hw_test_and_clear_complete: test & clear complete status (execute without
  *                             interruption)
  * @n: endpoint number
@@ -727,6 +709,8 @@ __acquires(ci->lock)
         if (ci->status == NULL)
                 retval = -ENOMEM;
 
+        usb_gadget_set_state(&ci->gadget, USB_STATE_DEFAULT);
+
 done:
         spin_lock(&ci->lock);
 
@@ -841,7 +825,6 @@ __acquires(hwep->lock)
         if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
                 /* Assume that device is bus powered for now. */
                 *(u16 *)req->buf = ci->remote_wakeup << 1;
-                retval = 0;
         } else if ((setup->bRequestType & USB_RECIP_MASK) \
                    == USB_RECIP_ENDPOINT) {
                 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
@@ -883,6 +866,8 @@ isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
         if (ci->setaddr) {
                 hw_usb_set_address(ci, ci->address);
                 ci->setaddr = false;
+                if (ci->address)
+                        usb_gadget_set_state(&ci->gadget, USB_STATE_ADDRESS);
         }
 
         spin_lock_irqsave(&ci->lock, flags);
@@ -1072,6 +1057,14 @@ __acquires(ci->lock)
                                 default:
                                         break;
                                 }
+                                break;
+                        case USB_DEVICE_B_HNP_ENABLE:
+                                if (ci_otg_is_fsm_mode(ci)) {
+                                        ci->gadget.b_hnp_enable = 1;
+                                        err = isr_setup_status_phase(
+                                                        ci);
+                                }
+                                break;
                         default:
                                 goto delegate;
                         }
@@ -1477,7 +1470,7 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                         pm_runtime_get_sync(&_gadget->dev);
                         hw_device_reset(ci, USBMODE_CM_DC);
                         hw_device_state(ci, ci->ep0out->qh.dma);
-                        dev_dbg(ci->dev, "Connected to host\n");
+                        usb_gadget_set_state(_gadget, USB_STATE_POWERED);
                 } else {
                         if (ci->driver)
                                 ci->driver->disconnect(&ci->gadget);
@@ -1487,7 +1480,7 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                                 CI_HDRC_CONTROLLER_STOPPED_EVENT);
                         _gadget_stop_activity(&ci->gadget);
                         pm_runtime_put_sync(&_gadget->dev);
-                        dev_dbg(ci->dev, "Disconnected from host\n");
+                        usb_gadget_set_state(_gadget, USB_STATE_NOTATTACHED);
                 }
         }
 
@@ -1655,6 +1648,13 @@ static int ci_udc_start(struct usb_gadget *gadget,
                 return retval;
 
         ci->driver = driver;
+
+        /* Start otg fsm for B-device */
+        if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) {
+                ci_hdrc_otg_fsm_start(ci);
+                return retval;
+        }
+
         pm_runtime_get_sync(&ci->gadget.dev);
         if (ci->vbus_active) {
                 spin_lock_irqsave(&ci->lock, flags);
@@ -1753,6 +1753,8 @@ static irqreturn_t udc_irq(struct ci_hdrc *ci)
                                 ci->suspended = 1;
                                 spin_unlock(&ci->lock);
                                 ci->driver->suspend(&ci->gadget);
+                                usb_gadget_set_state(&ci->gadget,
+                                                USB_STATE_SUSPENDED);
                                 spin_lock(&ci->lock);
                         }
                 }
@@ -1779,7 +1781,7 @@ static int udc_start(struct ci_hdrc *ci)
         ci->gadget.ops          = &usb_gadget_ops;
         ci->gadget.speed        = USB_SPEED_UNKNOWN;
         ci->gadget.max_speed    = USB_SPEED_HIGH;
-        ci->gadget.is_otg       = 0;
+        ci->gadget.is_otg       = ci->is_otg ? 1 : 0;
         ci->gadget.name         = ci->platdata->name;
 
         INIT_LIST_HEAD(&ci->gadget.ep_list);
@@ -1843,21 +1845,22 @@ void ci_hdrc_gadget_destroy(struct ci_hdrc *ci)
 
 static int udc_id_switch_for_device(struct ci_hdrc *ci)
 {
-        if (ci->is_otg) {
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                ci_enable_otg_interrupt(ci, OTGSC_BSVIE);
-        }
+        if (ci->is_otg)
+                /* Clear and enable BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIS | OTGSC_BSVIE,
+                                        OTGSC_BSVIS | OTGSC_BSVIE);
 
         return 0;
 }
 
 static void udc_id_switch_for_host(struct ci_hdrc *ci)
 {
-        if (ci->is_otg) {
-                /* host doesn't care B_SESSION_VALID event */
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                ci_disable_otg_interrupt(ci, OTGSC_BSVIE);
-        }
+        /*
+         * host doesn't care B_SESSION_VALID event
+         * so clear and disbale BSV irq
+         */
+        if (ci->is_otg)
+                hw_write_otgsc(ci, OTGSC_BSVIE | OTGSC_BSVIS, OTGSC_BSVIS);
 }
 
 /**
diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbmisc_imx.c
index cd061abe3507..85293b8b1df9 100644
--- a/drivers/usb/chipidea/usbmisc_imx.c
+++ b/drivers/usb/chipidea/usbmisc_imx.c
@@ -21,16 +21,39 @@
 #define MX25_USB_PHY_CTRL_OFFSET        0x08
 #define MX25_BM_EXTERNAL_VBUS_DIVIDER   BIT(23)
 
+#define MX25_EHCI_INTERFACE_SINGLE_UNI  (2 << 0)
+#define MX25_EHCI_INTERFACE_DIFF_UNI    (0 << 0)
+#define MX25_EHCI_INTERFACE_MASK        (0xf)
+
+#define MX25_OTG_SIC_SHIFT              29
+#define MX25_OTG_SIC_MASK               (0x3 << MX25_OTG_SIC_SHIFT)
+#define MX25_OTG_PM_BIT                 BIT(24)
+#define MX25_OTG_PP_BIT                 BIT(11)
+#define MX25_OTG_OCPOL_BIT              BIT(3)
+
+#define MX25_H1_SIC_SHIFT               21
+#define MX25_H1_SIC_MASK                (0x3 << MX25_H1_SIC_SHIFT)
+#define MX25_H1_PP_BIT                  BIT(18)
+#define MX25_H1_PM_BIT                  BIT(16)
+#define MX25_H1_IPPUE_UP_BIT            BIT(7)
+#define MX25_H1_IPPUE_DOWN_BIT          BIT(6)
+#define MX25_H1_TLL_BIT                 BIT(5)
+#define MX25_H1_USBTE_BIT               BIT(4)
+#define MX25_H1_OCPOL_BIT               BIT(2)
+
 #define MX27_H1_PM_BIT                  BIT(8)
 #define MX27_H2_PM_BIT                  BIT(16)
 #define MX27_OTG_PM_BIT                 BIT(24)
 
 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
+#define MX53_USB_OTG_PHY_CTRL_1_OFFSET  0x0c
 #define MX53_USB_UH2_CTRL_OFFSET        0x14
 #define MX53_USB_UH3_CTRL_OFFSET        0x18
 #define MX53_BM_OVER_CUR_DIS_H1         BIT(5)
 #define MX53_BM_OVER_CUR_DIS_OTG        BIT(8)
 #define MX53_BM_OVER_CUR_DIS_UHx        BIT(30)
+#define MX53_USB_PHYCTRL1_PLLDIV_MASK   0x3
+#define MX53_USB_PLL_DIV_24_MHZ         0x01
 
 #define MX6_BM_OVER_CUR_DIS             BIT(7)
 
@@ -50,6 +73,39 @@ struct imx_usbmisc {
 
 static struct imx_usbmisc *usbmisc;
 
+static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
+{
+        unsigned long flags;
+        u32 val = 0;
+
+        if (data->index > 1)
+                return -EINVAL;
+
+        spin_lock_irqsave(&usbmisc->lock, flags);
+        switch (data->index) {
+        case 0:
+                val = readl(usbmisc->base);
+                val &= ~(MX25_OTG_SIC_MASK | MX25_OTG_PP_BIT);
+                val |= (MX25_EHCI_INTERFACE_DIFF_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_OTG_SIC_SHIFT;
+                val |= (MX25_OTG_PM_BIT | MX25_OTG_OCPOL_BIT);
+                writel(val, usbmisc->base);
+                break;
+        case 1:
+                val = readl(usbmisc->base);
+                val &= ~(MX25_H1_SIC_MASK | MX25_H1_PP_BIT |  MX25_H1_IPPUE_UP_BIT);
+                val |= (MX25_EHCI_INTERFACE_SINGLE_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_H1_SIC_SHIFT;
+                val |= (MX25_H1_PM_BIT | MX25_H1_OCPOL_BIT | MX25_H1_TLL_BIT |
+                        MX25_H1_USBTE_BIT | MX25_H1_IPPUE_DOWN_BIT);
+
+                writel(val, usbmisc->base);
+
+                break;
+        }
+        spin_unlock_irqrestore(&usbmisc->lock, flags);
+
+        return 0;
+}
+
 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 {
         void __iomem *reg;
@@ -111,6 +167,13 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
         if (data->index > 3)
                 return -EINVAL;
 
+        /* Select a 24 MHz reference clock for the PHY  */
+        reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET;
+        val = readl(reg);
+        val &= ~MX53_USB_PHYCTRL1_PLLDIV_MASK;
+        val |= MX53_USB_PLL_DIV_24_MHZ;
+        writel(val, usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
+
         if (data->disable_oc) {
                 spin_lock_irqsave(&usbmisc->lock, flags);
                 switch (data->index) {
@@ -159,6 +222,7 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 }
 
 static const struct usbmisc_ops imx25_usbmisc_ops = {
+        .init = usbmisc_imx25_init,
         .post = usbmisc_imx25_post,
 };
 
@@ -200,6 +264,10 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = {
                 .data = &imx25_usbmisc_ops,
         },
         {
+                .compatible = "fsl,imx35-usbmisc",
+                .data = &imx25_usbmisc_ops,
+        },
+        {
                 .compatible = "fsl,imx27-usbmisc",
                 .data = &imx27_usbmisc_ops,
         },
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 904efb6035b0..e934e19f49f5 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -122,13 +122,23 @@ static void acm_release_minor(struct acm *acm)
 static int acm_ctrl_msg(struct acm *acm, int request, int value,
                                                         void *buf, int len)
 {
-        int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
+        int retval;
+
+        retval = usb_autopm_get_interface(acm->control);
+        if (retval)
+                return retval;
+
+        retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
                 request, USB_RT_ACM, value,
                 acm->control->altsetting[0].desc.bInterfaceNumber,
                 buf, len, 5000);
+
         dev_dbg(&acm->control->dev,
                         "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
                         __func__, request, value, len, retval);
+
+        usb_autopm_put_interface(acm->control);
+
         return retval < 0 ? retval : 0;
 }
 
@@ -406,19 +416,21 @@ static void acm_read_bulk_callback(struct urb *urb)
                 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
                 return;
         }
-        usb_mark_last_busy(acm->dev);
 
         if (urb->status) {
                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
                                                         __func__, urb->status);
                 return;
         }
+
+        usb_mark_last_busy(acm->dev);
+
         acm_process_read_urb(acm, urb);
 
         /* throttle device if requested by tty */
         spin_lock_irqsave(&acm->read_lock, flags);
         acm->throttled = acm->throttle_req;
-        if (!acm->throttled && !acm->susp_count) {
+        if (!acm->throttled) {
                 spin_unlock_irqrestore(&acm->read_lock, flags);
                 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
         } else {
@@ -492,10 +504,30 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         return tty_port_open(&acm->port, tty, filp);
 }
 
+static void acm_port_dtr_rts(struct tty_port *port, int raise)
+{
+        struct acm *acm = container_of(port, struct acm, port);
+        int val;
+        int res;
+
+        if (raise)
+                val = ACM_CTRL_DTR | ACM_CTRL_RTS;
+        else
+                val = 0;
+
+        /* FIXME: add missing ctrlout locking throughout driver */
+        acm->ctrlout = val;
+
+        res = acm_set_control(acm, val);
+        if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
+                dev_err(&acm->control->dev, "failed to set dtr/rts\n");
+}
+
 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 {
         struct acm *acm = container_of(port, struct acm, port);
         int retval = -ENODEV;
+        int i;
 
         dev_dbg(&acm->control->dev, "%s\n", __func__);
 
@@ -515,22 +547,13 @@ static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
         acm->control->needs_remote_wakeup = 1;
 
         acm->ctrlurb->dev = acm->dev;
-        if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
+        retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
+        if (retval) {
                 dev_err(&acm->control->dev,
                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
-                usb_autopm_put_interface(acm->control);
                 goto error_submit_urb;
         }
 
-        acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
-        if (acm_set_control(acm, acm->ctrlout) < 0 &&
-            (acm->ctrl_caps & USB_CDC_CAP_LINE)) {
-                usb_autopm_put_interface(acm->control);
-                goto error_set_control;
-        }
-
-        usb_autopm_put_interface(acm->control);
-
         /*
          * Unthrottle device in case the TTY was closed while throttled.
          */
@@ -539,23 +562,27 @@ static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
         acm->throttle_req = 0;
         spin_unlock_irq(&acm->read_lock);
 
-        if (acm_submit_read_urbs(acm, GFP_KERNEL))
+        retval = acm_submit_read_urbs(acm, GFP_KERNEL);
+        if (retval)
                 goto error_submit_read_urbs;
 
+        usb_autopm_put_interface(acm->control);
+
         mutex_unlock(&acm->mutex);
 
         return 0;
 
 error_submit_read_urbs:
-        acm->ctrlout = 0;
-        acm_set_control(acm, acm->ctrlout);
-error_set_control:
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_kill_urb(acm->read_urbs[i]);
         usb_kill_urb(acm->ctrlurb);
 error_submit_urb:
+        usb_autopm_put_interface(acm->control);
 error_get_interface:
 disconnected:
         mutex_unlock(&acm->mutex);
-        return retval;
+
+        return usb_translate_errors(retval);
 }
 
 static void acm_port_destruct(struct tty_port *port)
@@ -573,23 +600,37 @@ static void acm_port_destruct(struct tty_port *port)
 static void acm_port_shutdown(struct tty_port *port)
 {
         struct acm *acm = container_of(port, struct acm, port);
+        struct urb *urb;
+        struct acm_wb *wb;
         int i;
 
         dev_dbg(&acm->control->dev, "%s\n", __func__);
 
-        mutex_lock(&acm->mutex);
-        if (!acm->disconnected) {
-                usb_autopm_get_interface(acm->control);
-                acm_set_control(acm, acm->ctrlout = 0);
-                usb_kill_urb(acm->ctrlurb);
-                for (i = 0; i < ACM_NW; i++)
-                        usb_kill_urb(acm->wb[i].urb);
-                for (i = 0; i < acm->rx_buflimit; i++)
-                        usb_kill_urb(acm->read_urbs[i]);
-                acm->control->needs_remote_wakeup = 0;
-                usb_autopm_put_interface(acm->control);
+        /*
+         * Need to grab write_lock to prevent race with resume, but no need to
+         * hold it due to the tty-port initialised flag.
+         */
+        spin_lock_irq(&acm->write_lock);
+        spin_unlock_irq(&acm->write_lock);
+
+        usb_autopm_get_interface_no_resume(acm->control);
+        acm->control->needs_remote_wakeup = 0;
+        usb_autopm_put_interface(acm->control);
+
+        for (;;) {
+                urb = usb_get_from_anchor(&acm->delayed);
+                if (!urb)
+                        break;
+                wb = urb->context;
+                wb->use = 0;
+                usb_autopm_put_interface_async(acm->control);
         }
-        mutex_unlock(&acm->mutex);
+
+        usb_kill_urb(acm->ctrlurb);
+        for (i = 0; i < ACM_NW; i++)
+                usb_kill_urb(acm->wb[i].urb);
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_kill_urb(acm->read_urbs[i]);
 }
 
 static void acm_tty_cleanup(struct tty_struct *tty)
@@ -646,16 +687,18 @@ static int acm_tty_write(struct tty_struct *tty,
         memcpy(wb->buf, buf, count);
         wb->len = count;
 
-        usb_autopm_get_interface_async(acm->control);
+        stat = usb_autopm_get_interface_async(acm->control);
+        if (stat) {
+                wb->use = 0;
+                spin_unlock_irqrestore(&acm->write_lock, flags);
+                return stat;
+        }
+
         if (acm->susp_count) {
-                if (!acm->delayed_wb)
-                        acm->delayed_wb = wb;
-                else
-                        usb_autopm_put_interface_async(acm->control);
+                usb_anchor_urb(wb->urb, &acm->delayed);
                 spin_unlock_irqrestore(&acm->write_lock, flags);
-                return count;   /* A white lie */
+                return count;
         }
-        usb_mark_last_busy(acm->dev);
 
         stat = acm_start_wb(acm, wb);
         spin_unlock_irqrestore(&acm->write_lock, flags);
@@ -958,6 +1001,7 @@ static void acm_tty_set_termios(struct tty_struct *tty,
 }
 
 static const struct tty_port_operations acm_port_ops = {
+        .dtr_rts = acm_port_dtr_rts,
         .shutdown = acm_port_shutdown,
         .activate = acm_port_activate,
         .destruct = acm_port_destruct,
@@ -1269,6 +1313,7 @@ made_compressed_probe:
                 acm->bInterval = epread->bInterval;
         tty_port_init(&acm->port);
         acm->port.ops = &acm_port_ops;
+        init_usb_anchor(&acm->delayed);
 
         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
@@ -1394,8 +1439,6 @@ skip_countries:
 
         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 
-        acm_set_control(acm, acm->ctrlout);
-
         acm->line.dwDTERate = cpu_to_le32(9600);
         acm->line.bDataBits = 8;
         acm_set_line(acm, &acm->line);
@@ -1514,27 +1557,20 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         struct acm *acm = usb_get_intfdata(intf);
         int cnt;
 
+        spin_lock_irq(&acm->write_lock);
         if (PMSG_IS_AUTO(message)) {
-                int b;
-
-                spin_lock_irq(&acm->write_lock);
-                b = acm->transmitting;
-                spin_unlock_irq(&acm->write_lock);
-                if (b)
+                if (acm->transmitting) {
+                        spin_unlock_irq(&acm->write_lock);
                         return -EBUSY;
+                }
         }
-
-        spin_lock_irq(&acm->read_lock);
-        spin_lock(&acm->write_lock);
         cnt = acm->susp_count++;
-        spin_unlock(&acm->write_lock);
-        spin_unlock_irq(&acm->read_lock);
+        spin_unlock_irq(&acm->write_lock);
 
         if (cnt)
                 return 0;
 
-        if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
-                stop_data_traffic(acm);
+        stop_data_traffic(acm);
 
         return 0;
 }
@@ -1542,29 +1578,23 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 static int acm_resume(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
-        struct acm_wb *wb;
+        struct urb *urb;
         int rv = 0;
-        int cnt;
 
-        spin_lock_irq(&acm->read_lock);
-        acm->susp_count -= 1;
-        cnt = acm->susp_count;
-        spin_unlock_irq(&acm->read_lock);
+        spin_lock_irq(&acm->write_lock);
 
-        if (cnt)
-                return 0;
+        if (--acm->susp_count)
+                goto out;
 
         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
-                rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
+                rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
 
-                spin_lock_irq(&acm->write_lock);
-                if (acm->delayed_wb) {
-                        wb = acm->delayed_wb;
-                        acm->delayed_wb = NULL;
-                        spin_unlock_irq(&acm->write_lock);
-                        acm_start_wb(acm, wb);
-                } else {
-                        spin_unlock_irq(&acm->write_lock);
+                for (;;) {
+                        urb = usb_get_from_anchor(&acm->delayed);
+                        if (!urb)
+                                break;
+
+                        acm_start_wb(acm, urb->context);
                 }
 
                 /*
@@ -1572,12 +1602,13 @@ static int acm_resume(struct usb_interface *intf)
                  * do the write path at all cost
                  */
                 if (rv < 0)
-                        goto err_out;
+                        goto out;
 
-                rv = acm_submit_read_urbs(acm, GFP_NOIO);
+                rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
         }
+out:
+        spin_unlock_irq(&acm->write_lock);
 
-err_out:
         return rv;
 }
 
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index e38dc785808f..fc75651afe1c 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -120,15 +120,15 @@ struct acm {
         unsigned int throttled:1;                       /* actually throttled */
         unsigned int throttle_req:1;                    /* throttle requested */
         u8 bInterval;
-        struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
+        struct usb_anchor delayed;                      /* writes queued for a device about to be woken */
 };
 
 #define CDC_DATA_INTERFACE_TYPE 0x0a
 
 /* constants describing various quirks and errors */
-#define NO_UNION_NORMAL                 1
-#define SINGLE_RX_URB                   2
-#define NO_CAP_LINE                     4
-#define NOT_A_MODEM                     8
-#define NO_DATA_INTERFACE               16
-#define IGNORE_DEVICE                   32
+#define NO_UNION_NORMAL                 BIT(0)
+#define SINGLE_RX_URB                   BIT(1)
+#define NO_CAP_LINE                     BIT(2)
+#define NOT_A_MODEM                     BIT(3)
+#define NO_DATA_INTERFACE               BIT(4)
+#define IGNORE_DEVICE                   BIT(5)
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index cfbec9c7e09e..103a6e9ee49d 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -383,9 +383,12 @@ exit:
 static int send_request_dev_dep_msg_in(struct usbtmc_device_data *data, size_t transfer_size)
 {
         int retval;
-        u8 buffer[USBTMC_HEADER_SIZE];
+        u8 *buffer;
         int actual;
 
+        buffer = kmalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
         /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message
          * Refer to class specs for details
          */
@@ -417,6 +420,7 @@ static int send_request_dev_dep_msg_in(struct usbtmc_device_data *data, size_t t
         if (!data->bTag)
                 data->bTag++;
 
+        kfree(buffer);
         if (retval < 0) {
                 dev_err(&data->intf->dev, "usb_bulk_msg in send_request_dev_dep_msg_in() returned %d\n", retval);
                 return retval;
diff --git a/drivers/usb/common/Makefile b/drivers/usb/common/Makefile
new file mode 100644
index 000000000000..752646167e1e
--- /dev/null
+++ b/drivers/usb/common/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the usb common parts.
+#
+
+obj-$(CONFIG_USB_COMMON) += usb-common.o
+obj-$(CONFIG_USB_OTG_FSM) += usb-otg-fsm.o
diff --git a/drivers/usb/usb-common.c b/drivers/usb/common/usb-common.c
index 6dfd30a863c7..6dfd30a863c7 100644
--- a/drivers/usb/usb-common.c
+++ b/drivers/usb/common/usb-common.c
diff --git a/drivers/usb/phy/phy-fsm-usb.c b/drivers/usb/common/usb-otg-fsm.c
index d03fadd2629f..98e8340a5bb1 100644
--- a/drivers/usb/phy/phy-fsm-usb.c
+++ b/drivers/usb/common/usb-otg-fsm.c
@@ -364,3 +364,4 @@ int otg_statemachine(struct otg_fsm *fsm)
         VDBG("quit statemachine, changed = %d\n", state_changed);
         return state_changed;
 }
+EXPORT_SYMBOL_GPL(otg_statemachine);
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index cb8e99156f5a..1060657ca1b0 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -1,13 +1,6 @@
 #
 # USB Core configuration
 #
-config USB_DEBUG
-        bool "USB verbose debug messages"
-        help
-          Say Y here if you want the USB core & hub drivers to produce a bunch
-          of debug messages to the system log. Select this if you are having a
-          problem with USB support and want to see more of what is going on.
-
 config USB_ANNOUNCE_NEW_DEVICES
         bool "USB announce new devices"
         help
@@ -88,3 +81,12 @@ config USB_OTG_BLACKLIST_HUB
           and software costs by not supporting external hubs.  So
           are "Embedded Hosts" that don't offer OTG support.
 
+config USB_OTG_FSM
+        tristate "USB 2.0 OTG FSM implementation"
+        depends on USB
+        select USB_OTG
+        select USB_PHY
+        help
+          Implements OTG Finite State Machine as specified in On-The-Go
+          and Embedded Host Supplement to the USB Revision 2.0 Specification.
+
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 1f02e65fe305..82044b5d6113 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -192,7 +192,6 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (pci_enable_device(dev) < 0)
                 return -ENODEV;
-        dev->current_state = PCI_D0;
 
         /*
          * The xHCI driver has its own irq management
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 9c4e2922b04d..bec31e2efb88 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -918,6 +918,7 @@ static void usb_bus_init (struct usb_bus *bus)
         bus->bandwidth_allocated = 0;
         bus->bandwidth_int_reqs  = 0;
         bus->bandwidth_isoc_reqs = 0;
+        mutex_init(&bus->usb_address0_mutex);
 
         INIT_LIST_HEAD (&bus->bus_list);
 }
@@ -1502,6 +1503,9 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
                                         ret = -EAGAIN;
                                 else
                                         urb->transfer_flags |= URB_DMA_MAP_PAGE;
+                        } else if (is_vmalloc_addr(urb->transfer_buffer)) {
+                                WARN_ONCE(1, "transfer buffer not dma capable\n");
+                                ret = -EAGAIN;
                         } else {
                                 urb->transfer_dma = dma_map_single(
                                                 hcd->self.controller,
@@ -2263,9 +2267,7 @@ static void hcd_resume_work(struct work_struct *work)
         struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
         struct usb_device *udev = hcd->self.root_hub;
 
-        usb_lock_device(udev);
         usb_remote_wakeup(udev);
-        usb_unlock_device(udev);
 }
 
 /**
@@ -2454,11 +2456,13 @@ struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
                 mutex_init(hcd->bandwidth_mutex);
                 dev_set_drvdata(dev, hcd);
         } else {
+                mutex_lock(&usb_port_peer_mutex);
                 hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
                 hcd->primary_hcd = primary_hcd;
                 primary_hcd->primary_hcd = primary_hcd;
                 hcd->shared_hcd = primary_hcd;
                 primary_hcd->shared_hcd = hcd;
+                mutex_unlock(&usb_port_peer_mutex);
         }
 
         kref_init(&hcd->kref);
@@ -2510,18 +2514,25 @@ EXPORT_SYMBOL_GPL(usb_create_hcd);
  * deallocated.
  *
  * Make sure to only deallocate the bandwidth_mutex when the primary HCD is
- * freed.  When hcd_release() is called for the non-primary HCD, set the
- * primary_hcd's shared_hcd pointer to null (since the non-primary HCD will be
- * freed shortly).
+ * freed.  When hcd_release() is called for either hcd in a peer set
+ * invalidate the peer's ->shared_hcd and ->primary_hcd pointers to
+ * block new peering attempts
  */
-static void hcd_release (struct kref *kref)
+static void hcd_release(struct kref *kref)
 {
         struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
 
+        mutex_lock(&usb_port_peer_mutex);
         if (usb_hcd_is_primary_hcd(hcd))
                 kfree(hcd->bandwidth_mutex);
-        else
-                hcd->shared_hcd->shared_hcd = NULL;
+        if (hcd->shared_hcd) {
+                struct usb_hcd *peer = hcd->shared_hcd;
+
+                peer->shared_hcd = NULL;
+                if (peer->primary_hcd == hcd)
+                        peer->primary_hcd = NULL;
+        }
+        mutex_unlock(&usb_port_peer_mutex);
         kfree(hcd);
 }
 
@@ -2589,6 +2600,21 @@ static int usb_hcd_request_irqs(struct usb_hcd *hcd,
         return 0;
 }
 
+/*
+ * Before we free this root hub, flush in-flight peering attempts
+ * and disable peer lookups
+ */
+static void usb_put_invalidate_rhdev(struct usb_hcd *hcd)
+{
+        struct usb_device *rhdev;
+
+        mutex_lock(&usb_port_peer_mutex);
+        rhdev = hcd->self.root_hub;
+        hcd->self.root_hub = NULL;
+        mutex_unlock(&usb_port_peer_mutex);
+        usb_put_dev(rhdev);
+}
+
 /**
  * usb_add_hcd - finish generic HCD structure initialization and register
  * @hcd: the usb_hcd structure to initialize
@@ -2649,7 +2675,9 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 retval = -ENOMEM;
                 goto err_allocate_root_hub;
         }
+        mutex_lock(&usb_port_peer_mutex);
         hcd->self.root_hub = rhdev;
+        mutex_unlock(&usb_port_peer_mutex);
 
         switch (hcd->speed) {
         case HCD_USB11:
@@ -2758,7 +2786,7 @@ err_hcd_driver_start:
 err_request_irq:
 err_hcd_driver_setup:
 err_set_rh_speed:
-        usb_put_dev(hcd->self.root_hub);
+        usb_put_invalidate_rhdev(hcd);
 err_allocate_root_hub:
         usb_deregister_bus(&hcd->self);
 err_register_bus:
@@ -2838,7 +2866,6 @@ void usb_remove_hcd(struct usb_hcd *hcd)
                         free_irq(hcd->irq, hcd);
         }
 
-        usb_put_dev(hcd->self.root_hub);
         usb_deregister_bus(&hcd->self);
         hcd_buffer_destroy(hcd);
         if (hcd->remove_phy && hcd->phy) {
@@ -2846,6 +2873,8 @@ void usb_remove_hcd(struct usb_hcd *hcd)
                 usb_put_phy(hcd->phy);
                 hcd->phy = NULL;
         }
+
+        usb_put_invalidate_rhdev(hcd);
 }
 EXPORT_SYMBOL_GPL(usb_remove_hcd);
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 090469ebfcff..db6287025c06 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -36,11 +36,6 @@
 #define USB_VENDOR_GENESYS_LOGIC                0x05e3
 #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND        0x01
 
-static inline int hub_is_superspeed(struct usb_device *hdev)
-{
-        return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS);
-}
-
 /* Protect struct usb_device->state and ->children members
  * Note: Both are also protected by ->dev.sem, except that ->state can
  * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
@@ -55,6 +50,9 @@ static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
 
 static struct task_struct *khubd_task;
 
+/* synchronize hub-port add/remove and peering operations */
+DEFINE_MUTEX(usb_port_peer_mutex);
+
 /* cycle leds on hubs that aren't blinking for attention */
 static bool blinkenlights = 0;
 module_param (blinkenlights, bool, S_IRUGO);
@@ -412,30 +410,35 @@ static int set_port_feature(struct usb_device *hdev, int port1, int feature)
                 NULL, 0, 1000);
 }
 
+static char *to_led_name(int selector)
+{
+        switch (selector) {
+        case HUB_LED_AMBER:
+                return "amber";
+        case HUB_LED_GREEN:
+                return "green";
+        case HUB_LED_OFF:
+                return "off";
+        case HUB_LED_AUTO:
+                return "auto";
+        default:
+                return "??";
+        }
+}
+
 /*
  * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
  * for info about using port indicators
  */
-static void set_port_led(
-        struct usb_hub *hub,
-        int port1,
-        int selector
-)
+static void set_port_led(struct usb_hub *hub, int port1, int selector)
 {
-        int status = set_port_feature(hub->hdev, (selector << 8) | port1,
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        int status;
+
+        status = set_port_feature(hub->hdev, (selector << 8) | port1,
                         USB_PORT_FEAT_INDICATOR);
-        if (status < 0)
-                dev_dbg (hub->intfdev,
-                        "port %d indicator %s status %d\n",
-                        port1,
-                        ({ char *s; switch (selector) {
-                        case HUB_LED_AMBER: s = "amber"; break;
-                        case HUB_LED_GREEN: s = "green"; break;
-                        case HUB_LED_OFF: s = "off"; break;
-                        case HUB_LED_AUTO: s = "auto"; break;
-                        default: s = "??"; break;
-                        } s; }),
-                        status);
+        dev_dbg(&port_dev->dev, "indicator %s status %d\n",
+                to_led_name(selector), status);
 }
 
 #define LED_CYCLE_PERIOD        ((2*HZ)/3)
@@ -743,16 +746,20 @@ int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
                            int port1, bool set)
 {
         int ret;
-        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         if (set)
                 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
         else
                 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
-        if (!ret)
-                port_dev->power_is_on = set;
-        return ret;
+        if (ret)
+                return ret;
+
+        if (set)
+                set_bit(port1, hub->power_bits);
+        else
+                clear_bit(port1, hub->power_bits);
+        return 0;
 }
 
 /**
@@ -810,16 +817,9 @@ int usb_hub_clear_tt_buffer(struct urb *urb)
 }
 EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
 
-/* If do_delay is false, return the number of milliseconds the caller
- * needs to delay.
- */
-static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
+static void hub_power_on(struct usb_hub *hub, bool do_delay)
 {
         int port1;
-        unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
-        unsigned delay;
-        u16 wHubCharacteristics =
-                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
         /* Enable power on each port.  Some hubs have reserved values
          * of LPSM (> 2) in their descriptors, even though they are
@@ -827,23 +827,19 @@ static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
          * but only emulate it.  In all cases, the ports won't work
          * unless we send these messages to the hub.
          */
-        if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
+        if (hub_is_port_power_switchable(hub))
                 dev_dbg(hub->intfdev, "enabling power on all ports\n");
         else
                 dev_dbg(hub->intfdev, "trying to enable port power on "
                                 "non-switchable hub\n");
         for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
-                if (hub->ports[port1 - 1]->power_is_on)
+                if (test_bit(port1, hub->power_bits))
                         set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
                 else
                         usb_clear_port_feature(hub->hdev, port1,
                                                 USB_PORT_FEAT_POWER);
-
-        /* Wait at least 100 msec for power to become stable */
-        delay = max(pgood_delay, (unsigned) 100);
         if (do_delay)
-                msleep(delay);
-        return delay;
+                msleep(hub_power_on_good_delay(hub));
 }
 
 static int hub_hub_status(struct usb_hub *hub,
@@ -911,20 +907,20 @@ static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
                 msleep(HUB_DEBOUNCE_STEP);
         }
         if (total_time >= HUB_DEBOUNCE_TIMEOUT)
-                dev_warn(hub->intfdev, "Could not disable port %d after %d ms\n",
-                                port1, total_time);
+                dev_warn(&hub->ports[port1 - 1]->dev,
+                                "Could not disable after %d ms\n", total_time);
 
         return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
 }
 
 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 {
+        struct usb_port *port_dev = hub->ports[port1 - 1];
         struct usb_device *hdev = hub->hdev;
         int ret = 0;
 
-        if (hub->ports[port1 - 1]->child && set_state)
-                usb_set_device_state(hub->ports[port1 - 1]->child,
-                                USB_STATE_NOTATTACHED);
+        if (port_dev->child && set_state)
+                usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
         if (!hub->error) {
                 if (hub_is_superspeed(hub->hdev))
                         ret = hub_usb3_port_disable(hub, port1);
@@ -933,8 +929,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
                                         USB_PORT_FEAT_ENABLE);
         }
         if (ret && ret != -ENODEV)
-                dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
-                                port1, ret);
+                dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
         return ret;
 }
 
@@ -945,7 +940,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
  */
 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
 {
-        dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
+        dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
         hub_port_disable(hub, port1, 1);
 
         /* FIXME let caller ask to power down the port:
@@ -1048,7 +1043,9 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                  * for HUB_POST_RESET, but it's easier not to.
                  */
                 if (type == HUB_INIT) {
-                        delay = hub_power_on(hub, false);
+                        unsigned delay = hub_power_on_good_delay(hub);
+
+                        hub_power_on(hub, false);
                         INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
                         queue_delayed_work(system_power_efficient_wq,
                                         &hub->init_work,
@@ -1083,21 +1080,23 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
         }
  init2:
 
-        /* Check each port and set hub->change_bits to let khubd know
+        /*
+         * Check each port and set hub->change_bits to let khubd know
          * which ports need attention.
          */
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device *udev = hub->ports[port1 - 1]->child;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
                 u16 portstatus, portchange;
 
                 portstatus = portchange = 0;
                 status = hub_port_status(hub, port1, &portstatus, &portchange);
                 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
-                        dev_dbg(hub->intfdev,
-                                        "port %d: status %04x change %04x\n",
-                                        port1, portstatus, portchange);
+                        dev_dbg(&port_dev->dev, "status %04x change %04x\n",
+                                        portstatus, portchange);
 
-                /* After anything other than HUB_RESUME (i.e., initialization
+                /*
+                 * After anything other than HUB_RESUME (i.e., initialization
                  * or any sort of reset), every port should be disabled.
                  * Unconnected ports should likewise be disabled (paranoia),
                  * and so should ports for which we have no usb_device.
@@ -1173,15 +1172,13 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                 set_bit(port1, hub->change_bits);
 
                 } else if (udev->persist_enabled) {
-                        struct usb_port *port_dev = hub->ports[port1 - 1];
-
 #ifdef CONFIG_PM
                         udev->reset_resume = 1;
 #endif
                         /* Don't set the change_bits when the device
                          * was powered off.
                          */
-                        if (port_dev->power_is_on)
+                        if (test_bit(port1, hub->power_bits))
                                 set_bit(port1, hub->change_bits);
 
                 } else {
@@ -1276,12 +1273,22 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
                 flush_work(&hub->tt.clear_work);
 }
 
+static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
+{
+        int i;
+
+        for (i = 0; i < hub->hdev->maxchild; ++i)
+                pm_runtime_barrier(&hub->ports[i]->dev);
+}
+
 /* caller has locked the hub device */
 static int hub_pre_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
         hub_quiesce(hub, HUB_PRE_RESET);
+        hub->in_reset = 1;
+        hub_pm_barrier_for_all_ports(hub);
         return 0;
 }
 
@@ -1290,6 +1297,8 @@ static int hub_post_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
+        hub->in_reset = 0;
+        hub_pm_barrier_for_all_ports(hub);
         hub_activate(hub, HUB_POST_RESET);
         return 0;
 }
@@ -1307,6 +1316,7 @@ static int hub_configure(struct usb_hub *hub,
         char *message = "out of memory";
         unsigned unit_load;
         unsigned full_load;
+        unsigned maxchild;
 
         hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
         if (!hub->buffer) {
@@ -1345,12 +1355,11 @@ static int hub_configure(struct usb_hub *hub,
                 goto fail;
         }
 
-        hdev->maxchild = hub->descriptor->bNbrPorts;
-        dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
-                (hdev->maxchild == 1) ? "" : "s");
+        maxchild = hub->descriptor->bNbrPorts;
+        dev_info(hub_dev, "%d port%s detected\n", maxchild,
+                        (maxchild == 1) ? "" : "s");
 
-        hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
-                             GFP_KERNEL);
+        hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL);
         if (!hub->ports) {
                 ret = -ENOMEM;
                 goto fail;
@@ -1371,11 +1380,11 @@ static int hub_configure(struct usb_hub *hub,
                 int     i;
                 char    portstr[USB_MAXCHILDREN + 1];
 
-                for (i = 0; i < hdev->maxchild; i++)
+                for (i = 0; i < maxchild; i++)
                         portstr[i] = hub->descriptor->u.hs.DeviceRemovable
                                     [((i + 1) / 8)] & (1 << ((i + 1) % 8))
                                 ? 'F' : 'R';
-                portstr[hdev->maxchild] = 0;
+                portstr[maxchild] = 0;
                 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
         } else
                 dev_dbg(hub_dev, "standalone hub\n");
@@ -1487,7 +1496,7 @@ static int hub_configure(struct usb_hub *hub,
                 if (hcd->power_budget > 0)
                         hdev->bus_mA = hcd->power_budget;
                 else
-                        hdev->bus_mA = full_load * hdev->maxchild;
+                        hdev->bus_mA = full_load * maxchild;
                 if (hdev->bus_mA >= full_load)
                         hub->mA_per_port = full_load;
                 else {
@@ -1502,7 +1511,7 @@ static int hub_configure(struct usb_hub *hub,
                         hub->descriptor->bHubContrCurrent);
                 hub->limited_power = 1;
 
-                if (remaining < hdev->maxchild * unit_load)
+                if (remaining < maxchild * unit_load)
                         dev_warn(hub_dev,
                                         "insufficient power available "
                                         "to use all downstream ports\n");
@@ -1570,15 +1579,19 @@ static int hub_configure(struct usb_hub *hub,
         if (hub->has_indicators && blinkenlights)
                 hub->indicator[0] = INDICATOR_CYCLE;
 
-        for (i = 0; i < hdev->maxchild; i++) {
+        mutex_lock(&usb_port_peer_mutex);
+        for (i = 0; i < maxchild; i++) {
                 ret = usb_hub_create_port_device(hub, i + 1);
                 if (ret < 0) {
                         dev_err(hub->intfdev,
                                 "couldn't create port%d device.\n", i + 1);
-                        hdev->maxchild = i;
-                        goto fail_keep_maxchild;
+                        break;
                 }
         }
+        hdev->maxchild = i;
+        mutex_unlock(&usb_port_peer_mutex);
+        if (ret < 0)
+                goto fail;
 
         usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
 
@@ -1586,8 +1599,6 @@ static int hub_configure(struct usb_hub *hub,
         return 0;
 
 fail:
-        hdev->maxchild = 0;
-fail_keep_maxchild:
         dev_err (hub_dev, "config failed, %s (err %d)\n",
                         message, ret);
         /* hub_disconnect() frees urb and descriptor */
@@ -1623,6 +1634,8 @@ static void hub_disconnect(struct usb_interface *intf)
         hub->error = 0;
         hub_quiesce(hub, HUB_DISCONNECT);
 
+        mutex_lock(&usb_port_peer_mutex);
+
         /* Avoid races with recursively_mark_NOTATTACHED() */
         spin_lock_irq(&device_state_lock);
         port1 = hdev->maxchild;
@@ -1633,6 +1646,8 @@ static void hub_disconnect(struct usb_interface *intf)
         for (; port1 > 0; --port1)
                 usb_hub_remove_port_device(hub, port1);
 
+        mutex_unlock(&usb_port_peer_mutex);
+
         if (hub->hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
@@ -2024,6 +2039,18 @@ static void hub_free_dev(struct usb_device *udev)
                 hcd->driver->free_dev(hcd, udev);
 }
 
+static void hub_disconnect_children(struct usb_device *udev)
+{
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev);
+        int i;
+
+        /* Free up all the children before we remove this device */
+        for (i = 0; i < udev->maxchild; i++) {
+                if (hub->ports[i]->child)
+                        usb_disconnect(&hub->ports[i]->child);
+        }
+}
+
 /**
  * usb_disconnect - disconnect a device (usbcore-internal)
  * @pdev: pointer to device being disconnected
@@ -2042,9 +2069,10 @@ static void hub_free_dev(struct usb_device *udev)
  */
 void usb_disconnect(struct usb_device **pdev)
 {
-        struct usb_device       *udev = *pdev;
-        struct usb_hub          *hub = usb_hub_to_struct_hub(udev);
-        int                     i;
+        struct usb_port *port_dev = NULL;
+        struct usb_device *udev = *pdev;
+        struct usb_hub *hub;
+        int port1;
 
         /* mark the device as inactive, so any further urb submissions for
          * this device (and any of its children) will fail immediately.
@@ -2056,11 +2084,7 @@ void usb_disconnect(struct usb_device **pdev)
 
         usb_lock_device(udev);
 
-        /* Free up all the children before we remove this device */
-        for (i = 0; i < udev->maxchild; i++) {
-                if (hub->ports[i]->child)
-                        usb_disconnect(&hub->ports[i]->child);
-        }
+        hub_disconnect_children(udev);
 
         /* deallocate hcd/hardware state ... nuking all pending urbs and
          * cleaning up all state associated with the current configuration
@@ -2071,16 +2095,19 @@ void usb_disconnect(struct usb_device **pdev)
         usb_hcd_synchronize_unlinks(udev);
 
         if (udev->parent) {
-                struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
-                struct usb_port *port_dev = hub->ports[udev->portnum - 1];
+                port1 = udev->portnum;
+                hub = usb_hub_to_struct_hub(udev->parent);
+                port_dev = hub->ports[port1 - 1];
 
                 sysfs_remove_link(&udev->dev.kobj, "port");
                 sysfs_remove_link(&port_dev->dev.kobj, "device");
 
-                if (!port_dev->did_runtime_put)
-                        pm_runtime_put(&port_dev->dev);
-                else
-                        port_dev->did_runtime_put = false;
+                /*
+                 * As usb_port_runtime_resume() de-references udev, make
+                 * sure no resumes occur during removal
+                 */
+                if (!test_and_set_bit(port1, hub->child_usage_bits))
+                        pm_runtime_get_sync(&port_dev->dev);
         }
 
         usb_remove_ep_devs(&udev->ep0);
@@ -2102,6 +2129,9 @@ void usb_disconnect(struct usb_device **pdev)
         *pdev = NULL;
         spin_unlock_irq(&device_state_lock);
 
+        if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
+                pm_runtime_put(&port_dev->dev);
+
         hub_free_dev(udev);
 
         put_device(&udev->dev);
@@ -2289,6 +2319,22 @@ static void set_usb_port_removable(struct usb_device *udev)
                 udev->removable = USB_DEVICE_REMOVABLE;
         else
                 udev->removable = USB_DEVICE_FIXED;
+
+        /*
+         * Platform firmware may have populated an alternative value for
+         * removable.  If the parent port has a known connect_type use
+         * that instead.
+         */
+        switch (hub->ports[udev->portnum - 1]->connect_type) {
+        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
+                udev->removable = USB_DEVICE_REMOVABLE;
+                break;
+        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
+                udev->removable = USB_DEVICE_FIXED;
+                break;
+        default: /* use what was set above */
+                break;
+        }
 }
 
 /**
@@ -2358,11 +2404,7 @@ int usb_new_device(struct usb_device *udev)
 
         device_enable_async_suspend(&udev->dev);
 
-        /*
-         * check whether the hub marks this port as non-removable. Do it
-         * now so that platform-specific data can override it in
-         * device_add()
-         */
+        /* check whether the hub or firmware marks this port as non-removable */
         if (udev->parent)
                 set_usb_port_removable(udev);
 
@@ -2379,7 +2421,8 @@ int usb_new_device(struct usb_device *udev)
         /* Create link files between child device and usb port device. */
         if (udev->parent) {
                 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
-                struct usb_port *port_dev = hub->ports[udev->portnum - 1];
+                int port1 = udev->portnum;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
 
                 err = sysfs_create_link(&udev->dev.kobj,
                                 &port_dev->dev.kobj, "port");
@@ -2393,7 +2436,8 @@ int usb_new_device(struct usb_device *udev)
                         goto fail;
                 }
 
-                pm_runtime_get_sync(&port_dev->dev);
+                if (!test_and_set_bit(port1, hub->child_usage_bits))
+                        pm_runtime_get_sync(&port_dev->dev);
         }
 
         (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
@@ -2561,9 +2605,9 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
                         delay = HUB_LONG_RESET_TIME;
 
-                dev_dbg (hub->intfdev,
-                        "port %d not %sreset yet, waiting %dms\n",
-                        port1, warm ? "warm " : "", delay);
+                dev_dbg(&hub->ports[port1 - 1]->dev,
+                                "not %sreset yet, waiting %dms\n",
+                                warm ? "warm " : "", delay);
         }
 
         if ((portstatus & USB_PORT_STAT_RESET))
@@ -2647,6 +2691,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
 {
         int i, status;
         u16 portchange, portstatus;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         if (!hub_is_superspeed(hub->hdev)) {
                 if (warm) {
@@ -2680,9 +2725,9 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 if (status == -ENODEV) {
                         ;       /* The hub is gone */
                 } else if (status) {
-                        dev_err(hub->intfdev,
-                                        "cannot %sreset port %d (err = %d)\n",
-                                        warm ? "warm " : "", port1, status);
+                        dev_err(&port_dev->dev,
+                                        "cannot %sreset (err = %d)\n",
+                                        warm ? "warm " : "", status);
                 } else {
                         status = hub_port_wait_reset(hub, port1, udev, delay,
                                                                 warm);
@@ -2715,21 +2760,19 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                          * hot or warm reset failed.  Try another warm reset.
                          */
                         if (!warm) {
-                                dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
-                                                port1);
+                                dev_dbg(&port_dev->dev,
+                                                "hot reset failed, warm reset\n");
                                 warm = true;
                         }
                 }
 
-                dev_dbg (hub->intfdev,
-                        "port %d not enabled, trying %sreset again...\n",
-                        port1, warm ? "warm " : "");
+                dev_dbg(&port_dev->dev,
+                                "not enabled, trying %sreset again...\n",
+                                warm ? "warm " : "");
                 delay = HUB_LONG_RESET_TIME;
         }
 
-        dev_err (hub->intfdev,
-                "Cannot enable port %i.  Maybe the USB cable is bad?\n",
-                port1);
+        dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
 
 done:
         if (!hub_is_superspeed(hub->hdev))
@@ -2754,6 +2797,20 @@ static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
         return ret;
 }
 
+static void usb_lock_port(struct usb_port *port_dev)
+                __acquires(&port_dev->status_lock)
+{
+        mutex_lock(&port_dev->status_lock);
+        __acquire(&port_dev->status_lock);
+}
+
+static void usb_unlock_port(struct usb_port *port_dev)
+                __releases(&port_dev->status_lock)
+{
+        mutex_unlock(&port_dev->status_lock);
+        __release(&port_dev->status_lock);
+}
+
 #ifdef  CONFIG_PM
 
 /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
@@ -2780,6 +2837,8 @@ static int check_port_resume_type(struct usb_device *udev,
                 struct usb_hub *hub, int port1,
                 int status, unsigned portchange, unsigned portstatus)
 {
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+
         /* Is the device still present? */
         if (status || port_is_suspended(hub, portstatus) ||
                         !port_is_power_on(hub, portstatus) ||
@@ -2799,9 +2858,8 @@ static int check_port_resume_type(struct usb_device *udev,
         }
 
         if (status) {
-                dev_dbg(hub->intfdev,
-                                "port %d status %04x.%04x after resume, %d\n",
-                                port1, portchange, portstatus, status);
+                dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
+                                portchange, portstatus, status);
         } else if (udev->reset_resume) {
 
                 /* Late port handoff can set status-change bits */
@@ -2975,6 +3033,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         int             status;
         bool            really_suspend = true;
 
+        usb_lock_port(port_dev);
+
         /* enable remote wakeup when appropriate; this lets the device
          * wake up the upstream hub (including maybe the root hub).
          *
@@ -3032,8 +3092,7 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 status = 0;
         }
         if (status) {
-                dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
-                                port1, status);
+                dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
 
                 /* Try to enable USB3 LPM and LTM again */
                 usb_unlocked_enable_lpm(udev);
@@ -3064,12 +3123,13 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
         }
 
-        if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled) {
+        if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
+                        && test_and_clear_bit(port1, hub->child_usage_bits))
                 pm_runtime_put_sync(&port_dev->dev);
-                port_dev->did_runtime_put = true;
-        }
 
         usb_mark_last_busy(hub->hdev);
+
+        usb_unlock_port(port_dev);
         return status;
 }
 
@@ -3209,9 +3269,8 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         int             status;
         u16             portchange, portstatus;
 
-        if (port_dev->did_runtime_put) {
+        if (!test_and_set_bit(port1, hub->child_usage_bits)) {
                 status = pm_runtime_get_sync(&port_dev->dev);
-                port_dev->did_runtime_put = false;
                 if (status < 0) {
                         dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
                                         status);
@@ -3219,15 +3278,13 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
+        usb_lock_port(port_dev);
+
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
         if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
-        /* dev_dbg(hub->intfdev, "resume port %d\n", port1); */
-
-        set_bit(port1, hub->busy_bits);
-
         /* see 7.1.7.7; affects power usage, but not budgeting */
         if (hub_is_superspeed(hub->hdev))
                 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
@@ -3235,8 +3292,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 status = usb_clear_port_feature(hub->hdev,
                                 port1, USB_PORT_FEAT_SUSPEND);
         if (status) {
-                dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
-                                port1, status);
+                dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
         } else {
                 /* drive resume for at least 20 msec */
                 dev_dbg(&udev->dev, "usb %sresume\n",
@@ -3267,8 +3323,6 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
-        clear_bit(port1, hub->busy_bits);
-
         status = check_port_resume_type(udev,
                         hub, port1, status, portchange, portstatus);
         if (status == 0)
@@ -3286,16 +3340,18 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 usb_unlocked_enable_lpm(udev);
         }
 
+        usb_unlock_port(port_dev);
+
         return status;
 }
 
 #ifdef  CONFIG_PM_RUNTIME
 
-/* caller has locked udev */
 int usb_remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
+        usb_lock_device(udev);
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
                 status = usb_autoresume_device(udev);
@@ -3304,9 +3360,59 @@ int usb_remote_wakeup(struct usb_device *udev)
                         usb_autosuspend_device(udev);
                 }
         }
+        usb_unlock_device(udev);
         return status;
 }
 
+/* Returns 1 if there was a remote wakeup and a connect status change. */
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+                __must_hold(&port_dev->status_lock)
+{
+        struct usb_port *port_dev = hub->ports[port - 1];
+        struct usb_device *hdev;
+        struct usb_device *udev;
+        int connect_change = 0;
+        int ret;
+
+        hdev = hub->hdev;
+        udev = port_dev->child;
+        if (!hub_is_superspeed(hdev)) {
+                if (!(portchange & USB_PORT_STAT_C_SUSPEND))
+                        return 0;
+                usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
+        } else {
+                if (!udev || udev->state != USB_STATE_SUSPENDED ||
+                                 (portstatus & USB_PORT_STAT_LINK_STATE) !=
+                                 USB_SS_PORT_LS_U0)
+                        return 0;
+        }
+
+        if (udev) {
+                /* TRSMRCY = 10 msec */
+                msleep(10);
+
+                usb_unlock_port(port_dev);
+                ret = usb_remote_wakeup(udev);
+                usb_lock_port(port_dev);
+                if (ret < 0)
+                        connect_change = 1;
+        } else {
+                ret = -ENODEV;
+                hub_port_disable(hub, port, 1);
+        }
+        dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
+        return connect_change;
+}
+
+#else
+
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+{
+        return 0;
+}
+
 #endif
 
 static int check_ports_changed(struct usb_hub *hub)
@@ -3337,12 +3443,11 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
          */
         hub->wakeup_enabled_descendants = 0;
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
-                struct usb_device       *udev;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
 
-                udev = hub->ports[port1 - 1]->child;
                 if (udev && udev->can_submit) {
-                        dev_warn(&intf->dev, "port %d not suspended yet\n",
-                                        port1);
+                        dev_warn(&port_dev->dev, "not suspended yet\n");
                         if (PMSG_IS_AUTO(msg))
                                 return -EBUSY;
                 }
@@ -3861,6 +3966,12 @@ EXPORT_SYMBOL_GPL(usb_disable_ltm);
 void usb_enable_ltm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_enable_ltm);
 
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+{
+        return 0;
+}
+
 #endif  /* CONFIG_PM */
 
 
@@ -3882,9 +3993,10 @@ EXPORT_SYMBOL_GPL(usb_enable_ltm);
 int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
 {
         int ret;
-        int total_time, stable_time = 0;
         u16 portchange, portstatus;
         unsigned connection = 0xffff;
+        int total_time, stable_time = 0;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
                 ret = hub_port_status(hub, port1, &portstatus, &portchange);
@@ -3913,9 +4025,8 @@ int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
                 msleep(HUB_DEBOUNCE_STEP);
         }
 
-        dev_dbg (hub->intfdev,
-                "debounce: port %d: total %dms stable %dms status 0x%x\n",
-                port1, total_time, stable_time, portstatus);
+        dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
+                        total_time, stable_time, portstatus);
 
         if (stable_time < HUB_DEBOUNCE_STABLE)
                 return -ETIMEDOUT;
@@ -3974,13 +4085,14 @@ static int hub_set_address(struct usb_device *udev, int devnum)
  */
 static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
 {
-        int connect_type;
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
+        int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
 
         if (!udev->usb2_hw_lpm_capable)
                 return;
 
-        connect_type = usb_get_hub_port_connect_type(udev->parent,
-                        udev->portnum);
+        if (hub)
+                connect_type = hub->ports[udev->portnum - 1]->connect_type;
 
         if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
                         connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
@@ -4008,16 +4120,15 @@ static int hub_enable_device(struct usb_device *udev)
  * Returns device in USB_STATE_ADDRESS, except on error.
  *
  * If this is called for an already-existing device (as part of
- * usb_reset_and_verify_device), the caller must own the device lock.  For a
- * newly detected device that is not accessible through any global
- * pointers, it's not necessary to lock the device.
+ * usb_reset_and_verify_device), the caller must own the device lock and
+ * the port lock.  For a newly detected device that is not accessible
+ * through any global pointers, it's not necessary to lock the device,
+ * but it is still necessary to lock the port.
  */
 static int
 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 int retry_counter)
 {
-        static DEFINE_MUTEX(usb_address0_mutex);
-
         struct usb_device       *hdev = hub->hdev;
         struct usb_hcd          *hcd = bus_to_hcd(hdev->bus);
         int                     i, j, retval;
@@ -4040,7 +4151,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         if (oldspeed == USB_SPEED_LOW)
                 delay = HUB_LONG_RESET_TIME;
 
-        mutex_lock(&usb_address0_mutex);
+        mutex_lock(&hdev->bus->usb_address0_mutex);
 
         /* Reset the device; full speed may morph to high speed */
         /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
@@ -4317,7 +4428,7 @@ fail:
                 hub_port_disable(hub, port1, 0);
                 update_devnum(udev, devnum);    /* for disconnect processing */
         }
-        mutex_unlock(&usb_address0_mutex);
+        mutex_unlock(&hdev->bus->usb_address0_mutex);
         return retval;
 }
 
@@ -4358,9 +4469,10 @@ hub_power_remaining (struct usb_hub *hub)
 
         remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device       *udev = hub->ports[port1 - 1]->child;
-                int                     delta;
-                unsigned                unit_load;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
+                unsigned unit_load;
+                int delta;
 
                 if (!udev)
                         continue;
@@ -4380,9 +4492,8 @@ hub_power_remaining (struct usb_hub *hub)
                 else
                         delta = 8;
                 if (delta > hub->mA_per_port)
-                        dev_warn(&udev->dev,
-                                 "%dmA is over %umA budget for port %d!\n",
-                                 delta, hub->mA_per_port, port1);
+                        dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
+                                        delta, hub->mA_per_port);
                 remaining -= delta;
         }
         if (remaining < 0) {
@@ -4393,78 +4504,23 @@ hub_power_remaining (struct usb_hub *hub)
         return remaining;
 }
 
-/* Handle physical or logical connection change events.
- * This routine is called when:
- *      a port connection-change occurs;
- *      a port enable-change occurs (often caused by EMI);
- *      usb_reset_and_verify_device() encounters changed descriptors (as from
- *              a firmware download)
- * caller already locked the hub
- */
-static void hub_port_connect_change(struct usb_hub *hub, int port1,
-                                        u16 portstatus, u16 portchange)
+static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
+                u16 portchange)
 {
-        struct usb_device *hdev = hub->hdev;
-        struct device *hub_dev = hub->intfdev;
-        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
-        unsigned wHubCharacteristics =
-                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
-        struct usb_device *udev;
         int status, i;
         unsigned unit_load;
-
-        dev_dbg (hub_dev,
-                "port %d, status %04x, change %04x, %s\n",
-                port1, portstatus, portchange, portspeed(hub, portstatus));
-
-        if (hub->has_indicators) {
-                set_port_led(hub, port1, HUB_LED_AUTO);
-                hub->indicator[port1-1] = INDICATOR_AUTO;
-        }
-
-#ifdef  CONFIG_USB_OTG
-        /* during HNP, don't repeat the debounce */
-        if (hdev->bus->is_b_host)
-                portchange &= ~(USB_PORT_STAT_C_CONNECTION |
-                                USB_PORT_STAT_C_ENABLE);
-#endif
-
-        /* Try to resuscitate an existing device */
-        udev = hub->ports[port1 - 1]->child;
-        if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
-                        udev->state != USB_STATE_NOTATTACHED) {
-                usb_lock_device(udev);
-                if (portstatus & USB_PORT_STAT_ENABLE) {
-                        status = 0;             /* Nothing to do */
-
-#ifdef CONFIG_PM_RUNTIME
-                } else if (udev->state == USB_STATE_SUSPENDED &&
-                                udev->persist_enabled) {
-                        /* For a suspended device, treat this as a
-                         * remote wakeup event.
-                         */
-                        status = usb_remote_wakeup(udev);
-#endif
-
-                } else {
-                        status = -ENODEV;       /* Don't resuscitate */
-                }
-                usb_unlock_device(udev);
-
-                if (status == 0) {
-                        clear_bit(port1, hub->change_bits);
-                        return;
-                }
-        }
+        struct usb_device *hdev = hub->hdev;
+        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
 
         /* Disconnect any existing devices under this port */
         if (udev) {
                 if (hcd->phy && !hdev->parent &&
                                 !(portstatus & USB_PORT_STAT_CONNECTION))
                         usb_phy_notify_disconnect(hcd->phy, udev->speed);
-                usb_disconnect(&hub->ports[port1 - 1]->child);
+                usb_disconnect(&port_dev->child);
         }
-        clear_bit(port1, hub->change_bits);
 
         /* We can forget about a "removed" device when there's a physical
          * disconnect or the connect status changes.
@@ -4478,8 +4534,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 status = hub_port_debounce_be_stable(hub, port1);
                 if (status < 0) {
                         if (status != -ENODEV && printk_ratelimit())
-                                dev_err(hub_dev, "connect-debounce failed, "
-                                                "port %d disabled\n", port1);
+                                dev_err(&port_dev->dev,
+                                                "connect-debounce failed\n");
                         portstatus &= ~USB_PORT_STAT_CONNECTION;
                 } else {
                         portstatus = status;
@@ -4493,7 +4549,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         test_bit(port1, hub->removed_bits)) {
 
                 /* maybe switch power back on (e.g. root hub was reset) */
-                if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
+                if (hub_is_port_power_switchable(hub)
                                 && !port_is_power_on(hub, portstatus))
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
@@ -4514,9 +4570,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                  */
                 udev = usb_alloc_dev(hdev, hdev->bus, port1);
                 if (!udev) {
-                        dev_err (hub_dev,
-                                "couldn't allocate port %d usb_device\n",
-                                port1);
+                        dev_err(&port_dev->dev,
+                                        "couldn't allocate usb_device\n");
                         goto done;
                 }
 
@@ -4538,7 +4593,9 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 }
 
                 /* reset (non-USB 3.0 devices) and get descriptor */
+                usb_lock_port(port_dev);
                 status = hub_port_init(hub, udev, port1, i);
+                usb_unlock_port(port_dev);
                 if (status < 0)
                         goto loop;
 
@@ -4590,6 +4647,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                  */
                 status = 0;
 
+                mutex_lock(&usb_port_peer_mutex);
+
                 /* We mustn't add new devices if the parent hub has
                  * been disconnected; we would race with the
                  * recursively_mark_NOTATTACHED() routine.
@@ -4598,16 +4657,19 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 if (hdev->state == USB_STATE_NOTATTACHED)
                         status = -ENOTCONN;
                 else
-                        hub->ports[port1 - 1]->child = udev;
+                        port_dev->child = udev;
                 spin_unlock_irq(&device_state_lock);
+                mutex_unlock(&usb_port_peer_mutex);
 
                 /* Run it through the hoops (find a driver, etc) */
                 if (!status) {
                         status = usb_new_device(udev);
                         if (status) {
+                                mutex_lock(&usb_port_peer_mutex);
                                 spin_lock_irq(&device_state_lock);
-                                hub->ports[port1 - 1]->child = NULL;
+                                port_dev->child = NULL;
                                 spin_unlock_irq(&device_state_lock);
+                                mutex_unlock(&usb_port_peer_mutex);
                         }
                 }
 
@@ -4616,7 +4678,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
                 status = hub_power_remaining(hub);
                 if (status)
-                        dev_dbg(hub_dev, "%dmA power budget left\n", status);
+                        dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
 
                 return;
 
@@ -4634,56 +4696,200 @@ loop:
                         !hcd->driver->port_handed_over ||
                         !(hcd->driver->port_handed_over)(hcd, port1)) {
                 if (status != -ENOTCONN && status != -ENODEV)
-                        dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
-                                        port1);
+                        dev_err(&port_dev->dev,
+                                        "unable to enumerate USB device\n");
         }
 
 done:
         hub_port_disable(hub, port1, 1);
         if (hcd->driver->relinquish_port && !hub->hdev->parent)
                 hcd->driver->relinquish_port(hcd, port1);
+
 }
 
-/* Returns 1 if there was a remote wakeup and a connect status change. */
-static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
-                u16 portstatus, u16 portchange)
+/* Handle physical or logical connection change events.
+ * This routine is called when:
+ *      a port connection-change occurs;
+ *      a port enable-change occurs (often caused by EMI);
+ *      usb_reset_and_verify_device() encounters changed descriptors (as from
+ *              a firmware download)
+ * caller already locked the hub
+ */
+static void hub_port_connect_change(struct usb_hub *hub, int port1,
+                                        u16 portstatus, u16 portchange)
+                __must_hold(&port_dev->status_lock)
 {
-        struct usb_device *hdev;
-        struct usb_device *udev;
-        int connect_change = 0;
-        int ret;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
+        int status = -ENODEV;
 
-        hdev = hub->hdev;
-        udev = hub->ports[port - 1]->child;
-        if (!hub_is_superspeed(hdev)) {
-                if (!(portchange & USB_PORT_STAT_C_SUSPEND))
-                        return 0;
-                usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
-        } else {
-                if (!udev || udev->state != USB_STATE_SUSPENDED ||
-                                 (portstatus & USB_PORT_STAT_LINK_STATE) !=
-                                 USB_SS_PORT_LS_U0)
-                        return 0;
+        dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
+                        portchange, portspeed(hub, portstatus));
+
+        if (hub->has_indicators) {
+                set_port_led(hub, port1, HUB_LED_AUTO);
+                hub->indicator[port1-1] = INDICATOR_AUTO;
         }
 
-        if (udev) {
-                /* TRSMRCY = 10 msec */
-                msleep(10);
+#ifdef  CONFIG_USB_OTG
+        /* during HNP, don't repeat the debounce */
+        if (hub->hdev->bus->is_b_host)
+                portchange &= ~(USB_PORT_STAT_C_CONNECTION |
+                                USB_PORT_STAT_C_ENABLE);
+#endif
+
+        /* Try to resuscitate an existing device */
+        if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
+                        udev->state != USB_STATE_NOTATTACHED) {
+                if (portstatus & USB_PORT_STAT_ENABLE) {
+                        status = 0;             /* Nothing to do */
+#ifdef CONFIG_PM_RUNTIME
+                } else if (udev->state == USB_STATE_SUSPENDED &&
+                                udev->persist_enabled) {
+                        /* For a suspended device, treat this as a
+                         * remote wakeup event.
+                         */
+                        usb_unlock_port(port_dev);
+                        status = usb_remote_wakeup(udev);
+                        usb_lock_port(port_dev);
+#endif
+                } else {
+                        /* Don't resuscitate */;
+                }
+        }
+        clear_bit(port1, hub->change_bits);
+
+        /* successfully revalidated the connection */
+        if (status == 0)
+                return;
+
+        usb_unlock_port(port_dev);
+        hub_port_connect(hub, port1, portstatus, portchange);
+        usb_lock_port(port_dev);
+}
+
+static void port_event(struct usb_hub *hub, int port1)
+                __must_hold(&port_dev->status_lock)
+{
+        int connect_change, reset_device = 0;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
+        struct usb_device *hdev = hub->hdev;
+        u16 portstatus, portchange;
+
+        connect_change = test_bit(port1, hub->change_bits);
+        clear_bit(port1, hub->event_bits);
+        clear_bit(port1, hub->wakeup_bits);
+
+        if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
+                return;
+
+        if (portchange & USB_PORT_STAT_C_CONNECTION) {
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
+                connect_change = 1;
+        }
+
+        if (portchange & USB_PORT_STAT_C_ENABLE) {
+                if (!connect_change)
+                        dev_dbg(&port_dev->dev, "enable change, status %08x\n",
+                                        portstatus);
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
+
+                /*
+                 * EM interference sometimes causes badly shielded USB devices
+                 * to be shutdown by the hub, this hack enables them again.
+                 * Works at least with mouse driver.
+                 */
+                if (!(portstatus & USB_PORT_STAT_ENABLE)
+                    && !connect_change && udev) {
+                        dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
+                        connect_change = 1;
+                }
+        }
+
+        if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
+                u16 status = 0, unused;
+
+                dev_dbg(&port_dev->dev, "over-current change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_OVER_CURRENT);
+                msleep(100);    /* Cool down */
+                hub_power_on(hub, true);
+                hub_port_status(hub, port1, &status, &unused);
+                if (status & USB_PORT_STAT_OVERCURRENT)
+                        dev_err(&port_dev->dev, "over-current condition\n");
+        }
+
+        if (portchange & USB_PORT_STAT_C_RESET) {
+                dev_dbg(&port_dev->dev, "reset change\n");
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
+        }
+        if ((portchange & USB_PORT_STAT_C_BH_RESET)
+            && hub_is_superspeed(hdev)) {
+                dev_dbg(&port_dev->dev, "warm reset change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_BH_PORT_RESET);
+        }
+        if (portchange & USB_PORT_STAT_C_LINK_STATE) {
+                dev_dbg(&port_dev->dev, "link state change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_PORT_LINK_STATE);
+        }
+        if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
+                dev_warn(&port_dev->dev, "config error\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
+        }
+
+        /* skip port actions that require the port to be powered on */
+        if (!pm_runtime_active(&port_dev->dev))
+                return;
 
+        if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
+                connect_change = 1;
+
+        /*
+         * Warm reset a USB3 protocol port if it's in
+         * SS.Inactive state.
+         */
+        if (hub_port_warm_reset_required(hub, portstatus)) {
+                dev_dbg(&port_dev->dev, "do warm reset\n");
+                if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
+                                || udev->state == USB_STATE_NOTATTACHED) {
+                        if (hub_port_reset(hub, port1, NULL,
+                                        HUB_BH_RESET_TIME, true) < 0)
+                                hub_port_disable(hub, port1, 1);
+                } else
+                        reset_device = 1;
+        }
+
+        /*
+         * On disconnect USB3 protocol ports transit from U0 to
+         * SS.Inactive to Rx.Detect. If this happens a warm-
+         * reset is not needed, but a (re)connect may happen
+         * before khubd runs and sees the disconnect, and the
+         * device may be an unknown state.
+         *
+         * If the port went through SS.Inactive without khubd
+         * seeing it the C_LINK_STATE change flag will be set,
+         * and we reset the dev to put it in a known state.
+         */
+        if (reset_device || (udev && hub_is_superspeed(hub->hdev)
+                                && (portchange & USB_PORT_STAT_C_LINK_STATE)
+                                && (portstatus & USB_PORT_STAT_CONNECTION))) {
+                usb_unlock_port(port_dev);
                 usb_lock_device(udev);
-                ret = usb_remote_wakeup(udev);
+                usb_reset_device(udev);
                 usb_unlock_device(udev);
-                if (ret < 0)
-                        connect_change = 1;
-        } else {
-                ret = -ENODEV;
-                hub_port_disable(hub, port, 1);
+                usb_lock_port(port_dev);
+                connect_change = 0;
         }
-        dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
-                        port, ret);
-        return connect_change;
+
+        if (connect_change)
+                hub_port_connect_change(hub, port1, portstatus, portchange);
 }
 
+
 static void hub_events(void)
 {
         struct list_head *tmp;
@@ -4693,10 +4899,7 @@ static void hub_events(void)
         struct device *hub_dev;
         u16 hubstatus;
         u16 hubchange;
-        u16 portstatus;
-        u16 portchange;
         int i, ret;
-        int connect_change, wakeup_change;
 
         /*
          *  We restart the list every time to avoid a deadlock with
@@ -4770,146 +4973,28 @@ static void hub_events(void)
 
                 /* deal with port status changes */
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        struct usb_device *udev = hub->ports[i - 1]->child;
-
-                        if (test_bit(i, hub->busy_bits))
-                                continue;
-                        connect_change = test_bit(i, hub->change_bits);
-                        wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
-                        if (!test_and_clear_bit(i, hub->event_bits) &&
-                                        !connect_change && !wakeup_change)
-                                continue;
-
-                        ret = hub_port_status(hub, i,
-                                        &portstatus, &portchange);
-                        if (ret < 0)
-                                continue;
-
-                        if (portchange & USB_PORT_STAT_C_CONNECTION) {
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_CONNECTION);
-                                connect_change = 1;
-                        }
-
-                        if (portchange & USB_PORT_STAT_C_ENABLE) {
-                                if (!connect_change)
-                                        dev_dbg (hub_dev,
-                                                "port %d enable change, "
-                                                "status %08x\n",
-                                                i, portstatus);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_ENABLE);
+                        struct usb_port *port_dev = hub->ports[i - 1];
 
+                        if (test_bit(i, hub->event_bits)
+                                        || test_bit(i, hub->change_bits)
+                                        || test_bit(i, hub->wakeup_bits)) {
                                 /*
-                                 * EM interference sometimes causes badly
-                                 * shielded USB devices to be shutdown by
-                                 * the hub, this hack enables them again.
-                                 * Works at least with mouse driver.
+                                 * The get_noresume and barrier ensure that if
+                                 * the port was in the process of resuming, we
+                                 * flush that work and keep the port active for
+                                 * the duration of the port_event().  However,
+                                 * if the port is runtime pm suspended
+                                 * (powered-off), we leave it in that state, run
+                                 * an abbreviated port_event(), and move on.
                                  */
-                                if (!(portstatus & USB_PORT_STAT_ENABLE)
-                                    && !connect_change
-                                    && hub->ports[i - 1]->child) {
-                                        dev_err (hub_dev,
-                                            "port %i "
-                                            "disabled by hub (EMI?), "
-                                            "re-enabling...\n",
-                                                i);
-                                        connect_change = 1;
-                                }
-                        }
-
-                        if (hub_handle_remote_wakeup(hub, i,
-                                                portstatus, portchange))
-                                connect_change = 1;
-
-                        if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
-                                u16 status = 0;
-                                u16 unused;
-
-                                dev_dbg(hub_dev, "over-current change on port "
-                                        "%d\n", i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_OVER_CURRENT);
-                                msleep(100);    /* Cool down */
-                                hub_power_on(hub, true);
-                                hub_port_status(hub, i, &status, &unused);
-                                if (status & USB_PORT_STAT_OVERCURRENT)
-                                        dev_err(hub_dev, "over-current "
-                                                "condition on port %d\n", i);
-                        }
-
-                        if (portchange & USB_PORT_STAT_C_RESET) {
-                                dev_dbg (hub_dev,
-                                        "reset change on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_RESET);
-                        }
-                        if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
-                                        hub_is_superspeed(hub->hdev)) {
-                                dev_dbg(hub_dev,
-                                        "warm reset change on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_BH_PORT_RESET);
-                        }
-                        if (portchange & USB_PORT_STAT_C_LINK_STATE) {
-                                usb_clear_port_feature(hub->hdev, i,
-                                                USB_PORT_FEAT_C_PORT_LINK_STATE);
-                        }
-                        if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
-                                dev_warn(hub_dev,
-                                        "config error on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hub->hdev, i,
-                                                USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
+                                pm_runtime_get_noresume(&port_dev->dev);
+                                pm_runtime_barrier(&port_dev->dev);
+                                usb_lock_port(port_dev);
+                                port_event(hub, i);
+                                usb_unlock_port(port_dev);
+                                pm_runtime_put_sync(&port_dev->dev);
                         }
-
-                        /* Warm reset a USB3 protocol port if it's in
-                         * SS.Inactive state.
-                         */
-                        if (hub_port_warm_reset_required(hub, portstatus)) {
-                                int status;
-
-                                dev_dbg(hub_dev, "warm reset port %d\n", i);
-                                if (!udev ||
-                                    !(portstatus & USB_PORT_STAT_CONNECTION) ||
-                                    udev->state == USB_STATE_NOTATTACHED) {
-                                        status = hub_port_reset(hub, i,
-                                                        NULL, HUB_BH_RESET_TIME,
-                                                        true);
-                                        if (status < 0)
-                                                hub_port_disable(hub, i, 1);
-                                } else {
-                                        usb_lock_device(udev);
-                                        status = usb_reset_device(udev);
-                                        usb_unlock_device(udev);
-                                        connect_change = 0;
-                                }
-                        /*
-                         * On disconnect USB3 protocol ports transit from U0 to
-                         * SS.Inactive to Rx.Detect. If this happens a warm-
-                         * reset is not needed, but a (re)connect may happen
-                         * before khubd runs and sees the disconnect, and the
-                         * device may be an unknown state.
-                         *
-                         * If the port went through SS.Inactive without khubd
-                         * seeing it the C_LINK_STATE change flag will be set,
-                         * and we reset the dev to put it in a known state.
-                         */
-                        } else if (udev && hub_is_superspeed(hub->hdev) &&
-                                   (portchange & USB_PORT_STAT_C_LINK_STATE) &&
-                                   (portstatus & USB_PORT_STAT_CONNECTION)) {
-                                usb_lock_device(udev);
-                                usb_reset_device(udev);
-                                usb_unlock_device(udev);
-                                connect_change = 0;
-                        }
-
-                        if (connect_change)
-                                hub_port_connect_change(hub, i,
-                                                portstatus, portchange);
-                } /* end for i */
+                }
 
                 /* deal with hub status changes */
                 if (test_and_clear_bit(0, hub->event_bits) == 0)
@@ -5144,15 +5229,18 @@ static int descriptors_changed(struct usb_device *udev,
  * if the reset wasn't even attempted.
  *
  * Note:
- * The caller must own the device lock.  For example, it's safe to use
- * this from a driver probe() routine after downloading new firmware.
- * For calls that might not occur during probe(), drivers should lock
- * the device using usb_lock_device_for_reset().
+ * The caller must own the device lock and the port lock, the latter is
+ * taken by usb_reset_device().  For example, it's safe to use
+ * usb_reset_device() from a driver probe() routine after downloading
+ * new firmware.  For calls that might not occur during probe(), drivers
+ * should lock the device using usb_lock_device_for_reset().
  *
  * Locking exception: This routine may also be called from within an
  * autoresume handler.  Such usage won't conflict with other tasks
  * holding the device lock because these tasks should always call
- * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
+ * usb_autopm_resume_device(), thereby preventing any unwanted
+ * autoresume.  The autoresume handler is expected to have already
+ * acquired the port lock before calling this routine.
  */
 static int usb_reset_and_verify_device(struct usb_device *udev)
 {
@@ -5171,11 +5259,9 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 return -EINVAL;
         }
 
-        if (!parent_hdev) {
-                /* this requires hcd-specific logic; see ohci_restart() */
-                dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
+        if (!parent_hdev)
                 return -EISDIR;
-        }
+
         parent_hub = usb_hub_to_struct_hub(parent_hdev);
 
         /* Disable USB2 hardware LPM.
@@ -5204,7 +5290,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 goto re_enumerate;
         }
 
-        set_bit(port1, parent_hub->busy_bits);
         for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 
                 /* ep0 maxpacket size may change; let the HCD know about it.
@@ -5214,7 +5299,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
                         break;
         }
-        clear_bit(port1, parent_hub->busy_bits);
 
         if (ret < 0)
                 goto re_enumerate;
@@ -5335,7 +5419,9 @@ int usb_reset_device(struct usb_device *udev)
         int ret;
         int i;
         unsigned int noio_flag;
+        struct usb_port *port_dev;
         struct usb_host_config *config = udev->actconfig;
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
 
         if (udev->state == USB_STATE_NOTATTACHED ||
                         udev->state == USB_STATE_SUSPENDED) {
@@ -5344,6 +5430,14 @@ int usb_reset_device(struct usb_device *udev)
                 return -EINVAL;
         }
 
+        if (!udev->parent) {
+                /* this requires hcd-specific logic; see ohci_restart() */
+                dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
+                return -EISDIR;
+        }
+
+        port_dev = hub->ports[udev->portnum - 1];
+
         /*
          * Don't allocate memory with GFP_KERNEL in current
          * context to avoid possible deadlock if usb mass
@@ -5377,7 +5471,9 @@ int usb_reset_device(struct usb_device *udev)
                 }
         }
 
+        usb_lock_port(port_dev);
         ret = usb_reset_and_verify_device(udev);
+        usb_unlock_port(port_dev);
 
         if (config) {
                 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
@@ -5472,56 +5568,26 @@ struct usb_device *usb_hub_find_child(struct usb_device *hdev,
 }
 EXPORT_SYMBOL_GPL(usb_hub_find_child);
 
-/**
- * usb_set_hub_port_connect_type - set hub port connect type.
- * @hdev: USB device belonging to the usb hub
- * @port1: port num of the port
- * @type: connect type of the port
- */
-void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
-        enum usb_port_connect_type type)
-{
-        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
-
-        if (hub)
-                hub->ports[port1 - 1]->connect_type = type;
-}
-
-/**
- * usb_get_hub_port_connect_type - Get the port's connect type
- * @hdev: USB device belonging to the usb hub
- * @port1: port num of the port
- *
- * Return: The connect type of the port if successful. Or
- * USB_PORT_CONNECT_TYPE_UNKNOWN if input params are invalid.
- */
-enum usb_port_connect_type
-usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
-{
-        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
-
-        if (!hub)
-                return USB_PORT_CONNECT_TYPE_UNKNOWN;
-
-        return hub->ports[port1 - 1]->connect_type;
-}
-
 void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 struct usb_hub_descriptor *desc)
 {
+        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
         enum usb_port_connect_type connect_type;
         int i;
 
+        if (!hub)
+                return;
+
         if (!hub_is_superspeed(hdev)) {
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        connect_type = usb_get_hub_port_connect_type(hdev, i);
+                        struct usb_port *port_dev = hub->ports[i - 1];
 
+                        connect_type = port_dev->connect_type;
                         if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
                                 u8 mask = 1 << (i%8);
 
                                 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
-                                        dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
-                                                i);
+                                        dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
                                         desc->u.hs.DeviceRemovable[i/8] |= mask;
                                 }
                         }
@@ -5530,14 +5596,14 @@ void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
 
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        connect_type = usb_get_hub_port_connect_type(hdev, i);
+                        struct usb_port *port_dev = hub->ports[i - 1];
 
+                        connect_type = port_dev->connect_type;
                         if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
                                 u16 mask = 1 << i;
 
                                 if (!(port_removable & mask)) {
-                                        dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
-                                                i);
+                                        dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
                                         port_removable |= mask;
                                 }
                         }
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index 33bcb2c6f90a..0a7cdc0ef0a9 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -45,12 +45,13 @@ struct usb_hub {
         unsigned long           event_bits[1];  /* status change bitmask */
         unsigned long           change_bits[1]; /* ports with logical connect
                                                         status change */
-        unsigned long           busy_bits[1];   /* ports being reset or
-                                                        resumed */
         unsigned long           removed_bits[1]; /* ports with a "removed"
                                                         device present */
         unsigned long           wakeup_bits[1]; /* ports that have signaled
                                                         remote wakeup */
+        unsigned long           power_bits[1]; /* ports that are powered */
+        unsigned long           child_usage_bits[1]; /* ports powered on for
+                                                        children */
 #if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
 #error event_bits[] is too short!
 #endif
@@ -66,6 +67,7 @@ struct usb_hub {
         unsigned                limited_power:1;
         unsigned                quiescing:1;
         unsigned                disconnected:1;
+        unsigned                in_reset:1;
 
         unsigned                quirk_check_port_auto_suspend:1;
 
@@ -81,19 +83,23 @@ struct usb_hub {
  * @child: usb device attached to the port
  * @dev: generic device interface
  * @port_owner: port's owner
+ * @peer: related usb2 and usb3 ports (share the same connector)
  * @connect_type: port's connect type
+ * @location: opaque representation of platform connector location
+ * @status_lock: synchronize port_event() vs usb_port_{suspend|resume}
  * @portnum: port index num based one
- * @power_is_on: port's power state
- * @did_runtime_put: port has done pm_runtime_put().
+ * @is_superspeed cache super-speed status
  */
 struct usb_port {
         struct usb_device *child;
         struct device dev;
         struct usb_dev_state *port_owner;
+        struct usb_port *peer;
         enum usb_port_connect_type connect_type;
+        usb_port_location_t location;
+        struct mutex status_lock;
         u8 portnum;
-        unsigned power_is_on:1;
-        unsigned did_runtime_put:1;
+        unsigned int is_superspeed:1;
 };
 
 #define to_usb_port(_dev) \
@@ -111,6 +117,29 @@ extern int hub_port_debounce(struct usb_hub *hub, int port1,
 extern int usb_clear_port_feature(struct usb_device *hdev,
                 int port1, int feature);
 
+static inline bool hub_is_port_power_switchable(struct usb_hub *hub)
+{
+        __le16 hcs;
+
+        if (!hub)
+                return false;
+        hcs = hub->descriptor->wHubCharacteristics;
+        return (le16_to_cpu(hcs) & HUB_CHAR_LPSM) < HUB_CHAR_NO_LPSM;
+}
+
+static inline int hub_is_superspeed(struct usb_device *hdev)
+{
+        return hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS;
+}
+
+static inline unsigned hub_power_on_good_delay(struct usb_hub *hub)
+{
+        unsigned delay = hub->descriptor->bPwrOn2PwrGood * 2;
+
+        /* Wait at least 100 msec for power to become stable */
+        return max(delay, 100U);
+}
+
 static inline int hub_port_debounce_be_connected(struct usb_hub *hub,
                 int port1)
 {
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index 51542f852393..62036faf56c0 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -76,17 +76,29 @@ static int usb_port_runtime_resume(struct device *dev)
         struct usb_device *hdev = to_usb_device(dev->parent->parent);
         struct usb_interface *intf = to_usb_interface(dev->parent);
         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_device *udev = port_dev->child;
+        struct usb_port *peer = port_dev->peer;
         int port1 = port_dev->portnum;
         int retval;
 
         if (!hub)
                 return -EINVAL;
+        if (hub->in_reset) {
+                set_bit(port1, hub->power_bits);
+                return 0;
+        }
 
-        usb_autopm_get_interface(intf);
-        set_bit(port1, hub->busy_bits);
+        /*
+         * Power on our usb3 peer before this usb2 port to prevent a usb3
+         * device from degrading to its usb2 connection
+         */
+        if (!port_dev->is_superspeed && peer)
+                pm_runtime_get_sync(&peer->dev);
 
+        usb_autopm_get_interface(intf);
         retval = usb_hub_set_port_power(hdev, hub, port1, true);
-        if (port_dev->child && !retval) {
+        msleep(hub_power_on_good_delay(hub));
+        if (udev && !retval) {
                 /*
                  * Attempt to wait for usb hub port to be reconnected in order
                  * to make the resume procedure successful.  The device may have
@@ -97,12 +109,17 @@ static int usb_port_runtime_resume(struct device *dev)
                 if (retval < 0)
                         dev_dbg(&port_dev->dev, "can't get reconnection after setting port  power on, status %d\n",
                                         retval);
-                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
                 retval = 0;
+
+                /* Force the child awake to revalidate after the power loss. */
+                if (!test_and_set_bit(port1, hub->child_usage_bits)) {
+                        pm_runtime_get_noresume(&port_dev->dev);
+                        pm_request_resume(&udev->dev);
+                }
         }
 
-        clear_bit(port1, hub->busy_bits);
         usb_autopm_put_interface(intf);
+
         return retval;
 }
 
@@ -112,23 +129,34 @@ static int usb_port_runtime_suspend(struct device *dev)
         struct usb_device *hdev = to_usb_device(dev->parent->parent);
         struct usb_interface *intf = to_usb_interface(dev->parent);
         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_port *peer = port_dev->peer;
         int port1 = port_dev->portnum;
         int retval;
 
         if (!hub)
                 return -EINVAL;
+        if (hub->in_reset)
+                return -EBUSY;
 
         if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)
                         == PM_QOS_FLAGS_ALL)
                 return -EAGAIN;
 
         usb_autopm_get_interface(intf);
-        set_bit(port1, hub->busy_bits);
         retval = usb_hub_set_port_power(hdev, hub, port1, false);
         usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
-        usb_clear_port_feature(hdev, port1,     USB_PORT_FEAT_C_ENABLE);
-        clear_bit(port1, hub->busy_bits);
+        if (!port_dev->is_superspeed)
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
         usb_autopm_put_interface(intf);
+
+        /*
+         * Our peer usb3 port may now be able to suspend, so
+         * asynchronously queue a suspend request to observe that this
+         * usb2 port is now off.
+         */
+        if (!port_dev->is_superspeed && peer)
+                pm_runtime_put(&peer->dev);
+
         return retval;
 }
 #endif
@@ -146,9 +174,215 @@ struct device_type usb_port_device_type = {
         .pm =           &usb_port_pm_ops,
 };
 
+static struct device_driver usb_port_driver = {
+        .name = "usb",
+        .owner = THIS_MODULE,
+};
+
+static int link_peers(struct usb_port *left, struct usb_port *right)
+{
+        struct usb_port *ss_port, *hs_port;
+        int rc;
+
+        if (left->peer == right && right->peer == left)
+                return 0;
+
+        if (left->peer || right->peer) {
+                struct usb_port *lpeer = left->peer;
+                struct usb_port *rpeer = right->peer;
+
+                WARN(1, "failed to peer %s and %s (%s -> %p) (%s -> %p)\n",
+                        dev_name(&left->dev), dev_name(&right->dev),
+                        dev_name(&left->dev), lpeer,
+                        dev_name(&right->dev), rpeer);
+                return -EBUSY;
+        }
+
+        rc = sysfs_create_link(&left->dev.kobj, &right->dev.kobj, "peer");
+        if (rc)
+                return rc;
+        rc = sysfs_create_link(&right->dev.kobj, &left->dev.kobj, "peer");
+        if (rc) {
+                sysfs_remove_link(&left->dev.kobj, "peer");
+                return rc;
+        }
+
+        /*
+         * We need to wake the HiSpeed port to make sure we don't race
+         * setting ->peer with usb_port_runtime_suspend().  Otherwise we
+         * may miss a suspend event for the SuperSpeed port.
+         */
+        if (left->is_superspeed) {
+                ss_port = left;
+                WARN_ON(right->is_superspeed);
+                hs_port = right;
+        } else {
+                ss_port = right;
+                WARN_ON(!right->is_superspeed);
+                hs_port = left;
+        }
+        pm_runtime_get_sync(&hs_port->dev);
+
+        left->peer = right;
+        right->peer = left;
+
+        /*
+         * The SuperSpeed reference is dropped when the HiSpeed port in
+         * this relationship suspends, i.e. when it is safe to allow a
+         * SuperSpeed connection to drop since there is no risk of a
+         * device degrading to its powered-off HiSpeed connection.
+         *
+         * Also, drop the HiSpeed ref taken above.
+         */
+        pm_runtime_get_sync(&ss_port->dev);
+        pm_runtime_put(&hs_port->dev);
+
+        return 0;
+}
+
+static void link_peers_report(struct usb_port *left, struct usb_port *right)
+{
+        int rc;
+
+        rc = link_peers(left, right);
+        if (rc == 0) {
+                dev_dbg(&left->dev, "peered to %s\n", dev_name(&right->dev));
+        } else {
+                dev_warn(&left->dev, "failed to peer to %s (%d)\n",
+                                dev_name(&right->dev), rc);
+                pr_warn_once("usb: port power management may be unreliable\n");
+        }
+}
+
+static void unlink_peers(struct usb_port *left, struct usb_port *right)
+{
+        struct usb_port *ss_port, *hs_port;
+
+        WARN(right->peer != left || left->peer != right,
+                        "%s and %s are not peers?\n",
+                        dev_name(&left->dev), dev_name(&right->dev));
+
+        /*
+         * We wake the HiSpeed port to make sure we don't race its
+         * usb_port_runtime_resume() event which takes a SuperSpeed ref
+         * when ->peer is !NULL.
+         */
+        if (left->is_superspeed) {
+                ss_port = left;
+                hs_port = right;
+        } else {
+                ss_port = right;
+                hs_port = left;
+        }
+
+        pm_runtime_get_sync(&hs_port->dev);
+
+        sysfs_remove_link(&left->dev.kobj, "peer");
+        right->peer = NULL;
+        sysfs_remove_link(&right->dev.kobj, "peer");
+        left->peer = NULL;
+
+        /* Drop the SuperSpeed ref held on behalf of the active HiSpeed port */
+        pm_runtime_put(&ss_port->dev);
+
+        /* Drop the ref taken above */
+        pm_runtime_put(&hs_port->dev);
+}
+
+/*
+ * For each usb hub device in the system check to see if it is in the
+ * peer domain of the given port_dev, and if it is check to see if it
+ * has a port that matches the given port by location
+ */
+static int match_location(struct usb_device *peer_hdev, void *p)
+{
+        int port1;
+        struct usb_hcd *hcd, *peer_hcd;
+        struct usb_port *port_dev = p, *peer;
+        struct usb_hub *peer_hub = usb_hub_to_struct_hub(peer_hdev);
+        struct usb_device *hdev = to_usb_device(port_dev->dev.parent->parent);
+
+        if (!peer_hub)
+                return 0;
+
+        hcd = bus_to_hcd(hdev->bus);
+        peer_hcd = bus_to_hcd(peer_hdev->bus);
+        /* peer_hcd is provisional until we verify it against the known peer */
+        if (peer_hcd != hcd->shared_hcd)
+                return 0;
+
+        for (port1 = 1; port1 <= peer_hdev->maxchild; port1++) {
+                peer = peer_hub->ports[port1 - 1];
+                if (peer && peer->location == port_dev->location) {
+                        link_peers_report(port_dev, peer);
+                        return 1; /* done */
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * Find the peer port either via explicit platform firmware "location"
+ * data, the peer hcd for root hubs, or the upstream peer relationship
+ * for all other hubs.
+ */
+static void find_and_link_peer(struct usb_hub *hub, int port1)
+{
+        struct usb_port *port_dev = hub->ports[port1 - 1], *peer;
+        struct usb_device *hdev = hub->hdev;
+        struct usb_device *peer_hdev;
+        struct usb_hub *peer_hub;
+
+        /*
+         * If location data is available then we can only peer this port
+         * by a location match, not the default peer (lest we create a
+         * situation where we need to go back and undo a default peering
+         * when the port is later peered by location data)
+         */
+        if (port_dev->location) {
+                /* we link the peer in match_location() if found */
+                usb_for_each_dev(port_dev, match_location);
+                return;
+        } else if (!hdev->parent) {
+                struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
+                struct usb_hcd *peer_hcd = hcd->shared_hcd;
+
+                if (!peer_hcd)
+                        return;
+
+                peer_hdev = peer_hcd->self.root_hub;
+        } else {
+                struct usb_port *upstream;
+                struct usb_device *parent = hdev->parent;
+                struct usb_hub *parent_hub = usb_hub_to_struct_hub(parent);
+
+                if (!parent_hub)
+                        return;
+
+                upstream = parent_hub->ports[hdev->portnum - 1];
+                if (!upstream || !upstream->peer)
+                        return;
+
+                peer_hdev = upstream->peer->child;
+        }
+
+        peer_hub = usb_hub_to_struct_hub(peer_hdev);
+        if (!peer_hub || port1 > peer_hdev->maxchild)
+                return;
+
+        /*
+         * we found a valid default peer, last check is to make sure it
+         * does not have location data
+         */
+        peer = peer_hub->ports[port1 - 1];
+        if (peer && peer->location == 0)
+                link_peers_report(port_dev, peer);
+}
+
 int usb_hub_create_port_device(struct usb_hub *hub, int port1)
 {
-        struct usb_port *port_dev = NULL;
+        struct usb_port *port_dev;
         int retval;
 
         port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
@@ -159,24 +393,33 @@ int usb_hub_create_port_device(struct usb_hub *hub, int port1)
 
         hub->ports[port1 - 1] = port_dev;
         port_dev->portnum = port1;
-        port_dev->power_is_on = true;
+        set_bit(port1, hub->power_bits);
         port_dev->dev.parent = hub->intfdev;
         port_dev->dev.groups = port_dev_group;
         port_dev->dev.type = &usb_port_device_type;
-        dev_set_name(&port_dev->dev, "port%d", port1);
-
+        port_dev->dev.driver = &usb_port_driver;
+        if (hub_is_superspeed(hub->hdev))
+                port_dev->is_superspeed = 1;
+        dev_set_name(&port_dev->dev, "%s-port%d", dev_name(&hub->hdev->dev),
+                        port1);
+        mutex_init(&port_dev->status_lock);
         retval = device_register(&port_dev->dev);
         if (retval)
                 goto error_register;
 
+        find_and_link_peer(hub, port1);
+
         pm_runtime_set_active(&port_dev->dev);
 
-        /* It would be dangerous if user space couldn't
-         * prevent usb device from being powered off. So don't
-         * enable port runtime pm if failed to expose port's pm qos.
+        /*
+         * Do not enable port runtime pm if the hub does not support
+         * power switching.  Also, userspace must have final say of
+         * whether a port is permitted to power-off.  Do not enable
+         * runtime pm if we fail to expose pm_qos_no_power_off.
          */
-        if (!dev_pm_qos_expose_flags(&port_dev->dev,
-                        PM_QOS_FLAG_NO_POWER_OFF))
+        if (hub_is_port_power_switchable(hub)
+                        && dev_pm_qos_expose_flags(&port_dev->dev,
+                        PM_QOS_FLAG_NO_POWER_OFF) == 0)
                 pm_runtime_enable(&port_dev->dev);
 
         device_enable_async_suspend(&port_dev->dev);
@@ -188,9 +431,13 @@ exit:
         return retval;
 }
 
-void usb_hub_remove_port_device(struct usb_hub *hub,
-                                       int port1)
+void usb_hub_remove_port_device(struct usb_hub *hub, int port1)
 {
-        device_unregister(&hub->ports[port1 - 1]->dev);
-}
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_port *peer;
 
+        peer = port_dev->peer;
+        if (peer)
+                unlink_peers(port_dev, peer);
+        device_unregister(&port_dev->dev);
+}
diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
index 5ca4070b1f38..2776cfe64c09 100644
--- a/drivers/usb/core/usb-acpi.c
+++ b/drivers/usb/core/usb-acpi.c
@@ -17,7 +17,7 @@
 #include <linux/pci.h>
 #include <linux/usb/hcd.h>
 
-#include "usb.h"
+#include "hub.h"
 
 /**
  * usb_acpi_power_manageable - check whether usb port has
@@ -55,13 +55,18 @@ EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
  */
 int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 {
+        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_port *port_dev;
         acpi_handle port_handle;
         unsigned char state;
         int port1 = index + 1;
         int error = -EINVAL;
 
-        port_handle = (acpi_handle)usb_get_hub_port_acpi_handle(hdev,
-                port1);
+        if (!hub)
+                return -ENODEV;
+        port_dev = hub->ports[port1 - 1];
+
+        port_handle = (acpi_handle) usb_get_hub_port_acpi_handle(hdev, port1);
         if (!port_handle)
                 return error;
 
@@ -72,23 +77,21 @@ int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 
         error = acpi_bus_set_power(port_handle, state);
         if (!error)
-                dev_dbg(&hdev->dev, "The power of hub port %d was set to %d\n",
-                        port1, enable);
+                dev_dbg(&port_dev->dev, "acpi: power was set to %d\n", enable);
         else
-                dev_dbg(&hdev->dev, "The power of hub port failed to be set\n");
+                dev_dbg(&port_dev->dev, "acpi: power failed to be set\n");
 
         return error;
 }
 EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
 
-static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
-        acpi_handle handle, int port1)
+static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
+                struct acpi_pld_info *pld)
 {
-        acpi_status status;
+        enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *upc;
-        struct acpi_pld_info *pld;
-        int ret = 0;
+        acpi_status status;
 
         /*
          * According to ACPI Spec 9.13. PLD indicates whether usb port is
@@ -98,39 +101,37 @@ static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
          * a usb device is directly hard-wired to the port. If no visible and
          * no connectable, the port would be not used.
          */
-        status = acpi_get_physical_device_location(handle, &pld);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
         status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
         upc = buffer.pointer;
         if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
                 || upc->package.count != 4) {
-                ret = -EINVAL;
                 goto out;
         }
 
         if (upc->package.elements[0].integer.value)
                 if (pld->user_visible)
-                        usb_set_hub_port_connect_type(hdev, port1,
-                                USB_PORT_CONNECT_TYPE_HOT_PLUG);
+                        connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG;
                 else
-                        usb_set_hub_port_connect_type(hdev, port1,
-                                USB_PORT_CONNECT_TYPE_HARD_WIRED);
+                        connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
         else if (!pld->user_visible)
-                usb_set_hub_port_connect_type(hdev, port1, USB_PORT_NOT_USED);
-
+                connect_type = USB_PORT_NOT_USED;
 out:
-        ACPI_FREE(pld);
         kfree(upc);
-        return ret;
+        return connect_type;
 }
 
+
+/*
+ * Private to usb-acpi, all the core needs to know is that
+ * port_dev->location is non-zero when it has been set by the firmware.
+ */
+#define USB_ACPI_LOCATION_VALID (1 << 31)
+
 static struct acpi_device *usb_acpi_find_companion(struct device *dev)
 {
         struct usb_device *udev;
+        struct acpi_device *adev;
         acpi_handle *parent_handle;
-        int port_num;
 
         /*
          * In the ACPI DSDT table, only usb root hub and usb ports are
@@ -147,37 +148,19 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
          */
         if (is_usb_device(dev)) {
                 udev = to_usb_device(dev);
-                if (udev->parent) {
-                        enum usb_port_connect_type type;
-
-                        /*
-                         * According usb port's connect type to set usb device's
-                         * removability.
-                         */
-                        type = usb_get_hub_port_connect_type(udev->parent,
-                                udev->portnum);
-                        switch (type) {
-                        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
-                                udev->removable = USB_DEVICE_REMOVABLE;
-                                break;
-                        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
-                                udev->removable = USB_DEVICE_FIXED;
-                                break;
-                        default:
-                                udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
-                                break;
-                        }
-
+                if (udev->parent)
                         return NULL;
-                }
 
-                /* root hub's parent is the usb hcd. */
-                return acpi_find_child_device(ACPI_COMPANION(dev->parent),
-                                              udev->portnum, false);
+                /* root hub is only child (_ADR=0) under its parent, the HC */
+                adev = ACPI_COMPANION(dev->parent);
+                return acpi_find_child_device(adev, 0, false);
         } else if (is_usb_port(dev)) {
-                struct acpi_device *adev = NULL;
+                struct usb_port *port_dev = to_usb_port(dev);
+                int port1 = port_dev->portnum;
+                struct acpi_pld_info *pld;
+                acpi_handle *handle;
+                acpi_status status;
 
-                sscanf(dev_name(dev), "port%d", &port_num);
                 /* Get the struct usb_device point of port's hub */
                 udev = to_usb_device(dev->parent->parent);
 
@@ -188,12 +171,11 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
                  */
                 if (!udev->parent) {
                         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
-                        int raw_port_num;
+                        int raw;
 
-                        raw_port_num = usb_hcd_find_raw_port_number(hcd,
-                                port_num);
+                        raw = usb_hcd_find_raw_port_number(hcd, port1);
                         adev = acpi_find_child_device(ACPI_COMPANION(&udev->dev),
-                                                      raw_port_num, false);
+                                        raw, false);
                         if (!adev)
                                 return NULL;
                 } else {
@@ -204,11 +186,20 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
                                 return NULL;
 
                         acpi_bus_get_device(parent_handle, &adev);
-                        adev = acpi_find_child_device(adev, port_num, false);
+                        adev = acpi_find_child_device(adev, port1, false);
                         if (!adev)
                                 return NULL;
                 }
-                usb_acpi_check_port_connect_type(udev, adev->handle, port_num);
+                handle = adev->handle;
+                status = acpi_get_physical_device_location(handle, &pld);
+                if (ACPI_FAILURE(status) || !pld)
+                        return adev;
+
+                port_dev->location = USB_ACPI_LOCATION_VALID
+                        | pld->group_token << 8 | pld->group_position;
+                port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
+                ACPI_FREE(pld);
+
                 return adev;
         }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 75bf649da82d..d9d08720c386 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -107,11 +107,6 @@ static inline int usb_autoresume_device(struct usb_device *udev)
         return 0;
 }
 
-static inline int usb_remote_wakeup(struct usb_device *udev)
-{
-        return 0;
-}
-
 static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
         return 0;
@@ -119,6 +114,7 @@ static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 #endif
 
 extern struct bus_type usb_bus_type;
+extern struct mutex usb_port_peer_mutex;
 extern struct device_type usb_device_type;
 extern struct device_type usb_if_device_type;
 extern struct device_type usb_ep_device_type;
@@ -170,15 +166,17 @@ extern void usbfs_conn_disc_event(void);
 extern int usb_devio_init(void);
 extern void usb_devio_cleanup(void);
 
+/*
+ * Firmware specific cookie identifying a port's location. '0' == no location
+ * data available
+ */
+typedef u32 usb_port_location_t;
+
 /* internal notify stuff */
 extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);
 extern void usb_notify_add_bus(struct usb_bus *ubus);
 extern void usb_notify_remove_bus(struct usb_bus *ubus);
-extern enum usb_port_connect_type
-        usb_get_hub_port_connect_type(struct usb_device *hdev, int port1);
-extern void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
-        enum usb_port_connect_type type);
 extern void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 struct usb_hub_descriptor *desc);
 
diff --git a/drivers/usb/dwc2/Kconfig b/drivers/usb/dwc2/Kconfig
index be947d673844..f93807b3631a 100644
--- a/drivers/usb/dwc2/Kconfig
+++ b/drivers/usb/dwc2/Kconfig
@@ -1,25 +1,58 @@
 config USB_DWC2
-        tristate "DesignWare USB2 DRD Core Support"
+        bool "DesignWare USB2 DRD Core Support"
         depends on USB
         help
-          Say Y or M here if your system has a Dual Role HighSpeed
-          USB controller based on the DesignWare HSOTG IP Core.
+          Say Y here if your system has a Dual Role Hi-Speed USB
+          controller based on the DesignWare HSOTG IP Core.
 
-          If you choose to build this driver as dynamically linked
-          modules, the core module will be called dwc2.ko, the
-          PCI bus interface module (if you have a PCI bus system)
-          will be called dwc2_pci.ko and the platform interface module
-          (for controllers directly connected to the CPU) will be called
-          dwc2_platform.ko.
+          For host mode, if you choose to build the driver as dynamically
+          linked modules, the core module will be called dwc2.ko, the PCI
+          bus interface module (if you have a PCI bus system) will be
+          called dwc2_pci.ko, and the platform interface module (for
+          controllers directly connected to the CPU) will be called
+          dwc2_platform.ko. For gadget mode, there will be a single
+          module called dwc2_gadget.ko.
 
-          NOTE: This driver at present only implements the Host mode
-          of the controller. The existing s3c-hsotg driver supports
-          Peripheral mode, but only for the Samsung S3C platforms.
-          There are plans to merge the s3c-hsotg driver with this
-          driver in the near future to create a dual-role driver.
+          NOTE: The s3c-hsotg driver is now renamed to dwc2_gadget. The
+          host and gadget drivers are still currently separate drivers.
+          There are plans to merge the dwc2_gadget driver with the dwc2
+          host driver in the near future to create a dual-role driver.
 
 if USB_DWC2
 
+config USB_DWC2_HOST
+        tristate "Host only mode"
+        depends on USB
+        help
+          The Designware USB2.0 high-speed host controller
+          integrated into many SoCs.
+
+config USB_DWC2_PLATFORM
+        bool "DWC2 Platform"
+        depends on USB_DWC2_HOST
+        default USB_DWC2_HOST
+        help
+          The Designware USB2.0 platform interface module for
+          controllers directly connected to the CPU. This is only
+          used for host mode.
+
+config USB_DWC2_PCI
+        bool "DWC2 PCI"
+        depends on USB_DWC2_HOST && PCI
+        default USB_DWC2_HOST
+        help
+          The Designware USB2.0 PCI interface module for controllers
+          connected to a PCI bus. This is only used for host mode.
+
+comment "Gadget mode requires USB Gadget support to be enabled"
+
+config USB_DWC2_PERIPHERAL
+        tristate "Gadget only mode"
+        depends on USB_GADGET
+        help
+          The Designware USB2.0 high-speed gadget controller
+          integrated into many SoCs.
+
 config USB_DWC2_DEBUG
         bool "Enable Debugging Messages"
         help
diff --git a/drivers/usb/dwc2/Makefile b/drivers/usb/dwc2/Makefile
index 11529d3439b0..b73d2a527970 100644
--- a/drivers/usb/dwc2/Makefile
+++ b/drivers/usb/dwc2/Makefile
@@ -1,25 +1,28 @@
 ccflags-$(CONFIG_USB_DWC2_DEBUG)        += -DDEBUG
 ccflags-$(CONFIG_USB_DWC2_VERBOSE)      += -DVERBOSE_DEBUG
 
-obj-$(CONFIG_USB_DWC2)                  += dwc2.o
-
-dwc2-y                                  += core.o core_intr.o
-
-# NOTE: This driver at present only implements the Host mode
-# of the controller. The existing s3c-hsotg driver supports
-# Peripheral mode, but only for the Samsung S3C platforms.
-# There are plans to merge the s3c-hsotg driver with this
-# driver in the near future to create a dual-role driver. Once
-# that is done, Host mode will become an optional feature that
-# is selected with a config option.
-
+obj-$(CONFIG_USB_DWC2_HOST)             += dwc2.o
+dwc2-y                                  := core.o core_intr.o
 dwc2-y                                  += hcd.o hcd_intr.o
 dwc2-y                                  += hcd_queue.o hcd_ddma.o
 
-ifneq ($(CONFIG_PCI),)
-        obj-$(CONFIG_USB_DWC2)          += dwc2_pci.o
+# NOTE: The previous s3c-hsotg peripheral mode only driver has been moved to
+# this location and renamed gadget.c. When building for dynamically linked
+# modules, dwc2_gadget.ko will get built for peripheral mode. For host mode,
+# the core module will be dwc2.ko, the PCI bus interface module will called
+# dwc2_pci.ko and the platform interface module will be called dwc2_platform.ko.
+# At present the host and gadget driver will be separate drivers, but there
+# are plans in the near future to create a dual-role driver.
+
+ifneq ($(CONFIG_USB_DWC2_PCI),)
+        obj-$(CONFIG_USB_DWC2_HOST)     += dwc2_pci.o
+        dwc2_pci-y                      := pci.o
+endif
+
+ifneq ($(CONFIG_USB_DWC2_PLATFORM),)
+        obj-$(CONFIG_USB_DWC2_HOST)     += dwc2_platform.o
+        dwc2_platform-y                 := platform.o
 endif
-obj-$(CONFIG_USB_DWC2)                  += dwc2_platform.o
 
-dwc2_pci-y                              += pci.o
-dwc2_platform-y                         += platform.o
+obj-$(CONFIG_USB_DWC2_PERIPHERAL)       += dwc2_gadget.o
+dwc2_gadget-y                           := gadget.o
diff --git a/drivers/usb/dwc2/core.c b/drivers/usb/dwc2/core.c
index 1d129884cc39..27d2c9b8a034 100644
--- a/drivers/usb/dwc2/core.c
+++ b/drivers/usb/dwc2/core.c
@@ -507,6 +507,72 @@ void dwc2_disable_host_interrupts(struct dwc2_hsotg *hsotg)
         writel(intmsk, hsotg->regs + GINTMSK);
 }
 
+/*
+ * dwc2_calculate_dynamic_fifo() - Calculates the default fifo size
+ * For system that have a total fifo depth that is smaller than the default
+ * RX + TX fifo size.
+ *
+ * @hsotg: Programming view of DWC_otg controller
+ */
+static void dwc2_calculate_dynamic_fifo(struct dwc2_hsotg *hsotg)
+{
+        struct dwc2_core_params *params = hsotg->core_params;
+        struct dwc2_hw_params *hw = &hsotg->hw_params;
+        u32 rxfsiz, nptxfsiz, ptxfsiz, total_fifo_size;
+
+        total_fifo_size = hw->total_fifo_size;
+        rxfsiz = params->host_rx_fifo_size;
+        nptxfsiz = params->host_nperio_tx_fifo_size;
+        ptxfsiz = params->host_perio_tx_fifo_size;
+
+        /*
+         * Will use Method 2 defined in the DWC2 spec: minimum FIFO depth
+         * allocation with support for high bandwidth endpoints. Synopsys
+         * defines MPS(Max Packet size) for a periodic EP=1024, and for
+         * non-periodic as 512.
+         */
+        if (total_fifo_size < (rxfsiz + nptxfsiz + ptxfsiz)) {
+                /*
+                 * For Buffer DMA mode/Scatter Gather DMA mode
+                 * 2 * ((Largest Packet size / 4) + 1 + 1) + n
+                 * with n = number of host channel.
+                 * 2 * ((1024/4) + 2) = 516
+                 */
+                rxfsiz = 516 + hw->host_channels;
+
+                /*
+                 * min non-periodic tx fifo depth
+                 * 2 * (largest non-periodic USB packet used / 4)
+                 * 2 * (512/4) = 256
+                 */
+                nptxfsiz = 256;
+
+                /*
+                 * min periodic tx fifo depth
+                 * (largest packet size*MC)/4
+                 * (1024 * 3)/4 = 768
+                 */
+                ptxfsiz = 768;
+
+                params->host_rx_fifo_size = rxfsiz;
+                params->host_nperio_tx_fifo_size = nptxfsiz;
+                params->host_perio_tx_fifo_size = ptxfsiz;
+        }
+
+        /*
+         * If the summation of RX, NPTX and PTX fifo sizes is still
+         * bigger than the total_fifo_size, then we have a problem.
+         *
+         * We won't be able to allocate as many endpoints. Right now,
+         * we're just printing an error message, but ideally this FIFO
+         * allocation algorithm would be improved in the future.
+         *
+         * FIXME improve this FIFO allocation algorithm.
+         */
+        if (unlikely(total_fifo_size < (rxfsiz + nptxfsiz + ptxfsiz)))
+                dev_err(hsotg->dev, "invalid fifo sizes\n");
+}
+
 static void dwc2_config_fifos(struct dwc2_hsotg *hsotg)
 {
         struct dwc2_core_params *params = hsotg->core_params;
@@ -515,6 +581,8 @@ static void dwc2_config_fifos(struct dwc2_hsotg *hsotg)
         if (!params->enable_dynamic_fifo)
                 return;
 
+        dwc2_calculate_dynamic_fifo(hsotg);
+
         /* Rx FIFO */
         grxfsiz = readl(hsotg->regs + GRXFSIZ);
         dev_dbg(hsotg->dev, "initial grxfsiz=%08x\n", grxfsiz);
diff --git a/drivers/usb/dwc2/core.h b/drivers/usb/dwc2/core.h
index 648519c024b5..1efd10cc9629 100644
--- a/drivers/usb/dwc2/core.h
+++ b/drivers/usb/dwc2/core.h
@@ -37,6 +37,10 @@
 #ifndef __DWC2_CORE_H__
 #define __DWC2_CORE_H__
 
+#include <linux/phy/phy.h>
+#include <linux/regulator/consumer.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
 #include <linux/usb/phy.h>
 #include "hw.h"
 
@@ -54,6 +58,184 @@ static inline void do_write(u32 value, void *addr)
 /* Maximum number of Endpoints/HostChannels */
 #define MAX_EPS_CHANNELS        16
 
+/* s3c-hsotg declarations */
+static const char * const s3c_hsotg_supply_names[] = {
+        "vusb_d",               /* digital USB supply, 1.2V */
+        "vusb_a",               /* analog USB supply, 1.1V */
+};
+
+/*
+ * EP0_MPS_LIMIT
+ *
+ * Unfortunately there seems to be a limit of the amount of data that can
+ * be transferred by IN transactions on EP0. This is either 127 bytes or 3
+ * packets (which practically means 1 packet and 63 bytes of data) when the
+ * MPS is set to 64.
+ *
+ * This means if we are wanting to move >127 bytes of data, we need to
+ * split the transactions up, but just doing one packet at a time does
+ * not work (this may be an implicit DATA0 PID on first packet of the
+ * transaction) and doing 2 packets is outside the controller's limits.
+ *
+ * If we try to lower the MPS size for EP0, then no transfers work properly
+ * for EP0, and the system will fail basic enumeration. As no cause for this
+ * has currently been found, we cannot support any large IN transfers for
+ * EP0.
+ */
+#define EP0_MPS_LIMIT   64
+
+struct s3c_hsotg;
+struct s3c_hsotg_req;
+
+/**
+ * struct s3c_hsotg_ep - driver endpoint definition.
+ * @ep: The gadget layer representation of the endpoint.
+ * @name: The driver generated name for the endpoint.
+ * @queue: Queue of requests for this endpoint.
+ * @parent: Reference back to the parent device structure.
+ * @req: The current request that the endpoint is processing. This is
+ *       used to indicate an request has been loaded onto the endpoint
+ *       and has yet to be completed (maybe due to data move, or simply
+ *       awaiting an ack from the core all the data has been completed).
+ * @debugfs: File entry for debugfs file for this endpoint.
+ * @lock: State lock to protect contents of endpoint.
+ * @dir_in: Set to true if this endpoint is of the IN direction, which
+ *          means that it is sending data to the Host.
+ * @index: The index for the endpoint registers.
+ * @mc: Multi Count - number of transactions per microframe
+ * @interval - Interval for periodic endpoints
+ * @name: The name array passed to the USB core.
+ * @halted: Set if the endpoint has been halted.
+ * @periodic: Set if this is a periodic ep, such as Interrupt
+ * @isochronous: Set if this is a isochronous ep
+ * @sent_zlp: Set if we've sent a zero-length packet.
+ * @total_data: The total number of data bytes done.
+ * @fifo_size: The size of the FIFO (for periodic IN endpoints)
+ * @fifo_load: The amount of data loaded into the FIFO (periodic IN)
+ * @last_load: The offset of data for the last start of request.
+ * @size_loaded: The last loaded size for DxEPTSIZE for periodic IN
+ *
+ * This is the driver's state for each registered enpoint, allowing it
+ * to keep track of transactions that need doing. Each endpoint has a
+ * lock to protect the state, to try and avoid using an overall lock
+ * for the host controller as much as possible.
+ *
+ * For periodic IN endpoints, we have fifo_size and fifo_load to try
+ * and keep track of the amount of data in the periodic FIFO for each
+ * of these as we don't have a status register that tells us how much
+ * is in each of them. (note, this may actually be useless information
+ * as in shared-fifo mode periodic in acts like a single-frame packet
+ * buffer than a fifo)
+ */
+struct s3c_hsotg_ep {
+        struct usb_ep           ep;
+        struct list_head        queue;
+        struct s3c_hsotg        *parent;
+        struct s3c_hsotg_req    *req;
+        struct dentry           *debugfs;
+
+        unsigned long           total_data;
+        unsigned int            size_loaded;
+        unsigned int            last_load;
+        unsigned int            fifo_load;
+        unsigned short          fifo_size;
+
+        unsigned char           dir_in;
+        unsigned char           index;
+        unsigned char           mc;
+        unsigned char           interval;
+
+        unsigned int            halted:1;
+        unsigned int            periodic:1;
+        unsigned int            isochronous:1;
+        unsigned int            sent_zlp:1;
+
+        char                    name[10];
+};
+
+/**
+ * struct s3c_hsotg - driver state.
+ * @dev: The parent device supplied to the probe function
+ * @driver: USB gadget driver
+ * @phy: The otg phy transceiver structure for phy control.
+ * @uphy: The otg phy transceiver structure for old USB phy control.
+ * @plat: The platform specific configuration data. This can be removed once
+ * all SoCs support usb transceiver.
+ * @regs: The memory area mapped for accessing registers.
+ * @irq: The IRQ number we are using
+ * @supplies: Definition of USB power supplies
+ * @phyif: PHY interface width
+ * @dedicated_fifos: Set if the hardware has dedicated IN-EP fifos.
+ * @num_of_eps: Number of available EPs (excluding EP0)
+ * @debug_root: root directrory for debugfs.
+ * @debug_file: main status file for debugfs.
+ * @debug_fifo: FIFO status file for debugfs.
+ * @ep0_reply: Request used for ep0 reply.
+ * @ep0_buff: Buffer for EP0 reply data, if needed.
+ * @ctrl_buff: Buffer for EP0 control requests.
+ * @ctrl_req: Request for EP0 control packets.
+ * @setup: NAK management for EP0 SETUP
+ * @last_rst: Time of last reset
+ * @eps: The endpoints being supplied to the gadget framework
+ */
+struct s3c_hsotg {
+        struct device            *dev;
+        struct usb_gadget_driver *driver;
+        struct phy               *phy;
+        struct usb_phy           *uphy;
+        struct s3c_hsotg_plat    *plat;
+
+        spinlock_t              lock;
+
+        void __iomem            *regs;
+        int                     irq;
+        struct clk              *clk;
+
+        struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
+
+        u32                     phyif;
+        unsigned int            dedicated_fifos:1;
+        unsigned char           num_of_eps;
+
+        struct dentry           *debug_root;
+        struct dentry           *debug_file;
+        struct dentry           *debug_fifo;
+
+        struct usb_request      *ep0_reply;
+        struct usb_request      *ctrl_req;
+        u8                      ep0_buff[8];
+        u8                      ctrl_buff[8];
+
+        struct usb_gadget       gadget;
+        unsigned int            setup;
+        unsigned long           last_rst;
+        struct s3c_hsotg_ep     *eps;
+};
+
+/**
+ * struct s3c_hsotg_req - data transfer request
+ * @req: The USB gadget request
+ * @queue: The list of requests for the endpoint this is queued for.
+ * @in_progress: Has already had size/packets written to core
+ * @mapped: DMA buffer for this request has been mapped via dma_map_single().
+ */
+struct s3c_hsotg_req {
+        struct usb_request      req;
+        struct list_head        queue;
+        unsigned char           in_progress;
+        unsigned char           mapped;
+};
+
+#define call_gadget(_hs, _entry) \
+do { \
+        if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
+                (_hs)->driver && (_hs)->driver->_entry) { \
+                spin_unlock(&_hs->lock); \
+                (_hs)->driver->_entry(&(_hs)->gadget); \
+                spin_lock(&_hs->lock); \
+        } \
+} while (0)
+
 struct dwc2_hsotg;
 struct dwc2_host_chan;
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/dwc2/gadget.c
index 2a9cb674926a..f3c56a2fed5b 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -37,175 +37,7 @@
 #include <linux/usb/phy.h>
 #include <linux/platform_data/s3c-hsotg.h>
 
-#include "s3c-hsotg.h"
-
-static const char * const s3c_hsotg_supply_names[] = {
-        "vusb_d",               /* digital USB supply, 1.2V */
-        "vusb_a",               /* analog USB supply, 1.1V */
-};
-
-/*
- * EP0_MPS_LIMIT
- *
- * Unfortunately there seems to be a limit of the amount of data that can
- * be transferred by IN transactions on EP0. This is either 127 bytes or 3
- * packets (which practically means 1 packet and 63 bytes of data) when the
- * MPS is set to 64.
- *
- * This means if we are wanting to move >127 bytes of data, we need to
- * split the transactions up, but just doing one packet at a time does
- * not work (this may be an implicit DATA0 PID on first packet of the
- * transaction) and doing 2 packets is outside the controller's limits.
- *
- * If we try to lower the MPS size for EP0, then no transfers work properly
- * for EP0, and the system will fail basic enumeration. As no cause for this
- * has currently been found, we cannot support any large IN transfers for
- * EP0.
- */
-#define EP0_MPS_LIMIT   64
-
-struct s3c_hsotg;
-struct s3c_hsotg_req;
-
-/**
- * struct s3c_hsotg_ep - driver endpoint definition.
- * @ep: The gadget layer representation of the endpoint.
- * @name: The driver generated name for the endpoint.
- * @queue: Queue of requests for this endpoint.
- * @parent: Reference back to the parent device structure.
- * @req: The current request that the endpoint is processing. This is
- *       used to indicate an request has been loaded onto the endpoint
- *       and has yet to be completed (maybe due to data move, or simply
- *       awaiting an ack from the core all the data has been completed).
- * @debugfs: File entry for debugfs file for this endpoint.
- * @lock: State lock to protect contents of endpoint.
- * @dir_in: Set to true if this endpoint is of the IN direction, which
- *          means that it is sending data to the Host.
- * @index: The index for the endpoint registers.
- * @mc: Multi Count - number of transactions per microframe
- * @interval - Interval for periodic endpoints
- * @name: The name array passed to the USB core.
- * @halted: Set if the endpoint has been halted.
- * @periodic: Set if this is a periodic ep, such as Interrupt
- * @isochronous: Set if this is a isochronous ep
- * @sent_zlp: Set if we've sent a zero-length packet.
- * @total_data: The total number of data bytes done.
- * @fifo_size: The size of the FIFO (for periodic IN endpoints)
- * @fifo_load: The amount of data loaded into the FIFO (periodic IN)
- * @last_load: The offset of data for the last start of request.
- * @size_loaded: The last loaded size for DxEPTSIZE for periodic IN
- *
- * This is the driver's state for each registered enpoint, allowing it
- * to keep track of transactions that need doing. Each endpoint has a
- * lock to protect the state, to try and avoid using an overall lock
- * for the host controller as much as possible.
- *
- * For periodic IN endpoints, we have fifo_size and fifo_load to try
- * and keep track of the amount of data in the periodic FIFO for each
- * of these as we don't have a status register that tells us how much
- * is in each of them. (note, this may actually be useless information
- * as in shared-fifo mode periodic in acts like a single-frame packet
- * buffer than a fifo)
- */
-struct s3c_hsotg_ep {
-        struct usb_ep           ep;
-        struct list_head        queue;
-        struct s3c_hsotg        *parent;
-        struct s3c_hsotg_req    *req;
-        struct dentry           *debugfs;
-
-
-        unsigned long           total_data;
-        unsigned int            size_loaded;
-        unsigned int            last_load;
-        unsigned int            fifo_load;
-        unsigned short          fifo_size;
-
-        unsigned char           dir_in;
-        unsigned char           index;
-        unsigned char           mc;
-        unsigned char           interval;
-
-        unsigned int            halted:1;
-        unsigned int            periodic:1;
-        unsigned int            isochronous:1;
-        unsigned int            sent_zlp:1;
-
-        char                    name[10];
-};
-
-/**
- * struct s3c_hsotg - driver state.
- * @dev: The parent device supplied to the probe function
- * @driver: USB gadget driver
- * @phy: The otg phy transceiver structure for phy control.
- * @uphy: The otg phy transceiver structure for old USB phy control.
- * @plat: The platform specific configuration data. This can be removed once
- * all SoCs support usb transceiver.
- * @regs: The memory area mapped for accessing registers.
- * @irq: The IRQ number we are using
- * @supplies: Definition of USB power supplies
- * @phyif: PHY interface width
- * @dedicated_fifos: Set if the hardware has dedicated IN-EP fifos.
- * @num_of_eps: Number of available EPs (excluding EP0)
- * @debug_root: root directrory for debugfs.
- * @debug_file: main status file for debugfs.
- * @debug_fifo: FIFO status file for debugfs.
- * @ep0_reply: Request used for ep0 reply.
- * @ep0_buff: Buffer for EP0 reply data, if needed.
- * @ctrl_buff: Buffer for EP0 control requests.
- * @ctrl_req: Request for EP0 control packets.
- * @setup: NAK management for EP0 SETUP
- * @last_rst: Time of last reset
- * @eps: The endpoints being supplied to the gadget framework
- */
-struct s3c_hsotg {
-        struct device            *dev;
-        struct usb_gadget_driver *driver;
-        struct phy               *phy;
-        struct usb_phy           *uphy;
-        struct s3c_hsotg_plat    *plat;
-
-        spinlock_t              lock;
-
-        void __iomem            *regs;
-        int                     irq;
-        struct clk              *clk;
-
-        struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
-
-        u32                     phyif;
-        unsigned int            dedicated_fifos:1;
-        unsigned char           num_of_eps;
-
-        struct dentry           *debug_root;
-        struct dentry           *debug_file;
-        struct dentry           *debug_fifo;
-
-        struct usb_request      *ep0_reply;
-        struct usb_request      *ctrl_req;
-        u8                      ep0_buff[8];
-        u8                      ctrl_buff[8];
-
-        struct usb_gadget       gadget;
-        unsigned int            setup;
-        unsigned long           last_rst;
-        struct s3c_hsotg_ep     *eps;
-};
-
-/**
- * struct s3c_hsotg_req - data transfer request
- * @req: The USB gadget request
- * @queue: The list of requests for the endpoint this is queued for.
- * @in_progress: Has already had size/packets written to core
- * @mapped: DMA buffer for this request has been mapped via dma_map_single().
- */
-struct s3c_hsotg_req {
-        struct usb_request      req;
-        struct list_head        queue;
-        unsigned char           in_progress;
-        unsigned char           mapped;
-};
+#include "core.h"
 
 /* conversion functions */
 static inline struct s3c_hsotg_req *our_req(struct usb_request *req)
@@ -340,9 +172,8 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
         /* set FIFO sizes to 2048/1024 */
 
         writel(2048, hsotg->regs + GRXFSIZ);
-        writel(GNPTXFSIZ_NPTxFStAddr(2048) |
-               GNPTXFSIZ_NPTxFDep(1024),
-               hsotg->regs + GNPTXFSIZ);
+        writel((2048 << FIFOSIZE_STARTADDR_SHIFT) |
+                (1024 << FIFOSIZE_DEPTH_SHIFT), hsotg->regs + GNPTXFSIZ);
 
         /*
          * arange all the rest of the TX FIFOs, as some versions of this
@@ -362,10 +193,10 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
 
         for (ep = 1; ep <= 15; ep++) {
                 val = addr;
-                val |= size << DPTXFSIZn_DPTxFSize_SHIFT;
+                val |= size << FIFOSIZE_DEPTH_SHIFT;
                 addr += size;
 
-                writel(val, hsotg->regs + DPTXFSIZn(ep));
+                writel(val, hsotg->regs + DPTXFSIZN(ep));
         }
 
         /*
@@ -373,15 +204,15 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
          * all fifos are flushed before continuing
          */
 
-        writel(GRSTCTL_TxFNum(0x10) | GRSTCTL_TxFFlsh |
-               GRSTCTL_RxFFlsh, hsotg->regs + GRSTCTL);
+        writel(GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH |
+               GRSTCTL_RXFFLSH, hsotg->regs + GRSTCTL);
 
         /* wait until the fifos are both flushed */
         timeout = 100;
         while (1) {
                 val = readl(hsotg->regs + GRSTCTL);
 
-                if ((val & (GRSTCTL_TxFFlsh | GRSTCTL_RxFFlsh)) == 0)
+                if ((val & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) == 0)
                         break;
 
                 if (--timeout == 0) {
@@ -495,14 +326,14 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                  * how much data is left in the fifo.
                  */
 
-                size_left = DxEPTSIZ_XferSize_GET(epsize);
+                size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
 
                 /*
                  * if shared fifo, we cannot write anything until the
                  * previous data has been completely sent.
                  */
                 if (hs_ep->fifo_load != 0) {
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                         return -ENOSPC;
                 }
 
@@ -523,7 +354,7 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                         __func__, can_write);
 
                 if (can_write <= 0) {
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                         return -ENOSPC;
                 }
         } else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
@@ -532,16 +363,16 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 can_write &= 0xffff;
                 can_write *= 4;
         } else {
-                if (GNPTXSTS_NPTxQSpcAvail_GET(gnptxsts) == 0) {
+                if (GNPTXSTS_NP_TXQ_SPC_AVAIL_GET(gnptxsts) == 0) {
                         dev_dbg(hsotg->dev,
                                 "%s: no queue slots available (0x%08x)\n",
                                 __func__, gnptxsts);
 
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
                         return -ENOSPC;
                 }
 
-                can_write = GNPTXSTS_NPTxFSpcAvail_GET(gnptxsts);
+                can_write = GNPTXSTS_NP_TXF_SPC_AVAIL_GET(gnptxsts);
                 can_write *= 4; /* fifo size is in 32bit quantities. */
         }
 
@@ -569,8 +400,8 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 /* it's needed only when we do not use dedicated fifos */
                 if (!hsotg->dedicated_fifos)
                         s3c_hsotg_en_gsint(hsotg,
-                                           periodic ? GINTSTS_PTxFEmp :
-                                           GINTSTS_NPTxFEmp);
+                                           periodic ? GINTSTS_PTXFEMP :
+                                           GINTSTS_NPTXFEMP);
         }
 
         /* see if we can write data */
@@ -598,8 +429,8 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 /* it's needed only when we do not use dedicated fifos */
                 if (!hsotg->dedicated_fifos)
                         s3c_hsotg_en_gsint(hsotg,
-                                           periodic ? GINTSTS_PTxFEmp :
-                                           GINTSTS_NPTxFEmp);
+                                           periodic ? GINTSTS_PTXFEMP :
+                                           GINTSTS_NPTXFEMP);
         }
 
         dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
@@ -636,12 +467,12 @@ static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
         unsigned maxpkt;
 
         if (index != 0) {
-                maxsize = DxEPTSIZ_XferSize_LIMIT + 1;
-                maxpkt = DxEPTSIZ_PktCnt_LIMIT + 1;
+                maxsize = DXEPTSIZ_XFERSIZE_LIMIT + 1;
+                maxpkt = DXEPTSIZ_PKTCNT_LIMIT + 1;
         } else {
                 maxsize = 64+64;
                 if (hs_ep->dir_in)
-                        maxpkt = DIEPTSIZ0_PktCnt_LIMIT + 1;
+                        maxpkt = DIEPTSIZ0_PKTCNT_LIMIT + 1;
                 else
                         maxpkt = 2;
         }
@@ -710,7 +541,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         /* If endpoint is stalled, we will restart request later */
         ctrl = readl(hsotg->regs + epctrl_reg);
 
-        if (ctrl & DxEPCTL_Stall) {
+        if (ctrl & DXEPCTL_STALL) {
                 dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
                 return;
         }
@@ -720,7 +551,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 ureq->length, ureq->actual);
         if (0)
                 dev_dbg(hsotg->dev,
-                        "REQ buf %p len %d dma 0x%pad noi=%d zp=%d snok=%d\n",
+                        "REQ buf %p len %d dma %pad noi=%d zp=%d snok=%d\n",
                         ureq->buf, length, &ureq->dma,
                         ureq->no_interrupt, ureq->zero, ureq->short_not_ok);
 
@@ -750,9 +581,9 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
 
         if (dir_in && index != 0)
                 if (hs_ep->isochronous)
-                        epsize = DxEPTSIZ_MC(packets);
+                        epsize = DXEPTSIZ_MC(packets);
                 else
-                        epsize = DxEPTSIZ_MC(1);
+                        epsize = DXEPTSIZ_MC(1);
         else
                 epsize = 0;
 
@@ -766,8 +597,8 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                         packets++;
         }
 
-        epsize |= DxEPTSIZ_PktCnt(packets);
-        epsize |= DxEPTSIZ_XferSize(length);
+        epsize |= DXEPTSIZ_PKTCNT(packets);
+        epsize |= DXEPTSIZ_XFERSIZE(length);
 
         dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n",
                 __func__, packets, length, ureq->length, epsize, epsize_reg);
@@ -789,12 +620,12 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
                 writel(ureq->dma, hsotg->regs + dma_reg);
 
-                dev_dbg(hsotg->dev, "%s: 0x%pad => 0x%08x\n",
+                dev_dbg(hsotg->dev, "%s: %pad => 0x%08x\n",
                         __func__, &ureq->dma, dma_reg);
         }
 
-        ctrl |= DxEPCTL_EPEna;  /* ensure ep enabled */
-        ctrl |= DxEPCTL_USBActEp;
+        ctrl |= DXEPCTL_EPENA;  /* ensure ep enabled */
+        ctrl |= DXEPCTL_USBACTEP;
 
         dev_dbg(hsotg->dev, "setup req:%d\n", hsotg->setup);
 
@@ -802,7 +633,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         if (hsotg->setup && index == 0)
                 hsotg->setup = 0;
         else
-                ctrl |= DxEPCTL_CNAK;   /* clear NAK set by core */
+                ctrl |= DXEPCTL_CNAK;   /* clear NAK set by core */
 
 
         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
@@ -828,7 +659,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
          * to debugging to see what is going on.
          */
         if (dir_in)
-                writel(DIEPMSK_INTknTXFEmpMsk,
+                writel(DIEPMSK_INTKNTXFEMPMSK,
                        hsotg->regs + DIEPINT(index));
 
         /*
@@ -837,12 +668,12 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
          */
 
         /* check ep is enabled */
-        if (!(readl(hsotg->regs + epctrl_reg) & DxEPCTL_EPEna))
+        if (!(readl(hsotg->regs + epctrl_reg) & DXEPCTL_EPENA))
                 dev_warn(hsotg->dev,
-                         "ep%d: failed to become enabled (DxEPCTL=0x%08x)?\n",
+                         "ep%d: failed to become enabled (DXEPCTL=0x%08x)?\n",
                          index, readl(hsotg->regs + epctrl_reg));
 
-        dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n",
+        dev_dbg(hsotg->dev, "%s: DXEPCTL=0x%08x\n",
                 __func__, readl(hsotg->regs + epctrl_reg));
 
         /* enable ep interrupts */
@@ -1205,12 +1036,12 @@ static void s3c_hsotg_stall_ep0(struct s3c_hsotg *hsotg) {
          */
 
         ctrl = readl(hsotg->regs + reg);
-        ctrl |= DxEPCTL_Stall;
-        ctrl |= DxEPCTL_CNAK;
+        ctrl |= DXEPCTL_STALL;
+        ctrl |= DXEPCTL_CNAK;
         writel(ctrl, hsotg->regs + reg);
 
         dev_dbg(hsotg->dev,
-                "written DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n",
+                "written DXEPCTL=0x%08x to %08x (DXEPCTL=0x%08x)\n",
                 ctrl, reg, readl(hsotg->regs + reg));
 
          /*
@@ -1262,8 +1093,9 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                 case USB_REQ_SET_ADDRESS:
                         s3c_hsotg_disconnect(hsotg);
                         dcfg = readl(hsotg->regs + DCFG);
-                        dcfg &= ~DCFG_DevAddr_MASK;
-                        dcfg |= ctrl->wValue << DCFG_DevAddr_SHIFT;
+                        dcfg &= ~DCFG_DEVADDR_MASK;
+                        dcfg |= (le16_to_cpu(ctrl->wValue) <<
+                                 DCFG_DEVADDR_SHIFT) & DCFG_DEVADDR_MASK;
                         writel(dcfg, hsotg->regs + DCFG);
 
                         dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
@@ -1458,7 +1290,7 @@ static void s3c_hsotg_rx_data(struct s3c_hsotg *hsotg, int ep_idx, int size)
                 int ptr;
 
                 dev_warn(hsotg->dev,
-                         "%s: FIFO %d bytes on ep%d but no req (DxEPCTl=0x%08x)\n",
+                         "%s: FIFO %d bytes on ep%d but no req (DXEPCTl=0x%08x)\n",
                          __func__, size, ep_idx, epctl);
 
                 /* dump the data from the FIFO, we've nothing we can do */
@@ -1530,13 +1362,13 @@ static void s3c_hsotg_send_zlp(struct s3c_hsotg *hsotg,
         dev_dbg(hsotg->dev, "sending zero-length packet\n");
 
         /* issue a zero-sized packet to terminate this */
-        writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
-               DxEPTSIZ_XferSize(0), hsotg->regs + DIEPTSIZ(0));
+        writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
+               DXEPTSIZ_XFERSIZE(0), hsotg->regs + DIEPTSIZ(0));
 
         ctrl = readl(hsotg->regs + DIEPCTL0);
-        ctrl |= DxEPCTL_CNAK;  /* clear NAK set by core */
-        ctrl |= DxEPCTL_EPEna; /* ensure ep enabled */
-        ctrl |= DxEPCTL_USBActEp;
+        ctrl |= DXEPCTL_CNAK;  /* clear NAK set by core */
+        ctrl |= DXEPCTL_EPENA; /* ensure ep enabled */
+        ctrl |= DXEPCTL_USBACTEP;
         writel(ctrl, hsotg->regs + DIEPCTL0);
 }
 
@@ -1557,7 +1389,7 @@ static void s3c_hsotg_handle_outdone(struct s3c_hsotg *hsotg,
         struct s3c_hsotg_ep *hs_ep = &hsotg->eps[epnum];
         struct s3c_hsotg_req *hs_req = hs_ep->req;
         struct usb_request *req = &hs_req->req;
-        unsigned size_left = DxEPTSIZ_XferSize_GET(epsize);
+        unsigned size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
         int result = 0;
 
         if (!hs_req) {
@@ -1657,24 +1489,22 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
 
         WARN_ON(using_dma(hsotg));
 
-        epnum = grxstsr & GRXSTS_EPNum_MASK;
-        status = grxstsr & GRXSTS_PktSts_MASK;
+        epnum = grxstsr & GRXSTS_EPNUM_MASK;
+        status = grxstsr & GRXSTS_PKTSTS_MASK;
 
-        size = grxstsr & GRXSTS_ByteCnt_MASK;
-        size >>= GRXSTS_ByteCnt_SHIFT;
+        size = grxstsr & GRXSTS_BYTECNT_MASK;
+        size >>= GRXSTS_BYTECNT_SHIFT;
 
         if (1)
                 dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n",
                         __func__, grxstsr, size, epnum);
 
-#define __status(x) ((x) >> GRXSTS_PktSts_SHIFT)
-
-        switch (status >> GRXSTS_PktSts_SHIFT) {
-        case __status(GRXSTS_PktSts_GlobalOutNAK):
-                dev_dbg(hsotg->dev, "GlobalOutNAK\n");
+        switch ((status & GRXSTS_PKTSTS_MASK) >> GRXSTS_PKTSTS_SHIFT) {
+        case GRXSTS_PKTSTS_GLOBALOUTNAK:
+                dev_dbg(hsotg->dev, "GLOBALOUTNAK\n");
                 break;
 
-        case __status(GRXSTS_PktSts_OutDone):
+        case GRXSTS_PKTSTS_OUTDONE:
                 dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg));
 
@@ -1682,7 +1512,7 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
                         s3c_hsotg_handle_outdone(hsotg, epnum, false);
                 break;
 
-        case __status(GRXSTS_PktSts_SetupDone):
+        case GRXSTS_PKTSTS_SETUPDONE:
                 dev_dbg(hsotg->dev,
                         "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg),
@@ -1691,11 +1521,11 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
                 s3c_hsotg_handle_outdone(hsotg, epnum, true);
                 break;
 
-        case __status(GRXSTS_PktSts_OutRX):
+        case GRXSTS_PKTSTS_OUTRX:
                 s3c_hsotg_rx_data(hsotg, epnum, size);
                 break;
 
-        case __status(GRXSTS_PktSts_SetupRX):
+        case GRXSTS_PKTSTS_SETUPRX:
                 dev_dbg(hsotg->dev,
                         "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg),
@@ -1761,7 +1591,7 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
                 hs_ep->ep.maxpacket = mps;
                 hs_ep->mc = 1;
         } else {
-                mpsval = mps & DxEPCTL_MPS_MASK;
+                mpsval = mps & DXEPCTL_MPS_MASK;
                 if (mpsval > 1024)
                         goto bad_mps;
                 mcval = ((mps >> 11) & 0x3) + 1;
@@ -1777,13 +1607,13 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
          */
 
         reg = readl(regs + DIEPCTL(ep));
-        reg &= ~DxEPCTL_MPS_MASK;
+        reg &= ~DXEPCTL_MPS_MASK;
         reg |= mpsval;
         writel(reg, regs + DIEPCTL(ep));
 
         if (ep) {
                 reg = readl(regs + DOEPCTL(ep));
-                reg &= ~DxEPCTL_MPS_MASK;
+                reg &= ~DXEPCTL_MPS_MASK;
                 reg |= mpsval;
                 writel(reg, regs + DOEPCTL(ep));
         }
@@ -1804,7 +1634,7 @@ static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
         int timeout;
         int val;
 
-        writel(GRSTCTL_TxFNum(idx) | GRSTCTL_TxFFlsh,
+        writel(GRSTCTL_TXFNUM(idx) | GRSTCTL_TXFFLSH,
                 hsotg->regs + GRSTCTL);
 
         /* wait until the fifo is flushed */
@@ -1813,7 +1643,7 @@ static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
         while (1) {
                 val = readl(hsotg->regs + GRSTCTL);
 
-                if ((val & (GRSTCTL_TxFFlsh)) == 0)
+                if ((val & (GRSTCTL_TXFFLSH)) == 0)
                         break;
 
                 if (--timeout == 0) {
@@ -1896,7 +1726,7 @@ static void s3c_hsotg_complete_in(struct s3c_hsotg *hsotg,
          * aligned).
          */
 
-        size_left = DxEPTSIZ_XferSize_GET(epsize);
+        size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
 
         size_done = hs_ep->size_loaded - size_left;
         size_done += hs_ep->last_load;
@@ -1963,17 +1793,17 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
                 __func__, idx, dir_in ? "in" : "out", ints);
 
-        if (ints & DxEPINT_XferCompl) {
+        if (ints & DXEPINT_XFERCOMPL) {
                 if (hs_ep->isochronous && hs_ep->interval == 1) {
-                        if (ctrl & DxEPCTL_EOFrNum)
-                                ctrl |= DxEPCTL_SetEvenFr;
+                        if (ctrl & DXEPCTL_EOFRNUM)
+                                ctrl |= DXEPCTL_SETEVENFR;
                         else
-                                ctrl |= DxEPCTL_SetOddFr;
+                                ctrl |= DXEPCTL_SETODDFR;
                         writel(ctrl, hsotg->regs + epctl_reg);
                 }
 
                 dev_dbg(hsotg->dev,
-                        "%s: XferCompl: DxEPCTL=0x%08x, DxEPTSIZ=%08x\n",
+                        "%s: XferCompl: DxEPCTL=0x%08x, DXEPTSIZ=%08x\n",
                         __func__, readl(hsotg->regs + epctl_reg),
                         readl(hsotg->regs + epsiz_reg));
 
@@ -1996,7 +1826,7 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 }
         }
 
-        if (ints & DxEPINT_EPDisbld) {
+        if (ints & DXEPINT_EPDISBLD) {
                 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
 
                 if (dir_in) {
@@ -2004,20 +1834,20 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
 
                         s3c_hsotg_txfifo_flush(hsotg, idx);
 
-                        if ((epctl & DxEPCTL_Stall) &&
-                                (epctl & DxEPCTL_EPType_Bulk)) {
+                        if ((epctl & DXEPCTL_STALL) &&
+                                (epctl & DXEPCTL_EPTYPE_BULK)) {
                                 int dctl = readl(hsotg->regs + DCTL);
 
-                                dctl |= DCTL_CGNPInNAK;
+                                dctl |= DCTL_CGNPINNAK;
                                 writel(dctl, hsotg->regs + DCTL);
                         }
                 }
         }
 
-        if (ints & DxEPINT_AHBErr)
+        if (ints & DXEPINT_AHBERR)
                 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
 
-        if (ints & DxEPINT_Setup) {  /* Setup or Timeout */
+        if (ints & DXEPINT_SETUP) {  /* Setup or Timeout */
                 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n",  __func__);
 
                 if (using_dma(hsotg) && idx == 0) {
@@ -2035,25 +1865,25 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 }
         }
 
-        if (ints & DxEPINT_Back2BackSetup)
+        if (ints & DXEPINT_BACK2BACKSETUP)
                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
 
         if (dir_in && !hs_ep->isochronous) {
                 /* not sure if this is important, but we'll clear it anyway */
-                if (ints & DIEPMSK_INTknTXFEmpMsk) {
+                if (ints & DIEPMSK_INTKNTXFEMPMSK) {
                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
                                 __func__, idx);
                 }
 
                 /* this probably means something bad is happening */
-                if (ints & DIEPMSK_INTknEPMisMsk) {
+                if (ints & DIEPMSK_INTKNEPMISMSK) {
                         dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
                                  __func__, idx);
                 }
 
                 /* FIFO has space or is empty (see GAHBCFG) */
                 if (hsotg->dedicated_fifos &&
-                    ints & DIEPMSK_TxFIFOEmpty) {
+                    ints & DIEPMSK_TXFIFOEMPTY) {
                         dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
                                 __func__, idx);
                         if (!using_dma(hsotg))
@@ -2089,21 +1919,21 @@ static void s3c_hsotg_irq_enumdone(struct s3c_hsotg *hsotg)
          */
 
         /* catch both EnumSpd_FS and EnumSpd_FS48 */
-        switch (dsts & DSTS_EnumSpd_MASK) {
-        case DSTS_EnumSpd_FS:
-        case DSTS_EnumSpd_FS48:
+        switch (dsts & DSTS_ENUMSPD_MASK) {
+        case DSTS_ENUMSPD_FS:
+        case DSTS_ENUMSPD_FS48:
                 hsotg->gadget.speed = USB_SPEED_FULL;
                 ep0_mps = EP0_MPS_LIMIT;
                 ep_mps = 1023;
                 break;
 
-        case DSTS_EnumSpd_HS:
+        case DSTS_ENUMSPD_HS:
                 hsotg->gadget.speed = USB_SPEED_HIGH;
                 ep0_mps = EP0_MPS_LIMIT;
                 ep_mps = 1024;
                 break;
 
-        case DSTS_EnumSpd_LS:
+        case DSTS_ENUMSPD_LS:
                 hsotg->gadget.speed = USB_SPEED_LOW;
                 /*
                  * note, we don't actually support LS in this driver at the
@@ -2169,16 +1999,6 @@ static void kill_all_requests(struct s3c_hsotg *hsotg,
                         s3c_hsotg_txfifo_flush(hsotg, ep->index);
 }
 
-#define call_gadget(_hs, _entry) \
-do { \
-        if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
-            (_hs)->driver && (_hs)->driver->_entry) { \
-                spin_unlock(&_hs->lock); \
-                (_hs)->driver->_entry(&(_hs)->gadget); \
-                spin_lock(&_hs->lock); \
-        } \
-} while (0)
-
 /**
  * s3c_hsotg_disconnect - disconnect service
  * @hsotg: The device state.
@@ -2226,9 +2046,9 @@ static void s3c_hsotg_irq_fifoempty(struct s3c_hsotg *hsotg, bool periodic)
 }
 
 /* IRQ flags which will trigger a retry around the IRQ loop */
-#define IRQ_RETRY_MASK (GINTSTS_NPTxFEmp | \
-                        GINTSTS_PTxFEmp |  \
-                        GINTSTS_RxFLvl)
+#define IRQ_RETRY_MASK (GINTSTS_NPTXFEMP | \
+                        GINTSTS_PTXFEMP |  \
+                        GINTSTS_RXFLVL)
 
 /**
  * s3c_hsotg_corereset - issue softreset to the core
@@ -2244,14 +2064,14 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
         dev_dbg(hsotg->dev, "resetting core\n");
 
         /* issue soft reset */
-        writel(GRSTCTL_CSftRst, hsotg->regs + GRSTCTL);
+        writel(GRSTCTL_CSFTRST, hsotg->regs + GRSTCTL);
 
         timeout = 10000;
         do {
                 grstctl = readl(hsotg->regs + GRSTCTL);
-        } while ((grstctl & GRSTCTL_CSftRst) && timeout-- > 0);
+        } while ((grstctl & GRSTCTL_CSFTRST) && timeout-- > 0);
 
-        if (grstctl & GRSTCTL_CSftRst) {
+        if (grstctl & GRSTCTL_CSFTRST) {
                 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
                 return -EINVAL;
         }
@@ -2268,7 +2088,7 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                         return -ETIMEDOUT;
                 }
 
-                if (!(grstctl & GRSTCTL_AHBIdle))
+                if (!(grstctl & GRSTCTL_AHBIDLE))
                         continue;
 
                 break;          /* reset done */
@@ -2294,14 +2114,14 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          */
 
         /* set the PLL on, remove the HNP/SRP and set the PHY */
-        writel(hsotg->phyif | GUSBCFG_TOutCal(7) |
+        writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
                (0x5 << 10), hsotg->regs + GUSBCFG);
 
         s3c_hsotg_init_fifo(hsotg);
 
-        __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 
-        writel(1 << 18 | DCFG_DevSpd_HS,  hsotg->regs + DCFG);
+        writel(1 << 18 | DCFG_DEVSPD_HS,  hsotg->regs + DCFG);
 
         /* Clear any pending OTG interrupts */
         writel(0xffffffff, hsotg->regs + GOTGINT);
@@ -2309,21 +2129,21 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
         /* Clear any pending interrupts */
         writel(0xffffffff, hsotg->regs + GINTSTS);
 
-        writel(GINTSTS_ErlySusp | GINTSTS_SessReqInt |
-               GINTSTS_GOUTNakEff | GINTSTS_GINNakEff |
-               GINTSTS_ConIDStsChng | GINTSTS_USBRst |
-               GINTSTS_EnumDone | GINTSTS_OTGInt |
-               GINTSTS_USBSusp | GINTSTS_WkUpInt,
-               hsotg->regs + GINTMSK);
+        writel(GINTSTS_ERLYSUSP | GINTSTS_SESSREQINT |
+                GINTSTS_GOUTNAKEFF | GINTSTS_GINNAKEFF |
+                GINTSTS_CONIDSTSCHNG | GINTSTS_USBRST |
+                GINTSTS_ENUMDONE | GINTSTS_OTGINT |
+                GINTSTS_USBSUSP | GINTSTS_WKUPINT,
+                hsotg->regs + GINTMSK);
 
         if (using_dma(hsotg))
-                writel(GAHBCFG_GlblIntrEn | GAHBCFG_DMAEn |
-                       GAHBCFG_HBstLen_Incr4,
+                writel(GAHBCFG_GLBL_INTR_EN | GAHBCFG_DMA_EN |
+                       GAHBCFG_HBSTLEN_INCR4,
                        hsotg->regs + GAHBCFG);
         else
-                writel(((hsotg->dedicated_fifos) ? (GAHBCFG_NPTxFEmpLvl |
-                                                    GAHBCFG_PTxFEmpLvl) : 0) |
-                       GAHBCFG_GlblIntrEn,
+                writel(((hsotg->dedicated_fifos) ? (GAHBCFG_NP_TXF_EMP_LVL |
+                                                    GAHBCFG_P_TXF_EMP_LVL) : 0) |
+                       GAHBCFG_GLBL_INTR_EN,
                        hsotg->regs + GAHBCFG);
 
         /*
@@ -2332,22 +2152,22 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          * interrupts.
          */
 
-        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TxFIFOEmpty |
-               DIEPMSK_INTknTXFEmpMsk : 0) |
-               DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk |
-               DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
-               DIEPMSK_INTknEPMisMsk,
-               hsotg->regs + DIEPMSK);
+        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TXFIFOEMPTY |
+                DIEPMSK_INTKNTXFEMPMSK : 0) |
+                DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK |
+                DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
+                DIEPMSK_INTKNEPMISMSK,
+                hsotg->regs + DIEPMSK);
 
         /*
          * don't need XferCompl, we get that from RXFIFO in slave mode. In
          * DMA mode we may need this.
          */
-        writel((using_dma(hsotg) ? (DIEPMSK_XferComplMsk |
-                                    DIEPMSK_TimeOUTMsk) : 0) |
-               DOEPMSK_EPDisbldMsk | DOEPMSK_AHBErrMsk |
-               DOEPMSK_SetupMsk,
-               hsotg->regs + DOEPMSK);
+        writel((using_dma(hsotg) ? (DIEPMSK_XFERCOMPLMSK |
+                                    DIEPMSK_TIMEOUTMSK) : 0) |
+                DOEPMSK_EPDISBLDMSK | DOEPMSK_AHBERRMSK |
+                DOEPMSK_SETUPMSK,
+                hsotg->regs + DOEPMSK);
 
         writel(0, hsotg->regs + DAINTMSK);
 
@@ -2356,7 +2176,7 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
                 readl(hsotg->regs + DOEPCTL0));
 
         /* enable in and out endpoint interrupts */
-        s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPInt | GINTSTS_IEPInt);
+        s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
 
         /*
          * Enable the RXFIFO when in slave mode, as this is how we collect
@@ -2364,15 +2184,15 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          * things we cannot process, so do not use it.
          */
         if (!using_dma(hsotg))
-                s3c_hsotg_en_gsint(hsotg, GINTSTS_RxFLvl);
+                s3c_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
 
         /* Enable interrupts for EP0 in and out */
         s3c_hsotg_ctrl_epint(hsotg, 0, 0, 1);
         s3c_hsotg_ctrl_epint(hsotg, 0, 1, 1);
 
-        __orr32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
+        __orr32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
         udelay(10);  /* see openiboot */
-        __bic32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
+        __bic32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
 
         dev_dbg(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + DCTL));
 
@@ -2382,17 +2202,17 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          */
 
         /* set to read 1 8byte packet */
-        writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
-               DxEPTSIZ_XferSize(8), hsotg->regs + DOEPTSIZ0);
+        writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
+               DXEPTSIZ_XFERSIZE(8), hsotg->regs + DOEPTSIZ0);
 
         writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
-               DxEPCTL_CNAK | DxEPCTL_EPEna |
-               DxEPCTL_USBActEp,
+               DXEPCTL_CNAK | DXEPCTL_EPENA |
+               DXEPCTL_USBACTEP,
                hsotg->regs + DOEPCTL0);
 
         /* enable, but don't activate EP0in */
         writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
-               DxEPCTL_USBActEp, hsotg->regs + DIEPCTL0);
+               DXEPCTL_USBACTEP, hsotg->regs + DIEPCTL0);
 
         s3c_hsotg_enqueue_setup(hsotg);
 
@@ -2401,14 +2221,14 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
                 readl(hsotg->regs + DOEPCTL0));
 
         /* clear global NAKs */
-        writel(DCTL_CGOUTNak | DCTL_CGNPInNAK,
+        writel(DCTL_CGOUTNAK | DCTL_CGNPINNAK,
                hsotg->regs + DCTL);
 
         /* must be at-least 3ms to allow bus to see disconnect */
         mdelay(3);
 
         /* remove the soft-disconnect and let's go */
-        __bic32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __bic32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 }
 
 /**
@@ -2433,7 +2253,7 @@ irq_retry:
 
         gintsts &= gintmsk;
 
-        if (gintsts & GINTSTS_OTGInt) {
+        if (gintsts & GINTSTS_OTGINT) {
                 u32 otgint = readl(hsotg->regs + GOTGINT);
 
                 dev_info(hsotg->dev, "OTGInt: %08x\n", otgint);
@@ -2441,34 +2261,34 @@ irq_retry:
                 writel(otgint, hsotg->regs + GOTGINT);
         }
 
-        if (gintsts & GINTSTS_SessReqInt) {
+        if (gintsts & GINTSTS_SESSREQINT) {
                 dev_dbg(hsotg->dev, "%s: SessReqInt\n", __func__);
-                writel(GINTSTS_SessReqInt, hsotg->regs + GINTSTS);
+                writel(GINTSTS_SESSREQINT, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & GINTSTS_EnumDone) {
-                writel(GINTSTS_EnumDone, hsotg->regs + GINTSTS);
+        if (gintsts & GINTSTS_ENUMDONE) {
+                writel(GINTSTS_ENUMDONE, hsotg->regs + GINTSTS);
 
                 s3c_hsotg_irq_enumdone(hsotg);
         }
 
-        if (gintsts & GINTSTS_ConIDStsChng) {
+        if (gintsts & GINTSTS_CONIDSTSCHNG) {
                 dev_dbg(hsotg->dev, "ConIDStsChg (DSTS=0x%08x, GOTCTL=%08x)\n",
                         readl(hsotg->regs + DSTS),
                         readl(hsotg->regs + GOTGCTL));
 
-                writel(GINTSTS_ConIDStsChng, hsotg->regs + GINTSTS);
+                writel(GINTSTS_CONIDSTSCHNG, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & (GINTSTS_OEPInt | GINTSTS_IEPInt)) {
+        if (gintsts & (GINTSTS_OEPINT | GINTSTS_IEPINT)) {
                 u32 daint = readl(hsotg->regs + DAINT);
                 u32 daintmsk = readl(hsotg->regs + DAINTMSK);
                 u32 daint_out, daint_in;
                 int ep;
 
                 daint &= daintmsk;
-                daint_out = daint >> DAINT_OutEP_SHIFT;
-                daint_in = daint & ~(daint_out << DAINT_OutEP_SHIFT);
+                daint_out = daint >> DAINT_OUTEP_SHIFT;
+                daint_in = daint & ~(daint_out << DAINT_OUTEP_SHIFT);
 
                 dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
 
@@ -2483,7 +2303,7 @@ irq_retry:
                 }
         }
 
-        if (gintsts & GINTSTS_USBRst) {
+        if (gintsts & GINTSTS_USBRST) {
 
                 u32 usb_status = readl(hsotg->regs + GOTGCTL);
 
@@ -2491,7 +2311,7 @@ irq_retry:
                 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
                         readl(hsotg->regs + GNPTXSTS));
 
-                writel(GINTSTS_USBRst, hsotg->regs + GINTSTS);
+                writel(GINTSTS_USBRST, hsotg->regs + GINTSTS);
 
                 if (usb_status & GOTGCTL_BSESVLD) {
                         if (time_after(jiffies, hsotg->last_rst +
@@ -2508,7 +2328,7 @@ irq_retry:
 
         /* check both FIFOs */
 
-        if (gintsts & GINTSTS_NPTxFEmp) {
+        if (gintsts & GINTSTS_NPTXFEMP) {
                 dev_dbg(hsotg->dev, "NPTxFEmp\n");
 
                 /*
@@ -2517,20 +2337,20 @@ irq_retry:
                  * it needs re-enabling
                  */
 
-                s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTxFEmp);
+                s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
                 s3c_hsotg_irq_fifoempty(hsotg, false);
         }
 
-        if (gintsts & GINTSTS_PTxFEmp) {
+        if (gintsts & GINTSTS_PTXFEMP) {
                 dev_dbg(hsotg->dev, "PTxFEmp\n");
 
                 /* See note in GINTSTS_NPTxFEmp */
 
-                s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTxFEmp);
+                s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
                 s3c_hsotg_irq_fifoempty(hsotg, true);
         }
 
-        if (gintsts & GINTSTS_RxFLvl) {
+        if (gintsts & GINTSTS_RXFLVL) {
                 /*
                  * note, since GINTSTS_RxFLvl doubles as FIFO-not-empty,
                  * we need to retry s3c_hsotg_handle_rx if this is still
@@ -2540,28 +2360,28 @@ irq_retry:
                 s3c_hsotg_handle_rx(hsotg);
         }
 
-        if (gintsts & GINTSTS_ModeMis) {
+        if (gintsts & GINTSTS_MODEMIS) {
                 dev_warn(hsotg->dev, "warning, mode mismatch triggered\n");
-                writel(GINTSTS_ModeMis, hsotg->regs + GINTSTS);
+                writel(GINTSTS_MODEMIS, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & GINTSTS_USBSusp) {
+        if (gintsts & GINTSTS_USBSUSP) {
                 dev_info(hsotg->dev, "GINTSTS_USBSusp\n");
-                writel(GINTSTS_USBSusp, hsotg->regs + GINTSTS);
+                writel(GINTSTS_USBSUSP, hsotg->regs + GINTSTS);
 
                 call_gadget(hsotg, suspend);
         }
 
-        if (gintsts & GINTSTS_WkUpInt) {
+        if (gintsts & GINTSTS_WKUPINT) {
                 dev_info(hsotg->dev, "GINTSTS_WkUpIn\n");
-                writel(GINTSTS_WkUpInt, hsotg->regs + GINTSTS);
+                writel(GINTSTS_WKUPINT, hsotg->regs + GINTSTS);
 
                 call_gadget(hsotg, resume);
         }
 
-        if (gintsts & GINTSTS_ErlySusp) {
+        if (gintsts & GINTSTS_ERLYSUSP) {
                 dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
-                writel(GINTSTS_ErlySusp, hsotg->regs + GINTSTS);
+                writel(GINTSTS_ERLYSUSP, hsotg->regs + GINTSTS);
         }
 
         /*
@@ -2570,18 +2390,18 @@ irq_retry:
          * the occurrence.
          */
 
-        if (gintsts & GINTSTS_GOUTNakEff) {
+        if (gintsts & GINTSTS_GOUTNAKEFF) {
                 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
 
-                writel(DCTL_CGOUTNak, hsotg->regs + DCTL);
+                writel(DCTL_CGOUTNAK, hsotg->regs + DCTL);
 
                 s3c_hsotg_dump(hsotg);
         }
 
-        if (gintsts & GINTSTS_GINNakEff) {
+        if (gintsts & GINTSTS_GINNAKEFF) {
                 dev_info(hsotg->dev, "GINNakEff triggered\n");
 
-                writel(DCTL_CGNPInNAK, hsotg->regs + DCTL);
+                writel(DCTL_CGNPINNAK, hsotg->regs + DCTL);
 
                 s3c_hsotg_dump(hsotg);
         }
@@ -2645,14 +2465,14 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
 
         spin_lock_irqsave(&hsotg->lock, flags);
 
-        epctrl &= ~(DxEPCTL_EPType_MASK | DxEPCTL_MPS_MASK);
-        epctrl |= DxEPCTL_MPS(mps);
+        epctrl &= ~(DXEPCTL_EPTYPE_MASK | DXEPCTL_MPS_MASK);
+        epctrl |= DXEPCTL_MPS(mps);
 
         /*
          * mark the endpoint as active, otherwise the core may ignore
          * transactions entirely for this endpoint
          */
-        epctrl |= DxEPCTL_USBActEp;
+        epctrl |= DXEPCTL_USBACTEP;
 
         /*
          * set the NAK status on the endpoint, otherwise we might try and
@@ -2661,7 +2481,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
          * size register hasn't been set.
          */
 
-        epctrl |= DxEPCTL_SNAK;
+        epctrl |= DXEPCTL_SNAK;
 
         /* update the endpoint state */
         s3c_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps);
@@ -2677,15 +2497,15 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
 
         switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
         case USB_ENDPOINT_XFER_ISOC:
-                epctrl |= DxEPCTL_EPType_Iso;
-                epctrl |= DxEPCTL_SetEvenFr;
+                epctrl |= DXEPCTL_EPTYPE_ISO;
+                epctrl |= DXEPCTL_SETEVENFR;
                 hs_ep->isochronous = 1;
                 if (dir_in)
                         hs_ep->periodic = 1;
                 break;
 
         case USB_ENDPOINT_XFER_BULK:
-                epctrl |= DxEPCTL_EPType_Bulk;
+                epctrl |= DXEPCTL_EPTYPE_BULK;
                 break;
 
         case USB_ENDPOINT_XFER_INT:
@@ -2698,14 +2518,14 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
                          */
 
                         hs_ep->periodic = 1;
-                        epctrl |= DxEPCTL_TxFNum(index);
+                        epctrl |= DXEPCTL_TXFNUM(index);
                 }
 
-                epctrl |= DxEPCTL_EPType_Intterupt;
+                epctrl |= DXEPCTL_EPTYPE_INTERRUPT;
                 break;
 
         case USB_ENDPOINT_XFER_CONTROL:
-                epctrl |= DxEPCTL_EPType_Control;
+                epctrl |= DXEPCTL_EPTYPE_CONTROL;
                 break;
         }
 
@@ -2714,11 +2534,11 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
          * a unique tx-fifo even if it is non-periodic.
          */
         if (dir_in && hsotg->dedicated_fifos)
-                epctrl |= DxEPCTL_TxFNum(index);
+                epctrl |= DXEPCTL_TXFNUM(index);
 
         /* for non control endpoints, set PID to D0 */
         if (index)
-                epctrl |= DxEPCTL_SetD0PID;
+                epctrl |= DXEPCTL_SETD0PID;
 
         dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n",
                 __func__, epctrl);
@@ -2763,9 +2583,9 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
 
 
         ctrl = readl(hsotg->regs + epctrl_reg);
-        ctrl &= ~DxEPCTL_EPEna;
-        ctrl &= ~DxEPCTL_USBActEp;
-        ctrl |= DxEPCTL_SNAK;
+        ctrl &= ~DXEPCTL_EPENA;
+        ctrl &= ~DXEPCTL_USBACTEP;
+        ctrl |= DXEPCTL_SNAK;
 
         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
         writel(ctrl, hsotg->regs + epctrl_reg);
@@ -2852,15 +2672,15 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epctl = readl(hs->regs + epreg);
 
         if (value) {
-                epctl |= DxEPCTL_Stall + DxEPCTL_SNAK;
-                if (epctl & DxEPCTL_EPEna)
-                        epctl |= DxEPCTL_EPDis;
+                epctl |= DXEPCTL_STALL + DXEPCTL_SNAK;
+                if (epctl & DXEPCTL_EPENA)
+                        epctl |= DXEPCTL_EPDIS;
         } else {
-                epctl &= ~DxEPCTL_Stall;
-                xfertype = epctl & DxEPCTL_EPType_MASK;
-                if (xfertype == DxEPCTL_EPType_Bulk ||
-                        xfertype == DxEPCTL_EPType_Intterupt)
-                                epctl |= DxEPCTL_SetD0PID;
+                epctl &= ~DXEPCTL_STALL;
+                xfertype = epctl & DXEPCTL_EPTYPE_MASK;
+                if (xfertype == DXEPCTL_EPTYPE_BULK ||
+                        xfertype == DXEPCTL_EPTYPE_INTERRUPT)
+                                epctl |= DXEPCTL_SETD0PID;
         }
 
         writel(epctl, hs->regs + epreg);
@@ -2869,13 +2689,13 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epctl = readl(hs->regs + epreg);
 
         if (value)
-                epctl |= DxEPCTL_Stall;
+                epctl |= DXEPCTL_STALL;
         else {
-                epctl &= ~DxEPCTL_Stall;
-                xfertype = epctl & DxEPCTL_EPType_MASK;
-                if (xfertype == DxEPCTL_EPType_Bulk ||
-                        xfertype == DxEPCTL_EPType_Intterupt)
-                                epctl |= DxEPCTL_SetD0PID;
+                epctl &= ~DXEPCTL_STALL;
+                xfertype = epctl & DXEPCTL_EPTYPE_MASK;
+                if (xfertype == DXEPCTL_EPTYPE_BULK ||
+                        xfertype == DXEPCTL_EPTYPE_INTERRUPT)
+                                epctl |= DXEPCTL_SETD0PID;
         }
 
         writel(epctl, hs->regs + epreg);
@@ -2965,22 +2785,22 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 {
         /* unmask subset of endpoint interrupts */
 
-        writel(DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
-               DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk,
-               hsotg->regs + DIEPMSK);
+        writel(DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
+                DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK,
+                hsotg->regs + DIEPMSK);
 
-        writel(DOEPMSK_SetupMsk | DOEPMSK_AHBErrMsk |
-               DOEPMSK_EPDisbldMsk | DOEPMSK_XferComplMsk,
-               hsotg->regs + DOEPMSK);
+        writel(DOEPMSK_SETUPMSK | DOEPMSK_AHBERRMSK |
+                DOEPMSK_EPDISBLDMSK | DOEPMSK_XFERCOMPLMSK,
+                hsotg->regs + DOEPMSK);
 
         writel(0, hsotg->regs + DAINTMSK);
 
         /* Be in disconnected state until gadget is registered */
-        __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 
         if (0) {
                 /* post global nak until we're ready */
-                writel(DCTL_SGNPInNAK | DCTL_SGOUTNak,
+                writel(DCTL_SGNPINNAK | DCTL_SGOUTNAK,
                        hsotg->regs + DCTL);
         }
 
@@ -2993,10 +2813,10 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
         s3c_hsotg_init_fifo(hsotg);
 
         /* set the PLL on, remove the HNP/SRP and set the PHY */
-        writel(GUSBCFG_PHYIf16 | GUSBCFG_TOutCal(7) | (0x5 << 10),
+        writel(GUSBCFG_PHYIF16 | GUSBCFG_TOUTCAL(7) | (0x5 << 10),
                hsotg->regs + GUSBCFG);
 
-        writel(using_dma(hsotg) ? GAHBCFG_DMAEn : 0x0,
+        writel(using_dma(hsotg) ? GAHBCFG_DMA_EN : 0x0,
                hsotg->regs + GAHBCFG);
 }
 
@@ -3187,8 +3007,8 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
          * code is changed to make each endpoint's direction changeable.
          */
 
-        ptxfifo = readl(hsotg->regs + DPTXFSIZn(epnum));
-        hs_ep->fifo_size = DPTXFSIZn_DPTxFSize_GET(ptxfifo) * 4;
+        ptxfifo = readl(hsotg->regs + DPTXFSIZN(epnum));
+        hs_ep->fifo_size = FIFOSIZE_DEPTH_GET(ptxfifo) * 4;
 
         /*
          * if we're using dma, we need to set the next-endpoint pointer
@@ -3196,7 +3016,7 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
          */
 
         if (using_dma(hsotg)) {
-                u32 next = DxEPCTL_NextEp((epnum + 1) % 15);
+                u32 next = DXEPCTL_NEXTEP((epnum + 1) % 15);
                 writel(next, hsotg->regs + DIEPCTL(epnum));
                 writel(next, hsotg->regs + DOEPCTL(epnum));
         }
@@ -3250,10 +3070,10 @@ static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
         /* show periodic fifo settings */
 
         for (idx = 1; idx <= 15; idx++) {
-                val = readl(regs + DPTXFSIZn(idx));
+                val = readl(regs + DPTXFSIZN(idx));
                 dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx,
-                         val >> DPTXFSIZn_DPTxFSize_SHIFT,
-                         val & DPTXFSIZn_DPTxFStAddr_MASK);
+                         val >> FIFOSIZE_DEPTH_SHIFT,
+                         val & FIFOSIZE_STARTADDR_MASK);
         }
 
         for (idx = 0; idx < 15; idx++) {
@@ -3368,17 +3188,17 @@ static int fifo_show(struct seq_file *seq, void *v)
 
         val = readl(regs + GNPTXFSIZ);
         seq_printf(seq, "NPTXFIFO: Size %d, Start 0x%08x\n",
-                   val >> GNPTXFSIZ_NPTxFDep_SHIFT,
-                   val & GNPTXFSIZ_NPTxFStAddr_MASK);
+                   val >> FIFOSIZE_DEPTH_SHIFT,
+                   val & FIFOSIZE_DEPTH_MASK);
 
         seq_puts(seq, "\nPeriodic TXFIFOs:\n");
 
         for (idx = 1; idx <= 15; idx++) {
-                val = readl(regs + DPTXFSIZn(idx));
+                val = readl(regs + DPTXFSIZN(idx));
 
                 seq_printf(seq, "\tDPTXFIFO%2d: Size %d, Start 0x%08x\n", idx,
-                           val >> DPTXFSIZn_DPTxFSize_SHIFT,
-                           val & DPTXFSIZn_DPTxFStAddr_MASK);
+                           val >> FIFOSIZE_DEPTH_SHIFT,
+                           val & FIFOSIZE_STARTADDR_MASK);
         }
 
         return 0;
@@ -3662,14 +3482,14 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
         }
 
         /* Set default UTMI width */
-        hsotg->phyif = GUSBCFG_PHYIf16;
+        hsotg->phyif = GUSBCFG_PHYIF16;
 
         /*
          * If using the generic PHY framework, check if the PHY bus
          * width is 8-bit and set the phyif appropriately.
          */
         if (hsotg->phy && (phy_get_bus_width(phy) == 8))
-                hsotg->phyif = GUSBCFG_PHYIf8;
+                hsotg->phyif = GUSBCFG_PHYIF8;
 
         if (hsotg->phy)
                 phy_init(hsotg->phy);
diff --git a/drivers/usb/dwc2/hw.h b/drivers/usb/dwc2/hw.h
index 9c92a3c7588a..51248b935493 100644
--- a/drivers/usb/dwc2/hw.h
+++ b/drivers/usb/dwc2/hw.h
@@ -109,6 +109,7 @@
 #define GUSBCFG_FSINTF                  (1 << 5)
 #define GUSBCFG_ULPI_UTMI_SEL           (1 << 4)
 #define GUSBCFG_PHYIF16                 (1 << 3)
+#define GUSBCFG_PHYIF8                  (0 << 3)
 #define GUSBCFG_TOUTCAL_MASK            (0x7 << 0)
 #define GUSBCFG_TOUTCAL_SHIFT           0
 #define GUSBCFG_TOUTCAL_LIMIT           0x7
@@ -403,6 +404,7 @@
 #define FIFOSIZE_DEPTH_SHIFT            16
 #define FIFOSIZE_STARTADDR_MASK         (0xffff << 0)
 #define FIFOSIZE_STARTADDR_SHIFT        0
+#define FIFOSIZE_DEPTH_GET(_x)          (((_x) >> 16) & 0xffff)
 
 /* Device mode registers */
 
@@ -519,11 +521,11 @@
 #define DXEPCTL_STALL                   (1 << 21)
 #define DXEPCTL_SNP                     (1 << 20)
 #define DXEPCTL_EPTYPE_MASK             (0x3 << 18)
-#define DXEPCTL_EPTYPE_SHIFT            18
-#define DXEPCTL_EPTYPE_CONTROL          0
-#define DXEPCTL_EPTYPE_ISO              1
-#define DXEPCTL_EPTYPE_BULK             2
-#define DXEPCTL_EPTYPE_INTTERUPT        3
+#define DXEPCTL_EPTYPE_CONTROL          (0x0 << 18)
+#define DXEPCTL_EPTYPE_ISO              (0x1 << 18)
+#define DXEPCTL_EPTYPE_BULK             (0x2 << 18)
+#define DXEPCTL_EPTYPE_INTERRUPT        (0x3 << 18)
+
 #define DXEPCTL_NAKSTS                  (1 << 17)
 #define DXEPCTL_DPID                    (1 << 16)
 #define DXEPCTL_EOFRNUM                 (1 << 16)
diff --git a/drivers/usb/dwc2/platform.c b/drivers/usb/dwc2/platform.c
index eaba547ce26b..a10e7a353576 100644
--- a/drivers/usb/dwc2/platform.c
+++ b/drivers/usb/dwc2/platform.c
@@ -134,6 +134,12 @@ static int dwc2_driver_probe(struct platform_device *dev)
                 /* Default all params to autodetect */
                 dwc2_set_all_params(&defparams, -1);
                 params = &defparams;
+
+                /*
+                 * Disable descriptor dma mode by default as the HW can support
+                 * it, but does not support it for SPLIT transactions.
+                 */
+                defparams.dma_desc_enable = 0;
         }
 
         hsotg = devm_kzalloc(&dev->dev, sizeof(*hsotg), GFP_KERNEL);
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index e2c730fc9a90..8eb996e4f058 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -44,7 +44,7 @@ comment "Platform Glue Driver Support"
 
 config USB_DWC3_OMAP
         tristate "Texas Instruments OMAP5 and similar Platforms"
-        depends on EXTCON
+        depends on EXTCON && (ARCH_OMAP2PLUS || COMPILE_TEST)
         default USB_DWC3
         help
           Some platforms from Texas Instruments like OMAP5, DRA7xxx and
@@ -54,6 +54,7 @@ config USB_DWC3_OMAP
 
 config USB_DWC3_EXYNOS
         tristate "Samsung Exynos Platform"
+        depends on ARCH_EXYNOS || COMPILE_TEST
         default USB_DWC3
         help
           Recent Exynos5 SoCs ship with one DesignWare Core USB3 IP inside,
@@ -72,6 +73,7 @@ config USB_DWC3_PCI
 
 config USB_DWC3_KEYSTONE
         tristate "Texas Instruments Keystone2 Platforms"
+        depends on ARCH_KEYSTONE || COMPILE_TEST
         default USB_DWC3
         help
           Support of USB2/3 functionality in TI Keystone2 platforms.
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 10aaaae9af25..eb69eb9f06c8 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -486,70 +486,20 @@ static void dwc3_core_exit(struct dwc3 *dwc)
         phy_exit(dwc->usb3_generic_phy);
 }
 
-#define DWC3_ALIGN_MASK         (16 - 1)
-
-static int dwc3_probe(struct platform_device *pdev)
+static int dwc3_core_get_phy(struct dwc3 *dwc)
 {
-        struct device           *dev = &pdev->dev;
-        struct dwc3_platform_data *pdata = dev_get_platdata(dev);
+        struct device           *dev = dwc->dev;
         struct device_node      *node = dev->of_node;
-        struct resource         *res;
-        struct dwc3             *dwc;
-
-        int                     ret = -ENOMEM;
-
-        void __iomem            *regs;
-        void                    *mem;
-
-        mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
-        if (!mem) {
-                dev_err(dev, "not enough memory\n");
-                return -ENOMEM;
-        }
-        dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
-        dwc->mem = mem;
-
-        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!res) {
-                dev_err(dev, "missing IRQ\n");
-                return -ENODEV;
-        }
-        dwc->xhci_resources[1].start = res->start;
-        dwc->xhci_resources[1].end = res->end;
-        dwc->xhci_resources[1].flags = res->flags;
-        dwc->xhci_resources[1].name = res->name;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(dev, "missing memory resource\n");
-                return -ENODEV;
-        }
+        int ret;
 
         if (node) {
-                dwc->maximum_speed = of_usb_get_maximum_speed(node);
-
                 dwc->usb2_phy = devm_usb_get_phy_by_phandle(dev, "usb-phy", 0);
                 dwc->usb3_phy = devm_usb_get_phy_by_phandle(dev, "usb-phy", 1);
-
-                dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize");
-                dwc->dr_mode = of_usb_get_dr_mode(node);
-        } else if (pdata) {
-                dwc->maximum_speed = pdata->maximum_speed;
-
-                dwc->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
-                dwc->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
-
-                dwc->needs_fifo_resize = pdata->tx_fifo_resize;
-                dwc->dr_mode = pdata->dr_mode;
         } else {
                 dwc->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
                 dwc->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
         }
 
-        /* default to superspeed if no maximum_speed passed */
-        if (dwc->maximum_speed == USB_SPEED_UNKNOWN)
-                dwc->maximum_speed = USB_SPEED_SUPER;
-
         if (IS_ERR(dwc->usb2_phy)) {
                 ret = PTR_ERR(dwc->usb2_phy);
                 if (ret == -ENXIO || ret == -ENODEV) {
@@ -600,6 +550,132 @@ static int dwc3_probe(struct platform_device *pdev)
                 }
         }
 
+        return 0;
+}
+
+static int dwc3_core_init_mode(struct dwc3 *dwc)
+{
+        struct device *dev = dwc->dev;
+        int ret;
+
+        switch (dwc->dr_mode) {
+        case USB_DR_MODE_PERIPHERAL:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
+                ret = dwc3_gadget_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize gadget\n");
+                        return ret;
+                }
+                break;
+        case USB_DR_MODE_HOST:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
+                ret = dwc3_host_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize host\n");
+                        return ret;
+                }
+                break;
+        case USB_DR_MODE_OTG:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
+                ret = dwc3_host_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize host\n");
+                        return ret;
+                }
+
+                ret = dwc3_gadget_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize gadget\n");
+                        return ret;
+                }
+                break;
+        default:
+                dev_err(dev, "Unsupported mode of operation %d\n", dwc->dr_mode);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void dwc3_core_exit_mode(struct dwc3 *dwc)
+{
+        switch (dwc->dr_mode) {
+        case USB_DR_MODE_PERIPHERAL:
+                dwc3_gadget_exit(dwc);
+                break;
+        case USB_DR_MODE_HOST:
+                dwc3_host_exit(dwc);
+                break;
+        case USB_DR_MODE_OTG:
+                dwc3_host_exit(dwc);
+                dwc3_gadget_exit(dwc);
+                break;
+        default:
+                /* do nothing */
+                break;
+        }
+}
+
+#define DWC3_ALIGN_MASK         (16 - 1)
+
+static int dwc3_probe(struct platform_device *pdev)
+{
+        struct device           *dev = &pdev->dev;
+        struct dwc3_platform_data *pdata = dev_get_platdata(dev);
+        struct device_node      *node = dev->of_node;
+        struct resource         *res;
+        struct dwc3             *dwc;
+
+        int                     ret;
+
+        void __iomem            *regs;
+        void                    *mem;
+
+        mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
+        if (!mem) {
+                dev_err(dev, "not enough memory\n");
+                return -ENOMEM;
+        }
+        dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
+        dwc->mem = mem;
+        dwc->dev = dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(dev, "missing IRQ\n");
+                return -ENODEV;
+        }
+        dwc->xhci_resources[1].start = res->start;
+        dwc->xhci_resources[1].end = res->end;
+        dwc->xhci_resources[1].flags = res->flags;
+        dwc->xhci_resources[1].name = res->name;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "missing memory resource\n");
+                return -ENODEV;
+        }
+
+        if (node) {
+                dwc->maximum_speed = of_usb_get_maximum_speed(node);
+
+                dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize");
+                dwc->dr_mode = of_usb_get_dr_mode(node);
+        } else if (pdata) {
+                dwc->maximum_speed = pdata->maximum_speed;
+
+                dwc->needs_fifo_resize = pdata->tx_fifo_resize;
+                dwc->dr_mode = pdata->dr_mode;
+        }
+
+        /* default to superspeed if no maximum_speed passed */
+        if (dwc->maximum_speed == USB_SPEED_UNKNOWN)
+                dwc->maximum_speed = USB_SPEED_SUPER;
+
+        ret = dwc3_core_get_phy(dwc);
+        if (ret)
+                return ret;
+
         dwc->xhci_resources[0].start = res->start;
         dwc->xhci_resources[0].end = dwc->xhci_resources[0].start +
                                         DWC3_XHCI_REGS_END;
@@ -621,7 +697,6 @@ static int dwc3_probe(struct platform_device *pdev)
 
         dwc->regs       = regs;
         dwc->regs_size  = resource_size(res);
-        dwc->dev        = dev;
 
         dev->dma_mask   = dev->parent->dma_mask;
         dev->dma_parms  = dev->parent->dma_parms;
@@ -670,41 +745,9 @@ static int dwc3_probe(struct platform_device *pdev)
                 goto err_usb3phy_power;
         }
 
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
-                ret = dwc3_gadget_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize gadget\n");
-                        goto err2;
-                }
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
-                ret = dwc3_host_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize host\n");
-                        goto err2;
-                }
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
-                ret = dwc3_host_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize host\n");
-                        goto err2;
-                }
-
-                ret = dwc3_gadget_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize gadget\n");
-                        goto err2;
-                }
-                break;
-        default:
-                dev_err(dev, "Unsupported mode of operation %d\n", dwc->dr_mode);
+        ret = dwc3_core_init_mode(dwc);
+        if (ret)
                 goto err2;
-        }
 
         ret = dwc3_debugfs_init(dwc);
         if (ret) {
@@ -717,21 +760,7 @@ static int dwc3_probe(struct platform_device *pdev)
         return 0;
 
 err3:
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_gadget_exit(dwc);
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_host_exit(dwc);
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_host_exit(dwc);
-                dwc3_gadget_exit(dwc);
-                break;
-        default:
-                /* do nothing */
-                break;
-        }
+        dwc3_core_exit_mode(dwc);
 
 err2:
         dwc3_event_buffers_cleanup(dwc);
@@ -766,23 +795,7 @@ static int dwc3_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
 
         dwc3_debugfs_exit(dwc);
-
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_gadget_exit(dwc);
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_host_exit(dwc);
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_host_exit(dwc);
-                dwc3_gadget_exit(dwc);
-                break;
-        default:
-                /* do nothing */
-                break;
-        }
-
+        dwc3_core_exit_mode(dwc);
         dwc3_event_buffers_cleanup(dwc);
         dwc3_free_event_buffers(dwc);
         dwc3_core_exit(dwc);
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index 28c8ad79f5e6..f9fb8adb785b 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -24,9 +24,10 @@
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/regulator/consumer.h>
 
 struct dwc3_exynos {
         struct platform_device  *usb2_phy;
@@ -34,17 +35,19 @@ struct dwc3_exynos {
         struct device           *dev;
 
         struct clk              *clk;
+        struct regulator        *vdd33;
+        struct regulator        *vdd10;
 };
 
 static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
 {
-        struct usb_phy_gen_xceiv_platform_data pdata;
+        struct usb_phy_generic_platform_data pdata;
         struct platform_device  *pdev;
         int                     ret;
 
         memset(&pdata, 0x00, sizeof(pdata));
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", PLATFORM_DEVID_AUTO);
+        pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
         if (!pdev)
                 return -ENOMEM;
 
@@ -56,7 +59,7 @@ static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
         if (ret)
                 goto err1;
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", PLATFORM_DEVID_AUTO);
+        pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
         if (!pdev) {
                 ret = -ENOMEM;
                 goto err1;
@@ -107,12 +110,12 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
         struct device           *dev = &pdev->dev;
         struct device_node      *node = dev->of_node;
 
-        int                     ret = -ENOMEM;
+        int                     ret;
 
         exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL);
         if (!exynos) {
                 dev_err(dev, "not enough memory\n");
-                goto err1;
+                return -ENOMEM;
         }
 
         /*
@@ -122,21 +125,20 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
          */
         ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
         if (ret)
-                goto err1;
+                return ret;
 
         platform_set_drvdata(pdev, exynos);
 
         ret = dwc3_exynos_register_phys(exynos);
         if (ret) {
                 dev_err(dev, "couldn't register PHYs\n");
-                goto err1;
+                return ret;
         }
 
         clk = devm_clk_get(dev, "usbdrd30");
         if (IS_ERR(clk)) {
                 dev_err(dev, "couldn't get clock\n");
-                ret = -EINVAL;
-                goto err1;
+                return -EINVAL;
         }
 
         exynos->dev     = dev;
@@ -144,23 +146,48 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
 
         clk_prepare_enable(exynos->clk);
 
+        exynos->vdd33 = devm_regulator_get(dev, "vdd33");
+        if (IS_ERR(exynos->vdd33)) {
+                ret = PTR_ERR(exynos->vdd33);
+                goto err2;
+        }
+        ret = regulator_enable(exynos->vdd33);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD33 supply\n");
+                goto err2;
+        }
+
+        exynos->vdd10 = devm_regulator_get(dev, "vdd10");
+        if (IS_ERR(exynos->vdd10)) {
+                ret = PTR_ERR(exynos->vdd10);
+                goto err3;
+        }
+        ret = regulator_enable(exynos->vdd10);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD10 supply\n");
+                goto err3;
+        }
+
         if (node) {
                 ret = of_platform_populate(node, NULL, NULL, dev);
                 if (ret) {
                         dev_err(dev, "failed to add dwc3 core\n");
-                        goto err2;
+                        goto err4;
                 }
         } else {
                 dev_err(dev, "no device node, failed to add dwc3 core\n");
                 ret = -ENODEV;
-                goto err2;
+                goto err4;
         }
 
         return 0;
 
+err4:
+        regulator_disable(exynos->vdd10);
+err3:
+        regulator_disable(exynos->vdd33);
 err2:
         clk_disable_unprepare(clk);
-err1:
         return ret;
 }
 
@@ -174,6 +201,9 @@ static int dwc3_exynos_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(exynos->clk);
 
+        regulator_disable(exynos->vdd33);
+        regulator_disable(exynos->vdd10);
+
         return 0;
 }
 
@@ -192,12 +222,27 @@ static int dwc3_exynos_suspend(struct device *dev)
 
         clk_disable(exynos->clk);
 
+        regulator_disable(exynos->vdd33);
+        regulator_disable(exynos->vdd10);
+
         return 0;
 }
 
 static int dwc3_exynos_resume(struct device *dev)
 {
         struct dwc3_exynos *exynos = dev_get_drvdata(dev);
+        int ret;
+
+        ret = regulator_enable(exynos->vdd33);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD33 supply\n");
+                return ret;
+        }
+        ret = regulator_enable(exynos->vdd10);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD10 supply\n");
+                return ret;
+        }
 
         clk_enable(exynos->clk);
 
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 1160ff41bed4..4af4c3567656 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -393,7 +393,7 @@ static int dwc3_omap_probe(struct platform_device *pdev)
         struct extcon_dev       *edev;
         struct regulator        *vbus_reg = NULL;
 
-        int                     ret = -ENOMEM;
+        int                     ret;
         int                     irq;
 
         int                     utmi_mode = 0;
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index f393c183cc69..a60bab7dfa0a 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -23,7 +23,7 @@
 #include <linux/platform_device.h>
 
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 /* FIXME define these in <linux/pci_ids.h> */
 #define PCI_VENDOR_ID_SYNOPSYS          0x16c3
@@ -40,13 +40,13 @@ struct dwc3_pci {
 
 static int dwc3_pci_register_phys(struct dwc3_pci *glue)
 {
-        struct usb_phy_gen_xceiv_platform_data pdata;
+        struct usb_phy_generic_platform_data pdata;
         struct platform_device  *pdev;
         int                     ret;
 
         memset(&pdata, 0x00, sizeof(pdata));
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", 0);
+        pdev = platform_device_alloc("usb_phy_generic", 0);
         if (!pdev)
                 return -ENOMEM;
 
@@ -58,7 +58,7 @@ static int dwc3_pci_register_phys(struct dwc3_pci *glue)
         if (ret)
                 goto err1;
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", 1);
+        pdev = platform_device_alloc("usb_phy_generic", 1);
         if (!pdev) {
                 ret = -ENOMEM;
                 goto err1;
@@ -99,7 +99,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         struct resource         res[2];
         struct platform_device  *dwc3;
         struct dwc3_pci         *glue;
-        int                     ret = -ENOMEM;
+        int                     ret;
         struct device           *dev = &pci->dev;
 
         glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
@@ -110,7 +110,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
 
         glue->dev = dev;
 
-        ret = pci_enable_device(pci);
+        ret = pcim_enable_device(pci);
         if (ret) {
                 dev_err(dev, "failed to enable pci device\n");
                 return -ENODEV;
@@ -127,8 +127,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO);
         if (!dwc3) {
                 dev_err(dev, "couldn't allocate dwc3 device\n");
-                ret = -ENOMEM;
-                goto err1;
+                return -ENOMEM;
         }
 
         memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
@@ -145,7 +144,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
         if (ret) {
                 dev_err(dev, "couldn't add resources to dwc3 device\n");
-                goto err1;
+                return ret;
         }
 
         pci_set_drvdata(pci, glue);
@@ -167,9 +166,6 @@ static int dwc3_pci_probe(struct pci_dev *pci,
 
 err3:
         platform_device_put(dwc3);
-err1:
-        pci_disable_device(pci);
-
         return ret;
 }
 
@@ -180,7 +176,6 @@ static void dwc3_pci_remove(struct pci_dev *pci)
         platform_device_unregister(glue->dwc3);
         platform_device_unregister(glue->usb2_phy);
         platform_device_unregister(glue->usb3_phy);
-        pci_disable_device(pci);
 }
 
 static const struct pci_device_id dwc3_pci_id_table[] = {
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 70715eeededd..9d64dd02c57e 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -298,11 +298,76 @@ static const char *dwc3_gadget_ep_cmd_string(u8 cmd)
         }
 }
 
+static const char *dwc3_gadget_generic_cmd_string(u8 cmd)
+{
+        switch (cmd) {
+        case DWC3_DGCMD_SET_LMP:
+                return "Set LMP";
+        case DWC3_DGCMD_SET_PERIODIC_PAR:
+                return "Set Periodic Parameters";
+        case DWC3_DGCMD_XMIT_FUNCTION:
+                return "Transmit Function Wake Device Notification";
+        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
+                return "Set Scratchpad Buffer Array Address Lo";
+        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
+                return "Set Scratchpad Buffer Array Address Hi";
+        case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
+                return "Selected FIFO Flush";
+        case DWC3_DGCMD_ALL_FIFO_FLUSH:
+                return "All FIFO Flush";
+        case DWC3_DGCMD_SET_ENDPOINT_NRDY:
+                return "Set Endpoint NRDY";
+        case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
+                return "Run SoC Bus Loopback Test";
+        default:
+                return "UNKNOWN";
+        }
+}
+
+static const char *dwc3_gadget_link_string(enum dwc3_link_state link_state)
+{
+        switch (link_state) {
+        case DWC3_LINK_STATE_U0:
+                return "U0";
+        case DWC3_LINK_STATE_U1:
+                return "U1";
+        case DWC3_LINK_STATE_U2:
+                return "U2";
+        case DWC3_LINK_STATE_U3:
+                return "U3";
+        case DWC3_LINK_STATE_SS_DIS:
+                return "SS.Disabled";
+        case DWC3_LINK_STATE_RX_DET:
+                return "RX.Detect";
+        case DWC3_LINK_STATE_SS_INACT:
+                return "SS.Inactive";
+        case DWC3_LINK_STATE_POLL:
+                return "Polling";
+        case DWC3_LINK_STATE_RECOV:
+                return "Recovery";
+        case DWC3_LINK_STATE_HRESET:
+                return "Hot Reset";
+        case DWC3_LINK_STATE_CMPLY:
+                return "Compliance";
+        case DWC3_LINK_STATE_LPBK:
+                return "Loopback";
+        case DWC3_LINK_STATE_RESET:
+                return "Reset";
+        case DWC3_LINK_STATE_RESUME:
+                return "Resume";
+        default:
+                return "UNKNOWN link state\n";
+        }
+}
+
 int dwc3_send_gadget_generic_command(struct dwc3 *dwc, int cmd, u32 param)
 {
         u32             timeout = 500;
         u32             reg;
 
+        dev_vdbg(dwc->dev, "generic cmd '%s' [%d] param %08x\n",
+                        dwc3_gadget_generic_cmd_string(cmd), cmd, param);
+
         dwc3_writel(dwc->regs, DWC3_DGCMDPAR, param);
         dwc3_writel(dwc->regs, DWC3_DGCMD, cmd | DWC3_DGCMD_CMDACT);
 
@@ -332,9 +397,9 @@ int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep,
         u32                     timeout = 500;
         u32                     reg;
 
-        dev_vdbg(dwc->dev, "%s: cmd '%s' params %08x %08x %08x\n",
+        dev_vdbg(dwc->dev, "%s: cmd '%s' [%d] params %08x %08x %08x\n",
                         dep->name,
-                        dwc3_gadget_ep_cmd_string(cmd), params->param0,
+                        dwc3_gadget_ep_cmd_string(cmd), cmd, params->param0,
                         params->param1, params->param2);
 
         dwc3_writel(dwc->regs, DWC3_DEPCMDPAR0(ep), params->param0);
@@ -515,7 +580,7 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
 {
         struct dwc3             *dwc = dep->dwc;
         u32                     reg;
-        int                     ret = -ENOMEM;
+        int                     ret;
 
         dev_vdbg(dwc->dev, "Enabling %s\n", dep->name);
 
@@ -604,6 +669,10 @@ static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep)
 
         dwc3_remove_requests(dwc, dep);
 
+        /* make sure HW endpoint isn't stalled */
+        if (dep->flags & DWC3_EP_STALL)
+                __dwc3_gadget_ep_set_halt(dep, 0);
+
         reg = dwc3_readl(dwc->regs, DWC3_DALEPENA);
         reg &= ~DWC3_DALEPENA_EP(dep->number);
         dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
@@ -2441,8 +2510,6 @@ static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
                 }
         }
 
-        dwc->link_state = next;
-
         switch (next) {
         case DWC3_LINK_STATE_U1:
                 if (dwc->speed == USB_SPEED_SUPER)
@@ -2460,7 +2527,11 @@ static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
                 break;
         }
 
-        dev_vdbg(dwc->dev, "%s link %d\n", __func__, dwc->link_state);
+        dev_vdbg(dwc->dev, "link change: %s [%d] -> %s [%d]\n",
+                        dwc3_gadget_link_string(dwc->link_state),
+                        dwc->link_state, dwc3_gadget_link_string(next), next);
+
+        dwc->link_state = next;
 }
 
 static void dwc3_gadget_hibernation_interrupt(struct dwc3 *dwc,
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 3557c7e5040d..ba18e9c110cc 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -157,7 +157,7 @@ config USB_AT91
 
 config USB_LPC32XX
         tristate "LPC32XX USB Peripheral Controller"
-        depends on ARCH_LPC32XX
+        depends on ARCH_LPC32XX && I2C
         select USB_ISP1301
         help
            This option selects the USB device controller in the LPC32xx SoC.
@@ -226,7 +226,7 @@ config USB_GR_UDC
 config USB_OMAP
         tristate "OMAP USB Device Controller"
         depends on ARCH_OMAP1
-        select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
+        depends on ISP1301_OMAP || !(MACH_OMAP_H2 || MACH_OMAP_H3)
         help
            Many Texas Instruments OMAP processors have flexible full
            speed USB device controllers, with support for up to 30
@@ -300,12 +300,6 @@ config USB_PXA27X
            dynamically linked module called "pxa27x_udc" and force all
            gadget drivers to also be dynamically linked.
 
-config USB_S3C_HSOTG
-        tristate "Designware/S3C HS/OtG USB Device controller"
-        help
-          The Designware USB2.0 high-speed gadget controller
-          integrated into many SoCs.
-
 config USB_S3C2410
         tristate "S3C2410 USB Device Controller"
         depends on ARCH_S3C24XX
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 5f150bc1b4bc..49514ea60a98 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -26,7 +26,6 @@ fsl_usb2_udc-$(CONFIG_ARCH_MXC)	+= fsl_mxc_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_R8A66597)      += r8a66597-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
-obj-$(CONFIG_USB_S3C_HSOTG)     += s3c-hsotg.o
 obj-$(CONFIG_USB_S3C_HSUDC)     += s3c-hsudc.o
 obj-$(CONFIG_USB_LPC32XX)       += lpc32xx_udc.o
 obj-$(CONFIG_USB_EG20T)         += pch_udc.o
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 9f65324f9ae0..76023ce449a3 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1686,7 +1686,7 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
                 reset_all_endpoints(udc);
 
                 if (udc->gadget.speed != USB_SPEED_UNKNOWN
-                                && udc->driver->disconnect) {
+                                && udc->driver && udc->driver->disconnect) {
                         udc->gadget.speed = USB_SPEED_UNKNOWN;
                         spin_unlock(&udc->lock);
                         udc->driver->disconnect(&udc->gadget);
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index fab906429b80..f80151932053 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -21,6 +21,24 @@
 #include <linux/usb/composite.h>
 #include <asm/unaligned.h>
 
+#include "u_os_desc.h"
+
+/**
+ * struct usb_os_string - represents OS String to be reported by a gadget
+ * @bLength: total length of the entire descritor, always 0x12
+ * @bDescriptorType: USB_DT_STRING
+ * @qwSignature: the OS String proper
+ * @bMS_VendorCode: code used by the host for subsequent requests
+ * @bPad: not used, must be zero
+ */
+struct usb_os_string {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    qwSignature[OS_STRING_QW_SIGN_LEN];
+        __u8    bMS_VendorCode;
+        __u8    bPad;
+} __packed;
+
 /*
  * The code in this file is utility code, used to build a gadget driver
  * from one or more "function" drivers, one or more "configuration"
@@ -422,6 +440,7 @@ static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 {
         struct usb_gadget               *gadget = cdev->gadget;
         struct usb_configuration        *c;
+        struct list_head                *pos;
         u8                              type = w_value >> 8;
         enum usb_device_speed           speed = USB_SPEED_UNKNOWN;
 
@@ -440,7 +459,20 @@ static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 
         /* This is a lookup by config *INDEX* */
         w_value &= 0xff;
-        list_for_each_entry(c, &cdev->configs, list) {
+
+        pos = &cdev->configs;
+        c = cdev->os_desc_config;
+        if (c)
+                goto check_config;
+
+        while ((pos = pos->next) !=  &cdev->configs) {
+                c = list_entry(pos, typeof(*c), list);
+
+                /* skip OS Descriptors config which is handled separately */
+                if (c == cdev->os_desc_config)
+                        continue;
+
+check_config:
                 /* ignore configs that won't work at this speed */
                 switch (speed) {
                 case USB_SPEED_SUPER:
@@ -634,6 +666,7 @@ static int set_config(struct usb_composite_dev *cdev,
         if (!c)
                 goto done;
 
+        usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
         cdev->config = c;
 
         /* Initialize all interfaces by setting them to altsetting zero. */
@@ -960,6 +993,19 @@ static int get_string(struct usb_composite_dev *cdev,
                 return s->bLength;
         }
 
+        if (cdev->use_os_string && language == 0 && id == OS_STRING_IDX) {
+                struct usb_os_string *b = buf;
+                b->bLength = sizeof(*b);
+                b->bDescriptorType = USB_DT_STRING;
+                compiletime_assert(
+                        sizeof(b->qwSignature) == sizeof(cdev->qw_sign),
+                        "qwSignature size must be equal to qw_sign");
+                memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
+                b->bMS_VendorCode = cdev->b_vendor_code;
+                b->bPad = 0;
+                return sizeof(*b);
+        }
+
         list_for_each_entry(uc, &cdev->gstrings, list) {
                 struct usb_gadget_strings **sp;
 
@@ -1206,6 +1252,156 @@ static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
                                 req->status, req->actual, req->length);
 }
 
+static int count_ext_compat(struct usb_configuration *c)
+{
+        int i, res;
+
+        res = 0;
+        for (i = 0; i < c->next_interface_id; ++i) {
+                struct usb_function *f;
+                int j;
+
+                f = c->interface[i];
+                for (j = 0; j < f->os_desc_n; ++j) {
+                        struct usb_os_desc *d;
+
+                        if (i != f->os_desc_table[j].if_id)
+                                continue;
+                        d = f->os_desc_table[j].os_desc;
+                        if (d && d->ext_compat_id)
+                                ++res;
+                }
+        }
+        BUG_ON(res > 255);
+        return res;
+}
+
+static void fill_ext_compat(struct usb_configuration *c, u8 *buf)
+{
+        int i, count;
+
+        count = 16;
+        for (i = 0; i < c->next_interface_id; ++i) {
+                struct usb_function *f;
+                int j;
+
+                f = c->interface[i];
+                for (j = 0; j < f->os_desc_n; ++j) {
+                        struct usb_os_desc *d;
+
+                        if (i != f->os_desc_table[j].if_id)
+                                continue;
+                        d = f->os_desc_table[j].os_desc;
+                        if (d && d->ext_compat_id) {
+                                *buf++ = i;
+                                *buf++ = 0x01;
+                                memcpy(buf, d->ext_compat_id, 16);
+                                buf += 22;
+                        } else {
+                                ++buf;
+                                *buf = 0x01;
+                                buf += 23;
+                        }
+                        count += 24;
+                        if (count >= 4096)
+                                return;
+                }
+        }
+}
+
+static int count_ext_prop(struct usb_configuration *c, int interface)
+{
+        struct usb_function *f;
+        int j;
+
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                struct usb_os_desc *d;
+
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d && d->ext_compat_id)
+                        return d->ext_prop_count;
+        }
+        return 0;
+}
+
+static int len_ext_prop(struct usb_configuration *c, int interface)
+{
+        struct usb_function *f;
+        struct usb_os_desc *d;
+        int j, res;
+
+        res = 10; /* header length */
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d)
+                        return min(res + d->ext_prop_len, 4096);
+        }
+        return res;
+}
+
+static int fill_ext_prop(struct usb_configuration *c, int interface, u8 *buf)
+{
+        struct usb_function *f;
+        struct usb_os_desc *d;
+        struct usb_os_desc_ext_prop *ext_prop;
+        int j, count, n, ret;
+        u8 *start = buf;
+
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d)
+                        list_for_each_entry(ext_prop, &d->ext_prop, entry) {
+                                /* 4kB minus header length */
+                                n = buf - start;
+                                if (n >= 4086)
+                                        return 0;
+
+                                count = ext_prop->data_len +
+                                        ext_prop->name_len + 14;
+                                if (count > 4086 - n)
+                                        return -EINVAL;
+                                usb_ext_prop_put_size(buf, count);
+                                usb_ext_prop_put_type(buf, ext_prop->type);
+                                ret = usb_ext_prop_put_name(buf, ext_prop->name,
+                                                            ext_prop->name_len);
+                                if (ret < 0)
+                                        return ret;
+                                switch (ext_prop->type) {
+                                case USB_EXT_PROP_UNICODE:
+                                case USB_EXT_PROP_UNICODE_ENV:
+                                case USB_EXT_PROP_UNICODE_LINK:
+                                        usb_ext_prop_put_unicode(buf, ret,
+                                                         ext_prop->data,
+                                                         ext_prop->data_len);
+                                        break;
+                                case USB_EXT_PROP_BINARY:
+                                        usb_ext_prop_put_binary(buf, ret,
+                                                        ext_prop->data,
+                                                        ext_prop->data_len);
+                                        break;
+                                case USB_EXT_PROP_LE32:
+                                        /* not implemented */
+                                case USB_EXT_PROP_BE32:
+                                        /* not implemented */
+                                default:
+                                        return -EINVAL;
+                                }
+                                buf += count;
+                        }
+        }
+
+        return 0;
+}
+
 /*
  * The setup() callback implements all the ep0 functionality that's
  * not handled lower down, in hardware or the hardware driver(like
@@ -1415,6 +1611,91 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 break;
         default:
 unknown:
+                /*
+                 * OS descriptors handling
+                 */
+                if (cdev->use_os_string && cdev->os_desc_config &&
+                    (ctrl->bRequest & USB_TYPE_VENDOR) &&
+                    ctrl->bRequest == cdev->b_vendor_code) {
+                        struct usb_request              *req;
+                        struct usb_configuration        *os_desc_cfg;
+                        u8                              *buf;
+                        int                             interface;
+                        int                             count = 0;
+
+                        req = cdev->os_desc_req;
+                        req->complete = composite_setup_complete;
+                        buf = req->buf;
+                        os_desc_cfg = cdev->os_desc_config;
+                        memset(buf, 0, w_length);
+                        buf[5] = 0x01;
+                        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+                        case USB_RECIP_DEVICE:
+                                if (w_index != 0x4 || (w_value >> 8))
+                                        break;
+                                buf[6] = w_index;
+                                if (w_length == 0x10) {
+                                        /* Number of ext compat interfaces */
+                                        count = count_ext_compat(os_desc_cfg);
+                                        buf[8] = count;
+                                        count *= 24; /* 24 B/ext compat desc */
+                                        count += 16; /* header */
+                                        put_unaligned_le32(count, buf);
+                                        value = w_length;
+                                } else {
+                                        /* "extended compatibility ID"s */
+                                        count = count_ext_compat(os_desc_cfg);
+                                        buf[8] = count;
+                                        count *= 24; /* 24 B/ext compat desc */
+                                        count += 16; /* header */
+                                        put_unaligned_le32(count, buf);
+                                        buf += 16;
+                                        fill_ext_compat(os_desc_cfg, buf);
+                                        value = w_length;
+                                }
+                                break;
+                        case USB_RECIP_INTERFACE:
+                                if (w_index != 0x5 || (w_value >> 8))
+                                        break;
+                                interface = w_value & 0xFF;
+                                buf[6] = w_index;
+                                if (w_length == 0x0A) {
+                                        count = count_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le16(count, buf + 8);
+                                        count = len_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le32(count, buf);
+
+                                        value = w_length;
+                                } else {
+                                        count = count_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le16(count, buf + 8);
+                                        count = len_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le32(count, buf);
+                                        buf += 10;
+                                        value = fill_ext_prop(os_desc_cfg,
+                                                              interface, buf);
+                                        if (value < 0)
+                                                return value;
+
+                                        value = w_length;
+                                }
+                                break;
+                        }
+                        req->length = value;
+                        req->zero = value < w_length;
+                        value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+                        if (value < 0) {
+                                DBG(cdev, "ep_queue --> %d\n", value);
+                                req->status = 0;
+                                composite_setup_complete(gadget->ep0, req);
+                        }
+                        return value;
+                }
+
                 VDBG(cdev,
                         "non-core control req%02x.%02x v%04x i%04x l%d\n",
                         ctrl->bRequestType, ctrl->bRequest,
@@ -1638,6 +1919,29 @@ fail:
         return ret;
 }
 
+int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
+                                  struct usb_ep *ep0)
+{
+        int ret = 0;
+
+        cdev->os_desc_req = usb_ep_alloc_request(ep0, GFP_KERNEL);
+        if (!cdev->os_desc_req) {
+                ret = PTR_ERR(cdev->os_desc_req);
+                goto end;
+        }
+
+        /* OS feature descriptor length <= 4kB */
+        cdev->os_desc_req->buf = kmalloc(4096, GFP_KERNEL);
+        if (!cdev->os_desc_req->buf) {
+                ret = PTR_ERR(cdev->os_desc_req->buf);
+                kfree(cdev->os_desc_req);
+                goto end;
+        }
+        cdev->os_desc_req->complete = composite_setup_complete;
+end:
+        return ret;
+}
+
 void composite_dev_cleanup(struct usb_composite_dev *cdev)
 {
         struct usb_gadget_string_container *uc, *tmp;
@@ -1646,6 +1950,10 @@ void composite_dev_cleanup(struct usb_composite_dev *cdev)
                 list_del(&uc->list);
                 kfree(uc);
         }
+        if (cdev->os_desc_req) {
+                kfree(cdev->os_desc_req->buf);
+                usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
+        }
         if (cdev->req) {
                 kfree(cdev->req->buf);
                 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
@@ -1683,6 +1991,12 @@ static int composite_bind(struct usb_gadget *gadget,
         if (status < 0)
                 goto fail;
 
+        if (cdev->use_os_string) {
+                status = composite_os_desc_req_prepare(cdev, gadget->ep0);
+                if (status)
+                        goto fail;
+        }
+
         update_unchanged_dev_desc(&cdev->desc, composite->dev);
 
         /* has userspace failed to provide a serial number? */
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
index 7d1cc01796b6..2ddcd635ca2a 100644
--- a/drivers/usb/gadget/configfs.c
+++ b/drivers/usb/gadget/configfs.c
@@ -2,9 +2,12 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/device.h>
+#include <linux/nls.h>
 #include <linux/usb/composite.h>
 #include <linux/usb/gadget_configfs.h>
 #include "configfs.h"
+#include "u_f.h"
+#include "u_os_desc.h"
 
 int check_user_usb_string(const char *name,
                 struct usb_gadget_strings *stringtab_dev)
@@ -43,7 +46,8 @@ struct gadget_info {
         struct config_group functions_group;
         struct config_group configs_group;
         struct config_group strings_group;
-        struct config_group *default_groups[4];
+        struct config_group os_desc_group;
+        struct config_group *default_groups[5];
 
         struct mutex lock;
         struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
@@ -56,6 +60,9 @@ struct gadget_info {
 #endif
         struct usb_composite_driver composite;
         struct usb_composite_dev cdev;
+        bool use_os_desc;
+        char b_vendor_code;
+        char qw_sign[OS_STRING_QW_SIGN_LEN];
 };
 
 struct config_usb_cfg {
@@ -79,6 +86,10 @@ struct gadget_strings {
         struct list_head list;
 };
 
+struct os_desc {
+        struct config_group group;
+};
+
 struct gadget_config_name {
         struct usb_gadget_strings stringtab_dev;
         struct usb_string strings;
@@ -736,6 +747,525 @@ static void gadget_strings_attr_release(struct config_item *item)
 USB_CONFIG_STRING_RW_OPS(gadget_strings);
 USB_CONFIG_STRINGS_LANG(gadget_strings, gadget_info);
 
+static inline struct os_desc *to_os_desc(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct os_desc, group);
+}
+
+CONFIGFS_ATTR_STRUCT(os_desc);
+CONFIGFS_ATTR_OPS(os_desc);
+
+static ssize_t os_desc_use_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        return sprintf(page, "%d", gi->use_os_desc);
+}
+
+static ssize_t os_desc_use_store(struct os_desc *os_desc, const char *page,
+                                 size_t len)
+{
+        struct gadget_info *gi;
+        int ret;
+        bool use;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        mutex_lock(&gi->lock);
+        ret = strtobool(page, &use);
+        if (!ret) {
+                gi->use_os_desc = use;
+                ret = len;
+        }
+        mutex_unlock(&gi->lock);
+
+        return ret;
+}
+
+static struct os_desc_attribute os_desc_use =
+        __CONFIGFS_ATTR(use, S_IRUGO | S_IWUSR,
+                        os_desc_use_show,
+                        os_desc_use_store);
+
+static ssize_t os_desc_b_vendor_code_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        return sprintf(page, "%d", gi->b_vendor_code);
+}
+
+static ssize_t os_desc_b_vendor_code_store(struct os_desc *os_desc,
+                                           const char *page, size_t len)
+{
+        struct gadget_info *gi;
+        int ret;
+        u8 b_vendor_code;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        mutex_lock(&gi->lock);
+        ret = kstrtou8(page, 0, &b_vendor_code);
+        if (!ret) {
+                gi->b_vendor_code = b_vendor_code;
+                ret = len;
+        }
+        mutex_unlock(&gi->lock);
+
+        return ret;
+}
+
+static struct os_desc_attribute os_desc_b_vendor_code =
+        __CONFIGFS_ATTR(b_vendor_code, S_IRUGO | S_IWUSR,
+                        os_desc_b_vendor_code_show,
+                        os_desc_b_vendor_code_store);
+
+static ssize_t os_desc_qw_sign_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        memcpy(page, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
+
+        return OS_STRING_QW_SIGN_LEN;
+}
+
+static ssize_t os_desc_qw_sign_store(struct os_desc *os_desc, const char *page,
+                                     size_t len)
+{
+        struct gadget_info *gi;
+        int res, l;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+        l = min((int)len, OS_STRING_QW_SIGN_LEN >> 1);
+        if (page[l - 1] == '\n')
+                --l;
+
+        mutex_lock(&gi->lock);
+        res = utf8s_to_utf16s(page, l,
+                              UTF16_LITTLE_ENDIAN, (wchar_t *) gi->qw_sign,
+                              OS_STRING_QW_SIGN_LEN);
+        if (res > 0)
+                res = len;
+        mutex_unlock(&gi->lock);
+
+        return res;
+}
+
+static struct os_desc_attribute os_desc_qw_sign =
+        __CONFIGFS_ATTR(qw_sign, S_IRUGO | S_IWUSR,
+                        os_desc_qw_sign_show,
+                        os_desc_qw_sign_store);
+
+static struct configfs_attribute *os_desc_attrs[] = {
+        &os_desc_use.attr,
+        &os_desc_b_vendor_code.attr,
+        &os_desc_qw_sign.attr,
+        NULL,
+};
+
+static void os_desc_attr_release(struct config_item *item)
+{
+        struct os_desc *os_desc = to_os_desc(item);
+        kfree(os_desc);
+}
+
+static int os_desc_link(struct config_item *os_desc_ci,
+                        struct config_item *usb_cfg_ci)
+{
+        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
+                                        struct gadget_info, os_desc_group);
+        struct usb_composite_dev *cdev = &gi->cdev;
+        struct config_usb_cfg *c_target =
+                container_of(to_config_group(usb_cfg_ci),
+                             struct config_usb_cfg, group);
+        struct usb_configuration *c;
+        int ret;
+
+        mutex_lock(&gi->lock);
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c == &c_target->c)
+                        break;
+        }
+        if (c != &c_target->c) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (cdev->os_desc_config) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        cdev->os_desc_config = &c_target->c;
+        ret = 0;
+
+out:
+        mutex_unlock(&gi->lock);
+        return ret;
+}
+
+static int os_desc_unlink(struct config_item *os_desc_ci,
+                          struct config_item *usb_cfg_ci)
+{
+        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
+                                        struct gadget_info, os_desc_group);
+        struct usb_composite_dev *cdev = &gi->cdev;
+
+        mutex_lock(&gi->lock);
+        if (gi->udc_name)
+                unregister_gadget(gi);
+        cdev->os_desc_config = NULL;
+        WARN_ON(gi->udc_name);
+        mutex_unlock(&gi->lock);
+        return 0;
+}
+
+static struct configfs_item_operations os_desc_ops = {
+        .release                = os_desc_attr_release,
+        .show_attribute         = os_desc_attr_show,
+        .store_attribute        = os_desc_attr_store,
+        .allow_link             = os_desc_link,
+        .drop_link              = os_desc_unlink,
+};
+
+static struct config_item_type os_desc_type = {
+        .ct_item_ops    = &os_desc_ops,
+        .ct_attrs       = os_desc_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+CONFIGFS_ATTR_STRUCT(usb_os_desc);
+CONFIGFS_ATTR_OPS(usb_os_desc);
+
+
+static inline struct usb_os_desc_ext_prop
+*to_usb_os_desc_ext_prop(struct config_item *item)
+{
+        return container_of(item, struct usb_os_desc_ext_prop, item);
+}
+
+CONFIGFS_ATTR_STRUCT(usb_os_desc_ext_prop);
+CONFIGFS_ATTR_OPS(usb_os_desc_ext_prop);
+
+static ssize_t ext_prop_type_show(struct usb_os_desc_ext_prop *ext_prop,
+                                  char *page)
+{
+        return sprintf(page, "%d", ext_prop->type);
+}
+
+static ssize_t ext_prop_type_store(struct usb_os_desc_ext_prop *ext_prop,
+                                   const char *page, size_t len)
+{
+        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
+        u8 type;
+        int ret;
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        ret = kstrtou8(page, 0, &type);
+        if (ret)
+                goto end;
+        if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        if ((ext_prop->type == USB_EXT_PROP_BINARY ||
+            ext_prop->type == USB_EXT_PROP_LE32 ||
+            ext_prop->type == USB_EXT_PROP_BE32) &&
+            (type == USB_EXT_PROP_UNICODE ||
+            type == USB_EXT_PROP_UNICODE_ENV ||
+            type == USB_EXT_PROP_UNICODE_LINK))
+                ext_prop->data_len <<= 1;
+        else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
+                   ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+                   ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
+                   (type == USB_EXT_PROP_BINARY ||
+                   type == USB_EXT_PROP_LE32 ||
+                   type == USB_EXT_PROP_BE32))
+                ext_prop->data_len >>= 1;
+        ext_prop->type = type;
+        ret = len;
+
+end:
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        return ret;
+}
+
+static ssize_t ext_prop_data_show(struct usb_os_desc_ext_prop *ext_prop,
+                                  char *page)
+{
+        int len = ext_prop->data_len;
+
+        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
+                len >>= 1;
+        memcpy(page, ext_prop->data, len);
+
+        return len;
+}
+
+static ssize_t ext_prop_data_store(struct usb_os_desc_ext_prop *ext_prop,
+                                   const char *page, size_t len)
+{
+        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
+        char *new_data;
+        size_t ret_len = len;
+
+        if (page[len - 1] == '\n' || page[len - 1] == '\0')
+                --len;
+        new_data = kzalloc(len, GFP_KERNEL);
+        if (!new_data)
+                return -ENOMEM;
+
+        memcpy(new_data, page, len);
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        kfree(ext_prop->data);
+        ext_prop->data = new_data;
+        desc->ext_prop_len -= ext_prop->data_len;
+        ext_prop->data_len = len;
+        desc->ext_prop_len += ext_prop->data_len;
+        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
+                desc->ext_prop_len -= ext_prop->data_len;
+                ext_prop->data_len <<= 1;
+                ext_prop->data_len += 2;
+                desc->ext_prop_len += ext_prop->data_len;
+        }
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        return ret_len;
+}
+
+static struct usb_os_desc_ext_prop_attribute ext_prop_type =
+        __CONFIGFS_ATTR(type, S_IRUGO | S_IWUSR,
+                        ext_prop_type_show, ext_prop_type_store);
+
+static struct usb_os_desc_ext_prop_attribute ext_prop_data =
+        __CONFIGFS_ATTR(data, S_IRUGO | S_IWUSR,
+                        ext_prop_data_show, ext_prop_data_store);
+
+static struct configfs_attribute *ext_prop_attrs[] = {
+        &ext_prop_type.attr,
+        &ext_prop_data.attr,
+        NULL,
+};
+
+static void usb_os_desc_ext_prop_release(struct config_item *item)
+{
+        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
+
+        kfree(ext_prop); /* frees a whole chunk */
+}
+
+static struct configfs_item_operations ext_prop_ops = {
+        .release                = usb_os_desc_ext_prop_release,
+        .show_attribute         = usb_os_desc_ext_prop_attr_show,
+        .store_attribute        = usb_os_desc_ext_prop_attr_store,
+};
+
+static struct config_item *ext_prop_make(
+                struct config_group *group,
+                const char *name)
+{
+        struct usb_os_desc_ext_prop *ext_prop;
+        struct config_item_type *ext_prop_type;
+        struct usb_os_desc *desc;
+        char *vlabuf;
+
+        vla_group(data_chunk);
+        vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
+        vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);
+
+        vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
+        if (!vlabuf)
+                return ERR_PTR(-ENOMEM);
+
+        ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
+        ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);
+
+        desc = container_of(group, struct usb_os_desc, group);
+        ext_prop_type->ct_item_ops = &ext_prop_ops;
+        ext_prop_type->ct_attrs = ext_prop_attrs;
+        ext_prop_type->ct_owner = desc->owner;
+
+        config_item_init_type_name(&ext_prop->item, name, ext_prop_type);
+
+        ext_prop->name = kstrdup(name, GFP_KERNEL);
+        if (!ext_prop->name) {
+                kfree(vlabuf);
+                return ERR_PTR(-ENOMEM);
+        }
+        desc->ext_prop_len += 14;
+        ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        desc->ext_prop_len += ext_prop->name_len;
+        list_add_tail(&ext_prop->entry, &desc->ext_prop);
+        ++desc->ext_prop_count;
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return &ext_prop->item;
+}
+
+static void ext_prop_drop(struct config_group *group, struct config_item *item)
+{
+        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
+        struct usb_os_desc *desc = to_usb_os_desc(&group->cg_item);
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        list_del(&ext_prop->entry);
+        --desc->ext_prop_count;
+        kfree(ext_prop->name);
+        desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        config_item_put(item);
+}
+
+static struct configfs_group_operations interf_grp_ops = {
+        .make_item      = &ext_prop_make,
+        .drop_item      = &ext_prop_drop,
+};
+
+static struct configfs_item_operations interf_item_ops = {
+        .show_attribute         = usb_os_desc_attr_show,
+        .store_attribute        = usb_os_desc_attr_store,
+};
+
+static ssize_t rndis_grp_compatible_id_show(struct usb_os_desc *desc,
+                                            char *page)
+{
+        memcpy(page, desc->ext_compat_id, 8);
+        return 8;
+}
+
+static ssize_t rndis_grp_compatible_id_store(struct usb_os_desc *desc,
+                                             const char *page, size_t len)
+{
+        int l;
+
+        l = min_t(int, 8, len);
+        if (page[l - 1] == '\n')
+                --l;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        memcpy(desc->ext_compat_id, page, l);
+        desc->ext_compat_id[l] = '\0';
+
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return len;
+}
+
+static struct usb_os_desc_attribute rndis_grp_attr_compatible_id =
+        __CONFIGFS_ATTR(compatible_id, S_IRUGO | S_IWUSR,
+                        rndis_grp_compatible_id_show,
+                        rndis_grp_compatible_id_store);
+
+static ssize_t rndis_grp_sub_compatible_id_show(struct usb_os_desc *desc,
+                                                char *page)
+{
+        memcpy(page, desc->ext_compat_id + 8, 8);
+        return 8;
+}
+
+static ssize_t rndis_grp_sub_compatible_id_store(struct usb_os_desc *desc,
+                                                 const char *page, size_t len)
+{
+        int l;
+
+        l = min_t(int, 8, len);
+        if (page[l - 1] == '\n')
+                --l;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        memcpy(desc->ext_compat_id + 8, page, l);
+        desc->ext_compat_id[l + 8] = '\0';
+
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return len;
+}
+
+static struct usb_os_desc_attribute rndis_grp_attr_sub_compatible_id =
+        __CONFIGFS_ATTR(sub_compatible_id, S_IRUGO | S_IWUSR,
+                        rndis_grp_sub_compatible_id_show,
+                        rndis_grp_sub_compatible_id_store);
+
+static struct configfs_attribute *interf_grp_attrs[] = {
+        &rndis_grp_attr_compatible_id.attr,
+        &rndis_grp_attr_sub_compatible_id.attr,
+        NULL
+};
+
+int usb_os_desc_prepare_interf_dir(struct config_group *parent,
+                                   int n_interf,
+                                   struct usb_os_desc **desc,
+                                   struct module *owner)
+{
+        struct config_group **f_default_groups, *os_desc_group,
+                                **interface_groups;
+        struct config_item_type *os_desc_type, *interface_type;
+
+        vla_group(data_chunk);
+        vla_item(data_chunk, struct config_group *, f_default_groups, 2);
+        vla_item(data_chunk, struct config_group, os_desc_group, 1);
+        vla_item(data_chunk, struct config_group *, interface_groups,
+                 n_interf + 1);
+        vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
+        vla_item(data_chunk, struct config_item_type, interface_type, 1);
+
+        char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
+        if (!vlabuf)
+                return -ENOMEM;
+
+        f_default_groups = vla_ptr(vlabuf, data_chunk, f_default_groups);
+        os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
+        os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
+        interface_groups = vla_ptr(vlabuf, data_chunk, interface_groups);
+        interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
+
+        parent->default_groups = f_default_groups;
+        os_desc_type->ct_owner = owner;
+        config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
+        f_default_groups[0] = os_desc_group;
+
+        os_desc_group->default_groups = interface_groups;
+        interface_type->ct_item_ops = &interf_item_ops;
+        interface_type->ct_group_ops = &interf_grp_ops;
+        interface_type->ct_attrs = interf_grp_attrs;
+        interface_type->ct_owner = owner;
+
+        while (n_interf--) {
+                struct usb_os_desc *d;
+
+                d = desc[n_interf];
+                d->owner = owner;
+                config_group_init_type_name(&d->group, "", interface_type);
+                config_item_set_name(&d->group.cg_item, "interface.%d",
+                                     n_interf);
+                interface_groups[n_interf] = &d->group;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
+
 static int configfs_do_nothing(struct usb_composite_dev *cdev)
 {
         WARN_ON(1);
@@ -745,6 +1275,9 @@ static int configfs_do_nothing(struct usb_composite_dev *cdev)
 int composite_dev_prepare(struct usb_composite_driver *composite,
                 struct usb_composite_dev *dev);
 
+int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
+                                  struct usb_ep *ep0);
+
 static void purge_configs_funcs(struct gadget_info *gi)
 {
         struct usb_configuration        *c;
@@ -793,7 +1326,7 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
         ret = -EINVAL;
 
         if (list_empty(&gi->cdev.configs)) {
-                pr_err("Need atleast one configuration in %s.\n",
+                pr_err("Need at least one configuration in %s.\n",
                                 gi->composite.name);
                 goto err_comp_cleanup;
         }
@@ -804,7 +1337,7 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
 
                 cfg = container_of(c, struct config_usb_cfg, c);
                 if (list_empty(&cfg->func_list)) {
-                        pr_err("Config %s/%d of %s needs atleast one function.\n",
+                        pr_err("Config %s/%d of %s needs at least one function.\n",
                               c->label, c->bConfigurationValue,
                               gi->composite.name);
                         goto err_comp_cleanup;
@@ -839,6 +1372,12 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
                 gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
         }
 
+        if (gi->use_os_desc) {
+                cdev->use_os_string = true;
+                cdev->b_vendor_code = gi->b_vendor_code;
+                memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
+        }
+
         /* Go through all configs, attach all functions */
         list_for_each_entry(c, &gi->cdev.configs, list) {
                 struct config_usb_cfg *cfg;
@@ -874,6 +1413,12 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
                 }
                 usb_ep_autoconfig_reset(cdev->gadget);
         }
+        if (cdev->use_os_string) {
+                ret = composite_os_desc_req_prepare(cdev, gadget->ep0);
+                if (ret)
+                        goto err_purge_funcs;
+        }
+
         usb_ep_autoconfig_reset(cdev->gadget);
         return 0;
 
@@ -929,6 +1474,7 @@ static struct config_group *gadgets_make(
         gi->group.default_groups[0] = &gi->functions_group;
         gi->group.default_groups[1] = &gi->configs_group;
         gi->group.default_groups[2] = &gi->strings_group;
+        gi->group.default_groups[3] = &gi->os_desc_group;
 
         config_group_init_type_name(&gi->functions_group, "functions",
                         &functions_type);
@@ -936,6 +1482,8 @@ static struct config_group *gadgets_make(
                         &config_desc_type);
         config_group_init_type_name(&gi->strings_group, "strings",
                         &gadget_strings_strings_type);
+        config_group_init_type_name(&gi->os_desc_group, "os_desc",
+                        &os_desc_type);
 
         gi->composite.bind = configfs_do_nothing;
         gi->composite.unbind = configfs_do_nothing;
@@ -1005,7 +1553,7 @@ void unregister_gadget_item(struct config_item *item)
 
         unregister_gadget(gi);
 }
-EXPORT_SYMBOL(unregister_gadget_item);
+EXPORT_SYMBOL_GPL(unregister_gadget_item);
 
 static int __init gadget_cfs_init(void)
 {
diff --git a/drivers/usb/gadget/configfs.h b/drivers/usb/gadget/configfs.h
index a7b564a913d1..a14ac792c698 100644
--- a/drivers/usb/gadget/configfs.h
+++ b/drivers/usb/gadget/configfs.h
@@ -1,6 +1,18 @@
 #ifndef USB__GADGET__CONFIGFS__H
 #define USB__GADGET__CONFIGFS__H
 
+#include <linux/configfs.h>
+
 void unregister_gadget_item(struct config_item *item);
 
+int usb_os_desc_prepare_interf_dir(struct config_group *parent,
+                                   int n_interf,
+                                   struct usb_os_desc **desc,
+                                   struct module *owner);
+
+static inline struct usb_os_desc *to_usb_os_desc(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct usb_os_desc, group);
+}
+
 #endif /*  USB__GADGET__CONFIGFS__H */
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 8c06430dcc47..2b54955d3166 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -561,7 +561,6 @@ static int dummy_disable(struct usb_ep *_ep)
         struct dummy_ep         *ep;
         struct dummy            *dum;
         unsigned long           flags;
-        int                     retval;
 
         ep = usb_ep_to_dummy_ep(_ep);
         if (!_ep || !ep->desc || _ep->name == ep0name)
@@ -571,12 +570,11 @@ static int dummy_disable(struct usb_ep *_ep)
         spin_lock_irqsave(&dum->lock, flags);
         ep->desc = NULL;
         ep->stream_en = 0;
-        retval = 0;
         nuke(dum, ep);
         spin_unlock_irqrestore(&dum->lock, flags);
 
         dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
-        return retval;
+        return 0;
 }
 
 static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 1e12b3ee56fd..74202d67f911 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -33,36 +33,11 @@
 #include <linux/poll.h>
 
 #include "u_fs.h"
+#include "u_f.h"
 #include "configfs.h"
 
 #define FUNCTIONFS_MAGIC        0xa647361 /* Chosen by a honest dice roll ;) */
 
-/* Variable Length Array Macros **********************************************/
-#define vla_group(groupname) size_t groupname##__next = 0
-#define vla_group_size(groupname) groupname##__next
-
-#define vla_item(groupname, type, name, n) \
-        size_t groupname##_##name##__offset = ({                               \
-                size_t align_mask = __alignof__(type) - 1;                     \
-                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
-                size_t size = (n) * sizeof(type);                              \
-                groupname##__next = offset + size;                             \
-                offset;                                                        \
-        })
-
-#define vla_item_with_sz(groupname, type, name, n) \
-        size_t groupname##_##name##__sz = (n) * sizeof(type);                  \
-        size_t groupname##_##name##__offset = ({                               \
-                size_t align_mask = __alignof__(type) - 1;                     \
-                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
-                size_t size = groupname##_##name##__sz;                        \
-                groupname##__next = offset + size;                             \
-                offset;                                                        \
-        })
-
-#define vla_ptr(ptr, groupname, name) \
-        ((void *) ((char *)ptr + groupname##_##name##__offset))
-
 /* Reference counter handling */
 static void ffs_data_get(struct ffs_data *ffs);
 static void ffs_data_put(struct ffs_data *ffs);
@@ -190,7 +165,7 @@ ffs_sb_create_file(struct super_block *sb, const char *name, void *data,
 /* Devices management *******************************************************/
 
 DEFINE_MUTEX(ffs_lock);
-EXPORT_SYMBOL(ffs_lock);
+EXPORT_SYMBOL_GPL(ffs_lock);
 
 static struct ffs_dev *_ffs_find_dev(const char *name);
 static struct ffs_dev *_ffs_alloc_dev(void);
@@ -2883,7 +2858,7 @@ int ffs_name_dev(struct ffs_dev *dev, const char *name)
 
         return ret;
 }
-EXPORT_SYMBOL(ffs_name_dev);
+EXPORT_SYMBOL_GPL(ffs_name_dev);
 
 int ffs_single_dev(struct ffs_dev *dev)
 {
@@ -2900,7 +2875,7 @@ int ffs_single_dev(struct ffs_dev *dev)
         ffs_dev_unlock();
         return ret;
 }
-EXPORT_SYMBOL(ffs_single_dev);
+EXPORT_SYMBOL_GPL(ffs_single_dev);
 
 /*
  * ffs_lock must be taken by the caller of this function
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 9a4f49dc6ac4..eed3ad878047 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -27,6 +27,7 @@
 #include "u_ether_configfs.h"
 #include "u_rndis.h"
 #include "rndis.h"
+#include "configfs.h"
 
 /*
  * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
@@ -682,6 +683,15 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 
         rndis_opts = container_of(f->fi, struct f_rndis_opts, func_inst);
 
+        if (cdev->use_os_string) {
+                f->os_desc_table = kzalloc(sizeof(*f->os_desc_table),
+                                           GFP_KERNEL);
+                if (!f->os_desc_table)
+                        return PTR_ERR(f->os_desc_table);
+                f->os_desc_n = 1;
+                f->os_desc_table[0].os_desc = &rndis_opts->rndis_os_desc;
+        }
+
         /*
          * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
          * configurations are bound in sequence with list_for_each_entry,
@@ -693,14 +703,16 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
                 gether_set_gadget(rndis_opts->net, cdev->gadget);
                 status = gether_register_netdev(rndis_opts->net);
                 if (status)
-                        return status;
+                        goto fail;
                 rndis_opts->bound = true;
         }
 
         us = usb_gstrings_attach(cdev, rndis_strings,
                                  ARRAY_SIZE(rndis_string_defs));
-        if (IS_ERR(us))
-                return PTR_ERR(us);
+        if (IS_ERR(us)) {
+                status = PTR_ERR(us);
+                goto fail;
+        }
         rndis_control_intf.iInterface = us[0].id;
         rndis_data_intf.iInterface = us[1].id;
         rndis_iad_descriptor.iFunction = us[2].id;
@@ -802,6 +814,8 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
         return 0;
 
 fail:
+        kfree(f->os_desc_table);
+        f->os_desc_n = 0;
         usb_free_all_descriptors(f);
 
         if (rndis->notify_req) {
@@ -834,7 +848,7 @@ void rndis_borrow_net(struct usb_function_instance *f, struct net_device *net)
         opts->borrowed_net = opts->bound = true;
         opts->net = net;
 }
-EXPORT_SYMBOL(rndis_borrow_net);
+EXPORT_SYMBOL_GPL(rndis_borrow_net);
 
 static inline struct f_rndis_opts *to_f_rndis_opts(struct config_item *item)
 {
@@ -882,16 +896,21 @@ static void rndis_free_inst(struct usb_function_instance *f)
                 else
                         free_netdev(opts->net);
         }
+
+        kfree(opts->rndis_os_desc.group.default_groups); /* single VLA chunk */
         kfree(opts);
 }
 
 static struct usb_function_instance *rndis_alloc_inst(void)
 {
         struct f_rndis_opts *opts;
+        struct usb_os_desc *descs[1];
 
         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
         if (!opts)
                 return ERR_PTR(-ENOMEM);
+        opts->rndis_os_desc.ext_compat_id = opts->rndis_ext_compat_id;
+
         mutex_init(&opts->lock);
         opts->func_inst.free_func_inst = rndis_free_inst;
         opts->net = gether_setup_default();
@@ -900,7 +919,11 @@ static struct usb_function_instance *rndis_alloc_inst(void)
                 kfree(opts);
                 return ERR_CAST(net);
         }
+        INIT_LIST_HEAD(&opts->rndis_os_desc.ext_prop);
 
+        descs[0] = &opts->rndis_os_desc;
+        usb_os_desc_prepare_interf_dir(&opts->func_inst.group, 1, descs,
+                                       THIS_MODULE);
         config_group_init_type_name(&opts->func_inst.group, "",
                                     &rndis_func_type);
 
@@ -925,6 +948,8 @@ static void rndis_unbind(struct usb_configuration *c, struct usb_function *f)
 {
         struct f_rndis          *rndis = func_to_rndis(f);
 
+        kfree(f->os_desc_table);
+        f->os_desc_n = 0;
         usb_free_all_descriptors(f);
 
         kfree(rndis->notify_req->buf);
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index df4a0dcbc993..1ea8baf33333 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -276,7 +276,7 @@ static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         }
 
         net = gether_connect(&geth->port);
-        return PTR_RET(net);
+        return PTR_ERR_OR_ZERO(net);
 }
 
 static void geth_disable(struct usb_function *f)
diff --git a/drivers/usb/gadget/f_uac2.c b/drivers/usb/gadget/f_uac2.c
index bc23040c7790..6261db4a9910 100644
--- a/drivers/usb/gadget/f_uac2.c
+++ b/drivers/usb/gadget/f_uac2.c
@@ -196,7 +196,7 @@ agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
         struct snd_uac2_chip *uac2 = prm->uac2;
 
         /* i/f shutting down */
-        if (!prm->ep_enabled)
+        if (!prm->ep_enabled || req->status == -ESHUTDOWN)
                 return;
 
         /*
@@ -974,8 +974,6 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
         if (!prm->rbuf) {
                 prm->max_psize = 0;
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
 
@@ -984,8 +982,6 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
         if (!prm->rbuf) {
                 prm->max_psize = 0;
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
 
@@ -1298,10 +1294,8 @@ static int audio_bind_config(struct usb_configuration *cfg)
         int res;
 
         agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL);
-        if (agdev_g == NULL) {
-                printk(KERN_ERR "Unable to allocate audio gadget\n");
+        if (agdev_g == NULL)
                 return -ENOMEM;
-        }
 
         res = usb_string_ids_tab(cfg->cdev, strings_fn);
         if (res)
diff --git a/drivers/usb/gadget/fotg210-udc.c b/drivers/usb/gadget/fotg210-udc.c
index 2d0305280e8c..e143d69f6017 100644
--- a/drivers/usb/gadget/fotg210-udc.c
+++ b/drivers/usb/gadget/fotg210-udc.c
@@ -1112,17 +1112,13 @@ static int fotg210_udc_probe(struct platform_device *pdev)
 
         /* initialize udc */
         fotg210 = kzalloc(sizeof(struct fotg210_udc), GFP_KERNEL);
-        if (fotg210 == NULL) {
-                pr_err("kzalloc error\n");
+        if (fotg210 == NULL)
                 goto err_alloc;
-        }
 
         for (i = 0; i < FOTG210_MAX_NUM_EP; i++) {
                 _ep[i] = kzalloc(sizeof(struct fotg210_ep), GFP_KERNEL);
-                if (_ep[i] == NULL) {
-                        pr_err("_ep kzalloc error\n");
+                if (_ep[i] == NULL)
                         goto err_alloc;
-                }
                 fotg210->ep[i] = _ep[i];
         }
 
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index a2f26cdb56fe..28e4fc957026 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -2256,10 +2256,8 @@ static int __init struct_udc_setup(struct fsl_udc *udc,
         udc->phy_mode = pdata->phy_mode;
 
         udc->eps = kzalloc(sizeof(struct fsl_ep) * udc->max_ep, GFP_KERNEL);
-        if (!udc->eps) {
-                ERR("malloc fsl_ep failed\n");
+        if (!udc->eps)
                 return -1;
-        }
 
         /* initialized QHs, take care of alignment */
         size = udc->max_ep * sizeof(struct ep_queue_head);
@@ -2342,10 +2340,8 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
         u32 dccparams;
 
         udc_controller = kzalloc(sizeof(struct fsl_udc), GFP_KERNEL);
-        if (udc_controller == NULL) {
-                ERR("malloc udc failed\n");
+        if (udc_controller == NULL)
                 return -ENOMEM;
-        }
 
         pdata = dev_get_platdata(&pdev->dev);
         udc_controller->pdata = pdata;
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index 6423f1840ed9..3deb4e938071 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -1400,17 +1400,13 @@ static int __init fusb300_probe(struct platform_device *pdev)
 
         /* initialize udc */
         fusb300 = kzalloc(sizeof(struct fusb300), GFP_KERNEL);
-        if (fusb300 == NULL) {
-                pr_err("kzalloc error\n");
+        if (fusb300 == NULL)
                 goto clean_up;
-        }
 
         for (i = 0; i < FUSB300_MAX_NUM_EP; i++) {
                 _ep[i] = kzalloc(sizeof(struct fusb300_ep), GFP_KERNEL);
-                if (_ep[i] == NULL) {
-                        pr_err("_ep kzalloc error\n");
+                if (_ep[i] == NULL)
                         goto clean_up;
-                }
                 fusb300->ep[i] = _ep[i];
         }
 
diff --git a/drivers/usb/gadget/gr_udc.c b/drivers/usb/gadget/gr_udc.c
index f984ee75324d..99a37ed03e27 100644
--- a/drivers/usb/gadget/gr_udc.c
+++ b/drivers/usb/gadget/gr_udc.c
@@ -143,6 +143,7 @@ static void gr_seq_ep_show(struct seq_file *seq, struct gr_ep *ep)
         seq_printf(seq, "  wedged = %d\n", ep->wedged);
         seq_printf(seq, "  callback = %d\n", ep->callback);
         seq_printf(seq, "  maxpacket = %d\n", ep->ep.maxpacket);
+        seq_printf(seq, "  maxpacket_limit = %d\n", ep->ep.maxpacket_limit);
         seq_printf(seq, "  bytes_per_buffer = %d\n", ep->bytes_per_buffer);
         if (mode == 1 || mode == 3)
                 seq_printf(seq, "  nt = %d\n",
@@ -1541,6 +1542,10 @@ static int gr_ep_enable(struct usb_ep *_ep,
         } else if (max == 0) {
                 dev_err(dev->dev, "Max payload cannot be set to 0\n");
                 return -EINVAL;
+        } else if (max > ep->ep.maxpacket_limit) {
+                dev_err(dev->dev, "Requested max payload %d > limit %d\n",
+                        max, ep->ep.maxpacket_limit);
+                return -EINVAL;
         }
 
         spin_lock(&ep->dev->lock);
@@ -1679,7 +1684,7 @@ static int gr_queue_ext(struct usb_ep *_ep, struct usb_request *_req,
         if (ep->is_in)
                 gr_dbgprint_request("EXTERN", ep, req);
 
-        ret = gr_queue(ep, req, gfp_flags);
+        ret = gr_queue(ep, req, GFP_ATOMIC);
 
         spin_unlock(&ep->dev->lock);
 
@@ -1985,8 +1990,8 @@ static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit)
         INIT_LIST_HEAD(&ep->queue);
 
         if (num == 0) {
-                _req = gr_alloc_request(&ep->ep, GFP_KERNEL);
-                buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_KERNEL);
+                _req = gr_alloc_request(&ep->ep, GFP_ATOMIC);
+                buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_ATOMIC);
                 if (!_req || !buf) {
                         /* possible _req freed by gr_probe via gr_remove */
                         return -ENOMEM;
@@ -2020,9 +2025,7 @@ static int gr_udc_init(struct gr_udc *dev)
         u32 dmactrl_val;
         int i;
         int ret = 0;
-        u32 *bufsizes;
         u32 bufsize;
-        int len;
 
         gr_set_address(dev, 0);
 
@@ -2033,19 +2036,17 @@ static int gr_udc_init(struct gr_udc *dev)
         INIT_LIST_HEAD(&dev->ep_list);
         gr_set_ep0state(dev, GR_EP0_DISCONNECT);
 
-        bufsizes = (u32 *)of_get_property(np, "epobufsizes", &len);
-        len /= sizeof(u32);
         for (i = 0; i < dev->nepo; i++) {
-                bufsize = (bufsizes && i < len) ? bufsizes[i] : 1024;
+                if (of_property_read_u32_index(np, "epobufsizes", i, &bufsize))
+                        bufsize = 1024;
                 ret = gr_ep_init(dev, i, 0, bufsize);
                 if (ret)
                         return ret;
         }
 
-        bufsizes = (u32 *)of_get_property(np, "epibufsizes", &len);
-        len /= sizeof(u32);
         for (i = 0; i < dev->nepi; i++) {
-                bufsize = (bufsizes && i < len) ? bufsizes[i] : 1024;
+                if (of_property_read_u32_index(np, "epibufsizes", i, &bufsize))
+                        bufsize = 1024;
                 ret = gr_ep_init(dev, i, 1, bufsize);
                 if (ret)
                         return ret;
@@ -2065,9 +2066,9 @@ static int gr_udc_init(struct gr_udc *dev)
         return 0;
 }
 
-static int gr_remove(struct platform_device *ofdev)
+static int gr_remove(struct platform_device *pdev)
 {
-        struct gr_udc *dev = dev_get_drvdata(&ofdev->dev);
+        struct gr_udc *dev = platform_get_drvdata(pdev);
 
         if (dev->added)
                 usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
@@ -2077,7 +2078,7 @@ static int gr_remove(struct platform_device *ofdev)
         gr_dfs_delete(dev);
         if (dev->desc_pool)
                 dma_pool_destroy(dev->desc_pool);
-        dev_set_drvdata(&ofdev->dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
         gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
@@ -2090,7 +2091,7 @@ static int gr_request_irq(struct gr_udc *dev, int irq)
                                          IRQF_SHARED, driver_name, dev);
 }
 
-static int gr_probe(struct platform_device *ofdev)
+static int gr_probe(struct platform_device *pdev)
 {
         struct gr_udc *dev;
         struct resource *res;
@@ -2098,30 +2099,32 @@ static int gr_probe(struct platform_device *ofdev)
         int retval;
         u32 status;
 
-        dev = devm_kzalloc(&ofdev->dev, sizeof(*dev), GFP_KERNEL);
+        dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
         if (!dev)
                 return -ENOMEM;
-        dev->dev = &ofdev->dev;
+        dev->dev = &pdev->dev;
 
-        res = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         regs = devm_ioremap_resource(dev->dev, res);
         if (IS_ERR(regs))
                 return PTR_ERR(regs);
 
-        dev->irq = irq_of_parse_and_map(dev->dev->of_node, 0);
-        if (!dev->irq) {
+        dev->irq = platform_get_irq(pdev, 0);
+        if (dev->irq <= 0) {
                 dev_err(dev->dev, "No irq found\n");
                 return -ENODEV;
         }
 
         /* Some core configurations has separate irqs for IN and OUT events */
-        dev->irqi = irq_of_parse_and_map(dev->dev->of_node, 1);
-        if (dev->irqi) {
-                dev->irqo = irq_of_parse_and_map(dev->dev->of_node, 2);
-                if (!dev->irqo) {
+        dev->irqi = platform_get_irq(pdev, 1);
+        if (dev->irqi > 0) {
+                dev->irqo = platform_get_irq(pdev, 2);
+                if (dev->irqo <= 0) {
                         dev_err(dev->dev, "Found irqi but not irqo\n");
                         return -ENODEV;
                 }
+        } else {
+                dev->irqi = 0;
         }
 
         dev->gadget.name = driver_name;
@@ -2132,7 +2135,7 @@ static int gr_probe(struct platform_device *ofdev)
         spin_lock_init(&dev->lock);
         dev->regs = regs;
 
-        dev_set_drvdata(&ofdev->dev, dev);
+        platform_set_drvdata(pdev, dev);
 
         /* Determine number of endpoints and data interface mode */
         status = gr_read32(&dev->regs->status);
@@ -2204,7 +2207,7 @@ out:
         spin_unlock(&dev->lock);
 
         if (retval)
-                gr_remove(ofdev);
+                gr_remove(pdev);
 
         return retval;
 }
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index a925d0cbcd41..ee6c16416c30 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1494,6 +1494,7 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                  */
                 if (value == 0) {
                         INFO (dev, "configuration #%d\n", dev->current_config);
+                        usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
                         if (dev->usermode_setup) {
                                 dev->setup_can_stall = 0;
                                 goto delegate;
@@ -1501,7 +1502,7 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 }
                 break;
 
-#ifndef CONFIG_USB_GADGET_PXA25X
+#ifndef CONFIG_USB_PXA25X
         /* PXA automagically handles this request too */
         case USB_REQ_GET_CONFIGURATION:
                 if (ctrl->bRequestType != 0x80)
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 8cae01d88597..0d17174b86f8 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1594,7 +1594,6 @@ static int __init m66592_probe(struct platform_device *pdev)
         m66592 = kzalloc(sizeof(struct m66592), GFP_KERNEL);
         if (m66592 == NULL) {
                 ret = -ENOMEM;
-                pr_err("kzalloc error\n");
                 goto clean_up;
         }
 
diff --git a/drivers/usb/gadget/mv_u3d_core.c b/drivers/usb/gadget/mv_u3d_core.c
index d2ca59e7b477..16248711c152 100644
--- a/drivers/usb/gadget/mv_u3d_core.c
+++ b/drivers/usb/gadget/mv_u3d_core.c
@@ -297,10 +297,8 @@ static struct mv_u3d_trb *mv_u3d_build_trb_one(struct mv_u3d_req *req,
         u3d = req->ep->u3d;
 
         trb = kzalloc(sizeof(*trb), GFP_ATOMIC);
-        if (!trb) {
-                dev_err(u3d->dev, "%s, trb alloc fail\n", __func__);
+        if (!trb)
                 return NULL;
-        }
 
         /*
          * Be careful that no _GFP_HIGHMEM is set,
@@ -446,17 +444,12 @@ static int mv_u3d_req_to_trb(struct mv_u3d_req *req)
                         trb_num++;
 
                 trb = kcalloc(trb_num, sizeof(*trb), GFP_ATOMIC);
-                if (!trb) {
-                        dev_err(u3d->dev,
-                                        "%s, trb alloc fail\n", __func__);
+                if (!trb)
                         return -ENOMEM;
-                }
 
                 trb_hw = kcalloc(trb_num, sizeof(*trb_hw), GFP_ATOMIC);
                 if (!trb_hw) {
                         kfree(trb);
-                        dev_err(u3d->dev,
-                                        "%s, trb_hw alloc fail\n", __func__);
                         return -ENOMEM;
                 }
 
@@ -1811,7 +1804,6 @@ static int mv_u3d_probe(struct platform_device *dev)
 
         u3d = kzalloc(sizeof(*u3d), GFP_KERNEL);
         if (!u3d) {
-                dev_err(&dev->dev, "failed to allocate memory for u3d\n");
                 retval = -ENOMEM;
                 goto err_alloc_private;
         }
@@ -1905,7 +1897,6 @@ static int mv_u3d_probe(struct platform_device *dev)
         size = u3d->max_eps * sizeof(struct mv_u3d_ep) * 2;
         u3d->eps = kzalloc(size, GFP_KERNEL);
         if (!u3d->eps) {
-                dev_err(&dev->dev, "allocate ep memory failed\n");
                 retval = -ENOMEM;
                 goto err_alloc_eps;
         }
@@ -1913,7 +1904,6 @@ static int mv_u3d_probe(struct platform_device *dev)
         /* initialize ep0 status request structure */
         u3d->status_req = kzalloc(sizeof(struct mv_u3d_req) + 8, GFP_KERNEL);
         if (!u3d->status_req) {
-                dev_err(&dev->dev, "allocate status_req memory failed\n");
                 retval = -ENOMEM;
                 goto err_alloc_status_req;
         }
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 43e5e2f9888f..300b3a71383b 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -1972,7 +1972,9 @@ static int net2280_stop(struct usb_gadget *_gadget,
         device_remove_file (&dev->pdev->dev, &dev_attr_function);
         device_remove_file (&dev->pdev->dev, &dev_attr_queues);
 
-        DEBUG (dev, "unregistered driver '%s'\n", driver->driver.name);
+        DEBUG(dev, "unregistered driver '%s'\n",
+                        driver ? driver->driver.name : "");
+
         return 0;
 }
 
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index aff0a6718bc6..b698a490cc7d 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -1904,7 +1904,6 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         r8a66597 = kzalloc(sizeof(struct r8a66597), GFP_KERNEL);
         if (r8a66597 == NULL) {
                 ret = -ENOMEM;
-                dev_err(&pdev->dev, "kzalloc error\n");
                 goto clean_up;
         }
 
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 7ed452d90f4d..95d2324f6977 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -761,7 +761,7 @@ int rndis_signal_connect(int configNr)
         return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_CONNECT);
 }
-EXPORT_SYMBOL(rndis_signal_connect);
+EXPORT_SYMBOL_GPL(rndis_signal_connect);
 
 int rndis_signal_disconnect(int configNr)
 {
@@ -770,7 +770,7 @@ int rndis_signal_disconnect(int configNr)
         return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_DISCONNECT);
 }
-EXPORT_SYMBOL(rndis_signal_disconnect);
+EXPORT_SYMBOL_GPL(rndis_signal_disconnect);
 
 void rndis_uninit(int configNr)
 {
@@ -785,13 +785,13 @@ void rndis_uninit(int configNr)
         while ((buf = rndis_get_next_response(configNr, &length)))
                 rndis_free_response(configNr, buf);
 }
-EXPORT_SYMBOL(rndis_uninit);
+EXPORT_SYMBOL_GPL(rndis_uninit);
 
 void rndis_set_host_mac(int configNr, const u8 *addr)
 {
         rndis_per_dev_params[configNr].host_mac = addr;
 }
-EXPORT_SYMBOL(rndis_set_host_mac);
+EXPORT_SYMBOL_GPL(rndis_set_host_mac);
 
 /*
  * Message Parser
@@ -874,7 +874,7 @@ int rndis_msg_parser(u8 configNr, u8 *buf)
 
         return -ENOTSUPP;
 }
-EXPORT_SYMBOL(rndis_msg_parser);
+EXPORT_SYMBOL_GPL(rndis_msg_parser);
 
 int rndis_register(void (*resp_avail)(void *v), void *v)
 {
@@ -896,7 +896,7 @@ int rndis_register(void (*resp_avail)(void *v), void *v)
 
         return -ENODEV;
 }
-EXPORT_SYMBOL(rndis_register);
+EXPORT_SYMBOL_GPL(rndis_register);
 
 void rndis_deregister(int configNr)
 {
@@ -905,7 +905,7 @@ void rndis_deregister(int configNr)
         if (configNr >= RNDIS_MAX_CONFIGS) return;
         rndis_per_dev_params[configNr].used = 0;
 }
-EXPORT_SYMBOL(rndis_deregister);
+EXPORT_SYMBOL_GPL(rndis_deregister);
 
 int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
 {
@@ -919,7 +919,7 @@ int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_dev);
+EXPORT_SYMBOL_GPL(rndis_set_param_dev);
 
 int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
 {
@@ -932,7 +932,7 @@ int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_vendor);
+EXPORT_SYMBOL_GPL(rndis_set_param_vendor);
 
 int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
 {
@@ -944,7 +944,7 @@ int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_medium);
+EXPORT_SYMBOL_GPL(rndis_set_param_medium);
 
 void rndis_add_hdr(struct sk_buff *skb)
 {
@@ -959,7 +959,7 @@ void rndis_add_hdr(struct sk_buff *skb)
         header->DataOffset = cpu_to_le32(36);
         header->DataLength = cpu_to_le32(skb->len - sizeof(*header));
 }
-EXPORT_SYMBOL(rndis_add_hdr);
+EXPORT_SYMBOL_GPL(rndis_add_hdr);
 
 void rndis_free_response(int configNr, u8 *buf)
 {
@@ -976,7 +976,7 @@ void rndis_free_response(int configNr, u8 *buf)
                 }
         }
 }
-EXPORT_SYMBOL(rndis_free_response);
+EXPORT_SYMBOL_GPL(rndis_free_response);
 
 u8 *rndis_get_next_response(int configNr, u32 *length)
 {
@@ -998,7 +998,7 @@ u8 *rndis_get_next_response(int configNr, u32 *length)
 
         return NULL;
 }
-EXPORT_SYMBOL(rndis_get_next_response);
+EXPORT_SYMBOL_GPL(rndis_get_next_response);
 
 static rndis_resp_t *rndis_add_response(int configNr, u32 length)
 {
@@ -1042,7 +1042,7 @@ int rndis_rm_hdr(struct gether *port,
         skb_queue_tail(list, skb);
         return 0;
 }
-EXPORT_SYMBOL(rndis_rm_hdr);
+EXPORT_SYMBOL_GPL(rndis_rm_hdr);
 
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
 
diff --git a/drivers/usb/gadget/s3c-hsotg.h b/drivers/usb/gadget/s3c-hsotg.h
deleted file mode 100644
index 85f549ff8c1f..000000000000
--- a/drivers/usb/gadget/s3c-hsotg.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/* drivers/usb/gadget/s3c-hsotg.h
- *
- * Copyright 2008 Openmoko, Inc.
- * Copyright 2008 Simtec Electronics
- *      http://armlinux.simtec.co.uk/
- *      Ben Dooks <ben@simtec.co.uk>
- *
- * USB2.0 Highspeed/OtG Synopsis DWC2 device block registers
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
-*/
-
-#ifndef __REGS_USB_HSOTG_H
-#define __REGS_USB_HSOTG_H __FILE__
-
-#define HSOTG_REG(x) (x)
-
-#define GOTGCTL                         HSOTG_REG(0x000)
-#define GOTGCTL_BSESVLD                 (1 << 19)
-#define GOTGCTL_ASESVLD                 (1 << 18)
-#define GOTGCTL_DBNC_SHORT                      (1 << 17)
-#define GOTGCTL_CONID_B                 (1 << 16)
-#define GOTGCTL_DEVHNPEN                        (1 << 11)
-#define GOTGCTL_HSSETHNPEN                      (1 << 10)
-#define GOTGCTL_HNPREQ                          (1 << 9)
-#define GOTGCTL_HSTNEGSCS                       (1 << 8)
-#define GOTGCTL_SESREQ                          (1 << 1)
-#define GOTGCTL_SESREQSCS                       (1 << 0)
-
-#define GOTGINT                         HSOTG_REG(0x004)
-#define GOTGINT_DbnceDone                       (1 << 19)
-#define GOTGINT_ADevTOUTChg                     (1 << 18)
-#define GOTGINT_HstNegDet                       (1 << 17)
-#define GOTGINT_HstnegSucStsChng                (1 << 9)
-#define GOTGINT_SesReqSucStsChng                (1 << 8)
-#define GOTGINT_SesEndDet                       (1 << 2)
-
-#define GAHBCFG                         HSOTG_REG(0x008)
-#define GAHBCFG_PTxFEmpLvl                      (1 << 8)
-#define GAHBCFG_NPTxFEmpLvl                     (1 << 7)
-#define GAHBCFG_DMAEn                           (1 << 5)
-#define GAHBCFG_HBstLen_MASK                    (0xf << 1)
-#define GAHBCFG_HBstLen_SHIFT                   (1)
-#define GAHBCFG_HBstLen_Single                  (0x0 << 1)
-#define GAHBCFG_HBstLen_Incr                    (0x1 << 1)
-#define GAHBCFG_HBstLen_Incr4                   (0x3 << 1)
-#define GAHBCFG_HBstLen_Incr8                   (0x5 << 1)
-#define GAHBCFG_HBstLen_Incr16                  (0x7 << 1)
-#define GAHBCFG_GlblIntrEn                      (1 << 0)
-
-#define GUSBCFG                         HSOTG_REG(0x00C)
-#define GUSBCFG_PHYLPClkSel                     (1 << 15)
-#define GUSBCFG_HNPCap                          (1 << 9)
-#define GUSBCFG_SRPCap                          (1 << 8)
-#define GUSBCFG_PHYIf16                 (1 << 3)
-#define GUSBCFG_PHYIf8                          (0 << 3)
-#define GUSBCFG_TOutCal_MASK                    (0x7 << 0)
-#define GUSBCFG_TOutCal_SHIFT                   (0)
-#define GUSBCFG_TOutCal_LIMIT                   (0x7)
-#define GUSBCFG_TOutCal(_x)                     ((_x) << 0)
-
-#define GRSTCTL                         HSOTG_REG(0x010)
-
-#define GRSTCTL_AHBIdle                 (1 << 31)
-#define GRSTCTL_DMAReq                          (1 << 30)
-#define GRSTCTL_TxFNum_MASK                     (0x1f << 6)
-#define GRSTCTL_TxFNum_SHIFT                    (6)
-#define GRSTCTL_TxFNum_LIMIT                    (0x1f)
-#define GRSTCTL_TxFNum(_x)                      ((_x) << 6)
-#define GRSTCTL_TxFFlsh                 (1 << 5)
-#define GRSTCTL_RxFFlsh                 (1 << 4)
-#define GRSTCTL_INTknQFlsh                      (1 << 3)
-#define GRSTCTL_FrmCntrRst                      (1 << 2)
-#define GRSTCTL_HSftRst                 (1 << 1)
-#define GRSTCTL_CSftRst                 (1 << 0)
-
-#define GINTSTS                         HSOTG_REG(0x014)
-#define GINTMSK                         HSOTG_REG(0x018)
-
-#define GINTSTS_WkUpInt                 (1 << 31)
-#define GINTSTS_SessReqInt                      (1 << 30)
-#define GINTSTS_DisconnInt                      (1 << 29)
-#define GINTSTS_ConIDStsChng                    (1 << 28)
-#define GINTSTS_PTxFEmp                 (1 << 26)
-#define GINTSTS_HChInt                          (1 << 25)
-#define GINTSTS_PrtInt                          (1 << 24)
-#define GINTSTS_FetSusp                 (1 << 22)
-#define GINTSTS_incompIP                        (1 << 21)
-#define GINTSTS_IncomplSOIN                     (1 << 20)
-#define GINTSTS_OEPInt                          (1 << 19)
-#define GINTSTS_IEPInt                          (1 << 18)
-#define GINTSTS_EPMis                           (1 << 17)
-#define GINTSTS_EOPF                            (1 << 15)
-#define GINTSTS_ISOutDrop                       (1 << 14)
-#define GINTSTS_EnumDone                        (1 << 13)
-#define GINTSTS_USBRst                          (1 << 12)
-#define GINTSTS_USBSusp                 (1 << 11)
-#define GINTSTS_ErlySusp                        (1 << 10)
-#define GINTSTS_GOUTNakEff                      (1 << 7)
-#define GINTSTS_GINNakEff                       (1 << 6)
-#define GINTSTS_NPTxFEmp                        (1 << 5)
-#define GINTSTS_RxFLvl                          (1 << 4)
-#define GINTSTS_SOF                             (1 << 3)
-#define GINTSTS_OTGInt                          (1 << 2)
-#define GINTSTS_ModeMis                 (1 << 1)
-#define GINTSTS_CurMod_Host                     (1 << 0)
-
-#define GRXSTSR                         HSOTG_REG(0x01C)
-#define GRXSTSP                         HSOTG_REG(0x020)
-
-#define GRXSTS_FN_MASK                          (0x7f << 25)
-#define GRXSTS_FN_SHIFT                 (25)
-
-#define GRXSTS_PktSts_MASK                      (0xf << 17)
-#define GRXSTS_PktSts_SHIFT                     (17)
-#define GRXSTS_PktSts_GlobalOutNAK              (0x1 << 17)
-#define GRXSTS_PktSts_OutRX                     (0x2 << 17)
-#define GRXSTS_PktSts_OutDone                   (0x3 << 17)
-#define GRXSTS_PktSts_SetupDone         (0x4 << 17)
-#define GRXSTS_PktSts_SetupRX                   (0x6 << 17)
-
-#define GRXSTS_DPID_MASK                        (0x3 << 15)
-#define GRXSTS_DPID_SHIFT                       (15)
-#define GRXSTS_ByteCnt_MASK                     (0x7ff << 4)
-#define GRXSTS_ByteCnt_SHIFT                    (4)
-#define GRXSTS_EPNum_MASK                       (0xf << 0)
-#define GRXSTS_EPNum_SHIFT                      (0)
-
-#define GRXFSIZ                         HSOTG_REG(0x024)
-
-#define GNPTXFSIZ                               HSOTG_REG(0x028)
-
-#define GNPTXFSIZ_NPTxFDep_MASK         (0xffff << 16)
-#define GNPTXFSIZ_NPTxFDep_SHIFT                (16)
-#define GNPTXFSIZ_NPTxFDep_LIMIT                (0xffff)
-#define GNPTXFSIZ_NPTxFDep(_x)                  ((_x) << 16)
-#define GNPTXFSIZ_NPTxFStAddr_MASK              (0xffff << 0)
-#define GNPTXFSIZ_NPTxFStAddr_SHIFT             (0)
-#define GNPTXFSIZ_NPTxFStAddr_LIMIT             (0xffff)
-#define GNPTXFSIZ_NPTxFStAddr(_x)               ((_x) << 0)
-
-#define GNPTXSTS                                HSOTG_REG(0x02C)
-
-#define GNPTXSTS_NPtxQTop_MASK                  (0x7f << 24)
-#define GNPTXSTS_NPtxQTop_SHIFT         (24)
-
-#define GNPTXSTS_NPTxQSpcAvail_MASK             (0xff << 16)
-#define GNPTXSTS_NPTxQSpcAvail_SHIFT            (16)
-#define GNPTXSTS_NPTxQSpcAvail_GET(_v)          (((_v) >> 16) & 0xff)
-
-#define GNPTXSTS_NPTxFSpcAvail_MASK             (0xffff << 0)
-#define GNPTXSTS_NPTxFSpcAvail_SHIFT            (0)
-#define GNPTXSTS_NPTxFSpcAvail_GET(_v)          (((_v) >> 0) & 0xffff)
-
-
-#define HPTXFSIZ                                HSOTG_REG(0x100)
-
-#define DPTXFSIZn(_a)           HSOTG_REG(0x104 + (((_a) - 1) * 4))
-
-#define DPTXFSIZn_DPTxFSize_MASK                (0xffff << 16)
-#define DPTXFSIZn_DPTxFSize_SHIFT               (16)
-#define DPTXFSIZn_DPTxFSize_GET(_v)             (((_v) >> 16) & 0xffff)
-#define DPTXFSIZn_DPTxFSize_LIMIT               (0xffff)
-#define DPTXFSIZn_DPTxFSize(_x)         ((_x) << 16)
-
-#define DPTXFSIZn_DPTxFStAddr_MASK              (0xffff << 0)
-#define DPTXFSIZn_DPTxFStAddr_SHIFT             (0)
-
-/* Device mode registers */
-#define DCFG                                    HSOTG_REG(0x800)
-
-#define DCFG_EPMisCnt_MASK                      (0x1f << 18)
-#define DCFG_EPMisCnt_SHIFT                     (18)
-#define DCFG_EPMisCnt_LIMIT                     (0x1f)
-#define DCFG_EPMisCnt(_x)                       ((_x) << 18)
-
-#define DCFG_PerFrInt_MASK                      (0x3 << 11)
-#define DCFG_PerFrInt_SHIFT                     (11)
-#define DCFG_PerFrInt_LIMIT                     (0x3)
-#define DCFG_PerFrInt(_x)                       ((_x) << 11)
-
-#define DCFG_DevAddr_MASK                       (0x7f << 4)
-#define DCFG_DevAddr_SHIFT                      (4)
-#define DCFG_DevAddr_LIMIT                      (0x7f)
-#define DCFG_DevAddr(_x)                        ((_x) << 4)
-
-#define DCFG_NZStsOUTHShk                       (1 << 2)
-
-#define DCFG_DevSpd_MASK                        (0x3 << 0)
-#define DCFG_DevSpd_SHIFT                       (0)
-#define DCFG_DevSpd_HS                          (0x0 << 0)
-#define DCFG_DevSpd_FS                          (0x1 << 0)
-#define DCFG_DevSpd_LS                          (0x2 << 0)
-#define DCFG_DevSpd_FS48                        (0x3 << 0)
-
-#define DCTL                                    HSOTG_REG(0x804)
-
-#define DCTL_PWROnPrgDone                       (1 << 11)
-#define DCTL_CGOUTNak                           (1 << 10)
-#define DCTL_SGOUTNak                           (1 << 9)
-#define DCTL_CGNPInNAK                          (1 << 8)
-#define DCTL_SGNPInNAK                          (1 << 7)
-#define DCTL_TstCtl_MASK                        (0x7 << 4)
-#define DCTL_TstCtl_SHIFT                       (4)
-#define DCTL_GOUTNakSts                 (1 << 3)
-#define DCTL_GNPINNakSts                        (1 << 2)
-#define DCTL_SftDiscon                          (1 << 1)
-#define DCTL_RmtWkUpSig                 (1 << 0)
-
-#define DSTS                                    HSOTG_REG(0x808)
-
-#define DSTS_SOFFN_MASK                 (0x3fff << 8)
-#define DSTS_SOFFN_SHIFT                        (8)
-#define DSTS_SOFFN_LIMIT                        (0x3fff)
-#define DSTS_SOFFN(_x)                          ((_x) << 8)
-#define DSTS_ErraticErr                 (1 << 3)
-#define DSTS_EnumSpd_MASK                       (0x3 << 1)
-#define DSTS_EnumSpd_SHIFT                      (1)
-#define DSTS_EnumSpd_HS                 (0x0 << 1)
-#define DSTS_EnumSpd_FS                 (0x1 << 1)
-#define DSTS_EnumSpd_LS                 (0x2 << 1)
-#define DSTS_EnumSpd_FS48                       (0x3 << 1)
-
-#define DSTS_SuspSts                            (1 << 0)
-
-#define DIEPMSK                         HSOTG_REG(0x810)
-
-#define DIEPMSK_TxFIFOEmpty                     (1 << 7)
-#define DIEPMSK_INEPNakEffMsk                   (1 << 6)
-#define DIEPMSK_INTknEPMisMsk                   (1 << 5)
-#define DIEPMSK_INTknTXFEmpMsk                  (1 << 4)
-#define DIEPMSK_TimeOUTMsk                      (1 << 3)
-#define DIEPMSK_AHBErrMsk                       (1 << 2)
-#define DIEPMSK_EPDisbldMsk                     (1 << 1)
-#define DIEPMSK_XferComplMsk                    (1 << 0)
-
-#define DOEPMSK                         HSOTG_REG(0x814)
-
-#define DOEPMSK_Back2BackSetup                  (1 << 6)
-#define DOEPMSK_OUTTknEPdisMsk                  (1 << 4)
-#define DOEPMSK_SetupMsk                        (1 << 3)
-#define DOEPMSK_AHBErrMsk                       (1 << 2)
-#define DOEPMSK_EPDisbldMsk                     (1 << 1)
-#define DOEPMSK_XferComplMsk                    (1 << 0)
-
-#define DAINT                                   HSOTG_REG(0x818)
-#define DAINTMSK                                HSOTG_REG(0x81C)
-
-#define DAINT_OutEP_SHIFT                       (16)
-#define DAINT_OutEP(x)                          (1 << ((x) + 16))
-#define DAINT_InEP(x)                           (1 << (x))
-
-#define DTKNQR1                         HSOTG_REG(0x820)
-#define DTKNQR2                         HSOTG_REG(0x824)
-#define DTKNQR3                         HSOTG_REG(0x830)
-#define DTKNQR4                         HSOTG_REG(0x834)
-
-#define DVBUSDIS                                HSOTG_REG(0x828)
-#define DVBUSPULSE                              HSOTG_REG(0x82C)
-
-#define DIEPCTL0                                HSOTG_REG(0x900)
-#define DOEPCTL0                                HSOTG_REG(0xB00)
-#define DIEPCTL(_a)                     HSOTG_REG(0x900 + ((_a) * 0x20))
-#define DOEPCTL(_a)                     HSOTG_REG(0xB00 + ((_a) * 0x20))
-
-/* EP0 specialness:
- * bits[29..28] - reserved (no SetD0PID, SetD1PID)
- * bits[25..22] - should always be zero, this isn't a periodic endpoint
- * bits[10..0] - MPS setting differenct for EP0
- */
-#define D0EPCTL_MPS_MASK                        (0x3 << 0)
-#define D0EPCTL_MPS_SHIFT                       (0)
-#define D0EPCTL_MPS_64                          (0x0 << 0)
-#define D0EPCTL_MPS_32                          (0x1 << 0)
-#define D0EPCTL_MPS_16                          (0x2 << 0)
-#define D0EPCTL_MPS_8                           (0x3 << 0)
-
-#define DxEPCTL_EPEna                           (1 << 31)
-#define DxEPCTL_EPDis                           (1 << 30)
-#define DxEPCTL_SetD1PID                        (1 << 29)
-#define DxEPCTL_SetOddFr                        (1 << 29)
-#define DxEPCTL_SetD0PID                        (1 << 28)
-#define DxEPCTL_SetEvenFr                       (1 << 28)
-#define DxEPCTL_SNAK                            (1 << 27)
-#define DxEPCTL_CNAK                            (1 << 26)
-#define DxEPCTL_TxFNum_MASK                     (0xf << 22)
-#define DxEPCTL_TxFNum_SHIFT                    (22)
-#define DxEPCTL_TxFNum_LIMIT                    (0xf)
-#define DxEPCTL_TxFNum(_x)                      ((_x) << 22)
-
-#define DxEPCTL_Stall                           (1 << 21)
-#define DxEPCTL_Snp                             (1 << 20)
-#define DxEPCTL_EPType_MASK                     (0x3 << 18)
-#define DxEPCTL_EPType_SHIFT                    (18)
-#define DxEPCTL_EPType_Control                  (0x0 << 18)
-#define DxEPCTL_EPType_Iso                      (0x1 << 18)
-#define DxEPCTL_EPType_Bulk                     (0x2 << 18)
-#define DxEPCTL_EPType_Intterupt                (0x3 << 18)
-
-#define DxEPCTL_NAKsts                          (1 << 17)
-#define DxEPCTL_DPID                            (1 << 16)
-#define DxEPCTL_EOFrNum                 (1 << 16)
-#define DxEPCTL_USBActEp                        (1 << 15)
-#define DxEPCTL_NextEp_MASK                     (0xf << 11)
-#define DxEPCTL_NextEp_SHIFT                    (11)
-#define DxEPCTL_NextEp_LIMIT                    (0xf)
-#define DxEPCTL_NextEp(_x)                      ((_x) << 11)
-
-#define DxEPCTL_MPS_MASK                        (0x7ff << 0)
-#define DxEPCTL_MPS_SHIFT                       (0)
-#define DxEPCTL_MPS_LIMIT                       (0x7ff)
-#define DxEPCTL_MPS(_x)                 ((_x) << 0)
-
-#define DIEPINT(_a)                     HSOTG_REG(0x908 + ((_a) * 0x20))
-#define DOEPINT(_a)                     HSOTG_REG(0xB08 + ((_a) * 0x20))
-
-#define DxEPINT_INEPNakEff                      (1 << 6)
-#define DxEPINT_Back2BackSetup                  (1 << 6)
-#define DxEPINT_INTknEPMis                      (1 << 5)
-#define DxEPINT_INTknTXFEmp                     (1 << 4)
-#define DxEPINT_OUTTknEPdis                     (1 << 4)
-#define DxEPINT_Timeout                 (1 << 3)
-#define DxEPINT_Setup                           (1 << 3)
-#define DxEPINT_AHBErr                          (1 << 2)
-#define DxEPINT_EPDisbld                        (1 << 1)
-#define DxEPINT_XferCompl                       (1 << 0)
-
-#define DIEPTSIZ0                               HSOTG_REG(0x910)
-
-#define DIEPTSIZ0_PktCnt_MASK                   (0x3 << 19)
-#define DIEPTSIZ0_PktCnt_SHIFT                  (19)
-#define DIEPTSIZ0_PktCnt_LIMIT                  (0x3)
-#define DIEPTSIZ0_PktCnt(_x)                    ((_x) << 19)
-
-#define DIEPTSIZ0_XferSize_MASK         (0x7f << 0)
-#define DIEPTSIZ0_XferSize_SHIFT                (0)
-#define DIEPTSIZ0_XferSize_LIMIT                (0x7f)
-#define DIEPTSIZ0_XferSize(_x)                  ((_x) << 0)
-
-#define DOEPTSIZ0                               HSOTG_REG(0xB10)
-#define DOEPTSIZ0_SUPCnt_MASK                   (0x3 << 29)
-#define DOEPTSIZ0_SUPCnt_SHIFT                  (29)
-#define DOEPTSIZ0_SUPCnt_LIMIT                  (0x3)
-#define DOEPTSIZ0_SUPCnt(_x)                    ((_x) << 29)
-
-#define DOEPTSIZ0_PktCnt                        (1 << 19)
-#define DOEPTSIZ0_XferSize_MASK         (0x7f << 0)
-#define DOEPTSIZ0_XferSize_SHIFT                (0)
-
-#define DIEPTSIZ(_a)                    HSOTG_REG(0x910 + ((_a) * 0x20))
-#define DOEPTSIZ(_a)                    HSOTG_REG(0xB10 + ((_a) * 0x20))
-
-#define DxEPTSIZ_MC_MASK                        (0x3 << 29)
-#define DxEPTSIZ_MC_SHIFT                       (29)
-#define DxEPTSIZ_MC_LIMIT                       (0x3)
-#define DxEPTSIZ_MC(_x)                 ((_x) << 29)
-
-#define DxEPTSIZ_PktCnt_MASK                    (0x3ff << 19)
-#define DxEPTSIZ_PktCnt_SHIFT                   (19)
-#define DxEPTSIZ_PktCnt_GET(_v)         (((_v) >> 19) & 0x3ff)
-#define DxEPTSIZ_PktCnt_LIMIT                   (0x3ff)
-#define DxEPTSIZ_PktCnt(_x)                     ((_x) << 19)
-
-#define DxEPTSIZ_XferSize_MASK                  (0x7ffff << 0)
-#define DxEPTSIZ_XferSize_SHIFT         (0)
-#define DxEPTSIZ_XferSize_GET(_v)               (((_v) >> 0) & 0x7ffff)
-#define DxEPTSIZ_XferSize_LIMIT         (0x7ffff)
-#define DxEPTSIZ_XferSize(_x)                   ((_x) << 0)
-
-#define DIEPDMA(_a)                     HSOTG_REG(0x914 + ((_a) * 0x20))
-#define DOEPDMA(_a)                     HSOTG_REG(0xB14 + ((_a) * 0x20))
-#define DTXFSTS(_a)                     HSOTG_REG(0x918 + ((_a) * 0x20))
-
-#define EPFIFO(_a)                      HSOTG_REG(0x1000 + ((_a) * 0x1000))
-
-#endif /* __REGS_USB_HSOTG_H */
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index dd9678f85c58..7987aa049fab 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -117,7 +117,8 @@ static int dprintk(int level, const char *fmt, ...)
                         sizeof(printk_buf)-len, fmt, args);
         va_end(args);
 
-        return pr_debug("%s", printk_buf);
+        pr_debug("%s", printk_buf);
+        return len;
 }
 #else
 static int dprintk(int level, const char *fmt, ...)
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index ec20a1f50c2d..ff205a7bc55c 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -43,7 +43,7 @@ struct usb_interface_descriptor fsg_intf_desc = {
         .bInterfaceProtocol =   USB_PR_BULK,    /* Adjusted during fsg_bind() */
         .iInterface =           FSG_STRING_INTERFACE,
 };
-EXPORT_SYMBOL(fsg_intf_desc);
+EXPORT_SYMBOL_GPL(fsg_intf_desc);
 
 /*
  * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
@@ -58,7 +58,7 @@ struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
-EXPORT_SYMBOL(fsg_fs_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc);
 
 struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -68,7 +68,7 @@ struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
-EXPORT_SYMBOL(fsg_fs_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc);
 
 struct usb_descriptor_header *fsg_fs_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
@@ -76,7 +76,7 @@ struct usb_descriptor_header *fsg_fs_function[] = {
         (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_fs_function);
+EXPORT_SYMBOL_GPL(fsg_fs_function);
 
 
 /*
@@ -95,7 +95,7 @@ struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(512),
 };
-EXPORT_SYMBOL(fsg_hs_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc);
 
 struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -106,7 +106,7 @@ struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
         .wMaxPacketSize =       cpu_to_le16(512),
         .bInterval =            1,      /* NAK every 1 uframe */
 };
-EXPORT_SYMBOL(fsg_hs_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc);
 
 
 struct usb_descriptor_header *fsg_hs_function[] = {
@@ -115,7 +115,7 @@ struct usb_descriptor_header *fsg_hs_function[] = {
         (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_hs_function);
+EXPORT_SYMBOL_GPL(fsg_hs_function);
 
 struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -125,7 +125,7 @@ struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
-EXPORT_SYMBOL(fsg_ss_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc);
 
 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
@@ -133,7 +133,7 @@ struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
 
         /*.bMaxBurst =          DYNAMIC, */
 };
-EXPORT_SYMBOL(fsg_ss_bulk_in_comp_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc);
 
 struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -143,7 +143,7 @@ struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
-EXPORT_SYMBOL(fsg_ss_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc);
 
 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
@@ -151,7 +151,7 @@ struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
 
         /*.bMaxBurst =          DYNAMIC, */
 };
-EXPORT_SYMBOL(fsg_ss_bulk_out_comp_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc);
 
 struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
@@ -161,7 +161,7 @@ struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_ss_function);
+EXPORT_SYMBOL_GPL(fsg_ss_function);
 
 
  /*-------------------------------------------------------------------------*/
@@ -179,7 +179,7 @@ void fsg_lun_close(struct fsg_lun *curlun)
                 curlun->filp = NULL;
         }
 }
-EXPORT_SYMBOL(fsg_lun_close);
+EXPORT_SYMBOL_GPL(fsg_lun_close);
 
 int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 {
@@ -278,7 +278,7 @@ out:
         fput(filp);
         return rc;
 }
-EXPORT_SYMBOL(fsg_lun_open);
+EXPORT_SYMBOL_GPL(fsg_lun_open);
 
 
 /*-------------------------------------------------------------------------*/
@@ -295,7 +295,7 @@ int fsg_lun_fsync_sub(struct fsg_lun *curlun)
                 return 0;
         return vfs_fsync(filp, 1);
 }
-EXPORT_SYMBOL(fsg_lun_fsync_sub);
+EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub);
 
 void store_cdrom_address(u8 *dest, int msf, u32 addr)
 {
@@ -314,7 +314,7 @@ void store_cdrom_address(u8 *dest, int msf, u32 addr)
                 put_unaligned_be32(addr, dest);
         }
 }
-EXPORT_SYMBOL(store_cdrom_address);
+EXPORT_SYMBOL_GPL(store_cdrom_address);
 
 /*-------------------------------------------------------------------------*/
 
@@ -325,13 +325,13 @@ ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
                                   ? curlun->ro
                                   : curlun->initially_ro);
 }
-EXPORT_SYMBOL(fsg_show_ro);
+EXPORT_SYMBOL_GPL(fsg_show_ro);
 
 ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->nofua);
 }
-EXPORT_SYMBOL(fsg_show_nofua);
+EXPORT_SYMBOL_GPL(fsg_show_nofua);
 
 ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                       char *buf)
@@ -357,19 +357,19 @@ ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
         up_read(filesem);
         return rc;
 }
-EXPORT_SYMBOL(fsg_show_file);
+EXPORT_SYMBOL_GPL(fsg_show_file);
 
 ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->cdrom);
 }
-EXPORT_SYMBOL(fsg_show_cdrom);
+EXPORT_SYMBOL_GPL(fsg_show_cdrom);
 
 ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->removable);
 }
-EXPORT_SYMBOL(fsg_show_removable);
+EXPORT_SYMBOL_GPL(fsg_show_removable);
 
 /*
  * The caller must hold fsg->filesem for reading when calling this function.
@@ -410,7 +410,7 @@ ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 
         return rc;
 }
-EXPORT_SYMBOL(fsg_store_ro);
+EXPORT_SYMBOL_GPL(fsg_store_ro);
 
 ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 {
@@ -429,7 +429,7 @@ ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 
         return count;
 }
-EXPORT_SYMBOL(fsg_store_nofua);
+EXPORT_SYMBOL_GPL(fsg_store_nofua);
 
 ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                        const char *buf, size_t count)
@@ -460,7 +460,7 @@ ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
         up_write(filesem);
         return (rc < 0 ? rc : count);
 }
-EXPORT_SYMBOL(fsg_store_file);
+EXPORT_SYMBOL_GPL(fsg_store_file);
 
 ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                         const char *buf, size_t count)
@@ -483,7 +483,7 @@ ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 
         return ret;
 }
-EXPORT_SYMBOL(fsg_store_cdrom);
+EXPORT_SYMBOL_GPL(fsg_store_cdrom);
 
 ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
                             size_t count)
@@ -499,6 +499,6 @@ ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
 
         return count;
 }
-EXPORT_SYMBOL(fsg_store_removable);
+EXPORT_SYMBOL_GPL(fsg_store_removable);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index f058c0368d61..6cdb7a534f23 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -1383,10 +1383,8 @@ static struct se_node_acl *usbg_alloc_fabric_acl(struct se_portal_group *se_tpg)
         struct usbg_nacl *nacl;
 
         nacl = kzalloc(sizeof(struct usbg_nacl), GFP_KERNEL);
-        if (!nacl) {
-                printk(KERN_ERR "Unable to allocate struct usbg_nacl\n");
+        if (!nacl)
                 return NULL;
-        }
 
         return &nacl->se_node_acl;
 }
@@ -1561,10 +1559,8 @@ static struct se_portal_group *usbg_make_tpg(
         }
 
         tpg = kzalloc(sizeof(struct usbg_tpg), GFP_KERNEL);
-        if (!tpg) {
-                printk(KERN_ERR "Unable to allocate struct usbg_tpg");
+        if (!tpg)
                 return ERR_PTR(-ENOMEM);
-        }
         mutex_init(&tpg->tpg_mutex);
         atomic_set(&tpg->tpg_port_count, 0);
         tpg->workqueue = alloc_workqueue("tcm_usb_gadget", 0, 1);
@@ -1613,10 +1609,8 @@ static struct se_wwn *usbg_make_tport(
                 return ERR_PTR(-EINVAL);
 
         tport = kzalloc(sizeof(struct usbg_tport), GFP_KERNEL);
-        if (!(tport)) {
-                printk(KERN_ERR "Unable to allocate struct usbg_tport");
+        if (!(tport))
                 return ERR_PTR(-ENOMEM);
-        }
         tport->tport_wwpn = wwpn;
         snprintf(tport->tport_name, sizeof(tport->tport_name), "%s", wnn_name);
         return &tport->tport_wwn;
@@ -1727,10 +1721,8 @@ static int tcm_usbg_make_nexus(struct usbg_tpg *tpg, char *name)
 
         ret = -ENOMEM;
         tv_nexus = kzalloc(sizeof(*tv_nexus), GFP_KERNEL);
-        if (!tv_nexus) {
-                pr_err("Unable to allocate struct tcm_vhost_nexus\n");
+        if (!tv_nexus)
                 goto err_unlock;
-        }
         tv_nexus->tvn_se_sess = transport_init_session(TARGET_PROT_NORMAL);
         if (IS_ERR(tv_nexus->tvn_se_sess))
                 goto err_free;
@@ -1851,7 +1843,7 @@ static int usbg_port_link(struct se_portal_group *se_tpg, struct se_lun *lun)
         struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
 
         atomic_inc(&tpg->tpg_port_count);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
         return 0;
 }
 
@@ -1861,7 +1853,7 @@ static void usbg_port_unlink(struct se_portal_group *se_tpg,
         struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
 
         atomic_dec(&tpg->tpg_port_count);
-        smp_mb__after_atomic_dec();
+        smp_mb__after_atomic();
 }
 
 static int usbg_check_stop_free(struct se_cmd *se_cmd)
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index b7d4f82872b7..fe0880d0873e 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -818,7 +818,7 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g,
 
         return dev;
 }
-EXPORT_SYMBOL(gether_setup_name);
+EXPORT_SYMBOL_GPL(gether_setup_name);
 
 struct net_device *gether_setup_name_default(const char *netname)
 {
@@ -855,7 +855,7 @@ struct net_device *gether_setup_name_default(const char *netname)
 
         return net;
 }
-EXPORT_SYMBOL(gether_setup_name_default);
+EXPORT_SYMBOL_GPL(gether_setup_name_default);
 
 int gether_register_netdev(struct net_device *net)
 {
@@ -893,7 +893,7 @@ int gether_register_netdev(struct net_device *net)
 
         return status;
 }
-EXPORT_SYMBOL(gether_register_netdev);
+EXPORT_SYMBOL_GPL(gether_register_netdev);
 
 void gether_set_gadget(struct net_device *net, struct usb_gadget *g)
 {
@@ -903,7 +903,7 @@ void gether_set_gadget(struct net_device *net, struct usb_gadget *g)
         dev->gadget = g;
         SET_NETDEV_DEV(net, &g->dev);
 }
-EXPORT_SYMBOL(gether_set_gadget);
+EXPORT_SYMBOL_GPL(gether_set_gadget);
 
 int gether_set_dev_addr(struct net_device *net, const char *dev_addr)
 {
@@ -916,7 +916,7 @@ int gether_set_dev_addr(struct net_device *net, const char *dev_addr)
         memcpy(dev->dev_mac, new_addr, ETH_ALEN);
         return 0;
 }
-EXPORT_SYMBOL(gether_set_dev_addr);
+EXPORT_SYMBOL_GPL(gether_set_dev_addr);
 
 int gether_get_dev_addr(struct net_device *net, char *dev_addr, int len)
 {
@@ -925,7 +925,7 @@ int gether_get_dev_addr(struct net_device *net, char *dev_addr, int len)
         dev = netdev_priv(net);
         return get_ether_addr_str(dev->dev_mac, dev_addr, len);
 }
-EXPORT_SYMBOL(gether_get_dev_addr);
+EXPORT_SYMBOL_GPL(gether_get_dev_addr);
 
 int gether_set_host_addr(struct net_device *net, const char *host_addr)
 {
@@ -938,7 +938,7 @@ int gether_set_host_addr(struct net_device *net, const char *host_addr)
         memcpy(dev->host_mac, new_addr, ETH_ALEN);
         return 0;
 }
-EXPORT_SYMBOL(gether_set_host_addr);
+EXPORT_SYMBOL_GPL(gether_set_host_addr);
 
 int gether_get_host_addr(struct net_device *net, char *host_addr, int len)
 {
@@ -947,7 +947,7 @@ int gether_get_host_addr(struct net_device *net, char *host_addr, int len)
         dev = netdev_priv(net);
         return get_ether_addr_str(dev->host_mac, host_addr, len);
 }
-EXPORT_SYMBOL(gether_get_host_addr);
+EXPORT_SYMBOL_GPL(gether_get_host_addr);
 
 int gether_get_host_addr_cdc(struct net_device *net, char *host_addr, int len)
 {
@@ -961,7 +961,7 @@ int gether_get_host_addr_cdc(struct net_device *net, char *host_addr, int len)
 
         return strlen(host_addr);
 }
-EXPORT_SYMBOL(gether_get_host_addr_cdc);
+EXPORT_SYMBOL_GPL(gether_get_host_addr_cdc);
 
 void gether_get_host_addr_u8(struct net_device *net, u8 host_mac[ETH_ALEN])
 {
@@ -970,7 +970,7 @@ void gether_get_host_addr_u8(struct net_device *net, u8 host_mac[ETH_ALEN])
         dev = netdev_priv(net);
         memcpy(host_mac, dev->host_mac, ETH_ALEN);
 }
-EXPORT_SYMBOL(gether_get_host_addr_u8);
+EXPORT_SYMBOL_GPL(gether_get_host_addr_u8);
 
 void gether_set_qmult(struct net_device *net, unsigned qmult)
 {
@@ -979,7 +979,7 @@ void gether_set_qmult(struct net_device *net, unsigned qmult)
         dev = netdev_priv(net);
         dev->qmult = qmult;
 }
-EXPORT_SYMBOL(gether_set_qmult);
+EXPORT_SYMBOL_GPL(gether_set_qmult);
 
 unsigned gether_get_qmult(struct net_device *net)
 {
@@ -988,7 +988,7 @@ unsigned gether_get_qmult(struct net_device *net)
         dev = netdev_priv(net);
         return dev->qmult;
 }
-EXPORT_SYMBOL(gether_get_qmult);
+EXPORT_SYMBOL_GPL(gether_get_qmult);
 
 int gether_get_ifname(struct net_device *net, char *name, int len)
 {
@@ -997,7 +997,7 @@ int gether_get_ifname(struct net_device *net, char *name, int len)
         rtnl_unlock();
         return strlen(name);
 }
-EXPORT_SYMBOL(gether_get_ifname);
+EXPORT_SYMBOL_GPL(gether_get_ifname);
 
 /**
  * gether_cleanup - remove Ethernet-over-USB device
@@ -1014,7 +1014,7 @@ void gether_cleanup(struct eth_dev *dev)
         flush_work(&dev->work);
         free_netdev(dev->net);
 }
-EXPORT_SYMBOL(gether_cleanup);
+EXPORT_SYMBOL_GPL(gether_cleanup);
 
 /**
  * gether_connect - notify network layer that USB link is active
@@ -1095,7 +1095,7 @@ fail0:
                 return ERR_PTR(result);
         return dev->net;
 }
-EXPORT_SYMBOL(gether_connect);
+EXPORT_SYMBOL_GPL(gether_connect);
 
 /**
  * gether_disconnect - notify network layer that USB link is inactive
@@ -1166,7 +1166,7 @@ void gether_disconnect(struct gether *link)
         dev->port_usb = NULL;
         spin_unlock(&dev->lock);
 }
-EXPORT_SYMBOL(gether_disconnect);
+EXPORT_SYMBOL_GPL(gether_disconnect);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Brownell");
diff --git a/drivers/usb/gadget/u_f.c b/drivers/usb/gadget/u_f.c
index 63b6642c162b..c6276f0268ae 100644
--- a/drivers/usb/gadget/u_f.c
+++ b/drivers/usb/gadget/u_f.c
@@ -29,4 +29,4 @@ struct usb_request *alloc_ep_req(struct usb_ep *ep, int len, int default_len)
         }
         return req;
 }
-EXPORT_SYMBOL(alloc_ep_req);
+EXPORT_SYMBOL_GPL(alloc_ep_req);
diff --git a/drivers/usb/gadget/u_f.h b/drivers/usb/gadget/u_f.h
index 71034c061fca..1d5f0eb68552 100644
--- a/drivers/usb/gadget/u_f.h
+++ b/drivers/usb/gadget/u_f.h
@@ -16,6 +16,32 @@
 #ifndef __U_F_H__
 #define __U_F_H__
 
+/* Variable Length Array Macros **********************************************/
+#define vla_group(groupname) size_t groupname##__next = 0
+#define vla_group_size(groupname) groupname##__next
+
+#define vla_item(groupname, type, name, n) \
+        size_t groupname##_##name##__offset = ({                               \
+                size_t align_mask = __alignof__(type) - 1;                     \
+                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
+                size_t size = (n) * sizeof(type);                              \
+                groupname##__next = offset + size;                             \
+                offset;                                                        \
+        })
+
+#define vla_item_with_sz(groupname, type, name, n) \
+        size_t groupname##_##name##__sz = (n) * sizeof(type);                  \
+        size_t groupname##_##name##__offset = ({                               \
+                size_t align_mask = __alignof__(type) - 1;                     \
+                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
+                size_t size = groupname##_##name##__sz;                        \
+                groupname##__next = offset + size;                             \
+                offset;                                                        \
+        })
+
+#define vla_ptr(ptr, groupname, name) \
+        ((void *) ((char *)ptr + groupname##_##name##__offset))
+
 struct usb_ep;
 struct usb_request;
 
diff --git a/drivers/usb/gadget/u_os_desc.h b/drivers/usb/gadget/u_os_desc.h
new file mode 100644
index 000000000000..ea5cf8c2da28
--- /dev/null
+++ b/drivers/usb/gadget/u_os_desc.h
@@ -0,0 +1,90 @@
+/*
+ * u_os_desc.h
+ *
+ * Utility definitions for "OS Descriptors" support
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __U_OS_DESC_H__
+#define __U_OS_DESC_H__
+
+#include <asm/unaligned.h>
+#include <linux/nls.h>
+
+#define USB_EXT_PROP_DW_SIZE                    0
+#define USB_EXT_PROP_DW_PROPERTY_DATA_TYPE      4
+#define USB_EXT_PROP_W_PROPERTY_NAME_LENGTH     8
+#define USB_EXT_PROP_B_PROPERTY_NAME            10
+#define USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH    10
+#define USB_EXT_PROP_B_PROPERTY_DATA            14
+
+#define USB_EXT_PROP_RESERVED                   0
+#define USB_EXT_PROP_UNICODE                    1
+#define USB_EXT_PROP_UNICODE_ENV                2
+#define USB_EXT_PROP_BINARY                     3
+#define USB_EXT_PROP_LE32                       4
+#define USB_EXT_PROP_BE32                       5
+#define USB_EXT_PROP_UNICODE_LINK               6
+#define USB_EXT_PROP_UNICODE_MULTI              7
+
+static inline void usb_ext_prop_put_size(u8 *buf, int dw_size)
+{
+        put_unaligned_le32(dw_size, &buf[USB_EXT_PROP_DW_SIZE]);
+}
+
+static inline void usb_ext_prop_put_type(u8 *buf, int type)
+{
+        put_unaligned_le32(type, &buf[USB_EXT_PROP_DW_PROPERTY_DATA_TYPE]);
+}
+
+static inline int usb_ext_prop_put_name(u8 *buf, const char *name, int pnl)
+{
+        int result;
+
+        put_unaligned_le16(pnl, &buf[USB_EXT_PROP_W_PROPERTY_NAME_LENGTH]);
+        result = utf8s_to_utf16s(name, strlen(name), UTF16_LITTLE_ENDIAN,
+                (wchar_t *) &buf[USB_EXT_PROP_B_PROPERTY_NAME], pnl - 2);
+        if (result < 0)
+                return result;
+
+        put_unaligned_le16(0, &buf[USB_EXT_PROP_B_PROPERTY_NAME + pnl]);
+
+        return pnl;
+}
+
+static inline void usb_ext_prop_put_binary(u8 *buf, int pnl, const u8 *data,
+                                           int data_len)
+{
+        put_unaligned_le32(data_len,
+                           &buf[USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH + pnl]);
+        memcpy(&buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl], data, data_len);
+}
+
+static inline int usb_ext_prop_put_unicode(u8 *buf, int pnl, const char *string,
+                                           int data_len)
+{
+        int result;
+        put_unaligned_le32(data_len,
+                        &buf[USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH + pnl]);
+
+        result = utf8s_to_utf16s(string, data_len >> 1, UTF16_LITTLE_ENDIAN,
+                        (wchar_t *) &buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl],
+                        data_len - 2);
+        if (result < 0)
+                return result;
+
+        put_unaligned_le16(0,
+                        &buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl + data_len]);
+
+        return data_len;
+}
+
+#endif /* __U_OS_DESC_H__ */
diff --git a/drivers/usb/gadget/u_rndis.h b/drivers/usb/gadget/u_rndis.h
index 7291b15c9dce..e902aa42a297 100644
--- a/drivers/usb/gadget/u_rndis.h
+++ b/drivers/usb/gadget/u_rndis.h
@@ -26,6 +26,9 @@ struct f_rndis_opts {
         bool                            bound;
         bool                            borrowed_net;
 
+        struct usb_os_desc              rndis_os_desc;
+        char                            rndis_ext_compat_id[16];
+
         /*
          * Read/write access to configfs attributes is handled by configfs.
          *
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 27768a7d986a..b0d98172bc07 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -428,6 +428,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         list_for_each_entry(udc, &udc_list, list)
                 if (udc->driver == driver) {
                         usb_gadget_remove_driver(udc);
+                        usb_gadget_set_state(udc->gadget,
+                                        USB_STATE_NOTATTACHED);
                         ret = 0;
                         break;
                 }
diff --git a/drivers/usb/gadget/uvc_queue.c b/drivers/usb/gadget/uvc_queue.c
index 0bb5d50075de..1c29bc954db9 100644
--- a/drivers/usb/gadget/uvc_queue.c
+++ b/drivers/usb/gadget/uvc_queue.c
@@ -20,6 +20,7 @@
 #include <linux/vmalloc.h>
 #include <linux/wait.h>
 
+#include <media/v4l2-common.h>
 #include <media/videobuf2-vmalloc.h>
 
 #include "uvc.h"
@@ -136,6 +137,8 @@ static int uvc_queue_init(struct uvc_video_queue *queue,
         queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
         queue->queue.ops = &uvc_queue_qops;
         queue->queue.mem_ops = &vb2_vmalloc_memops;
+        queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
+                                     | V4L2_BUF_FLAG_TSTAMP_SRC_EOF;
         ret = vb2_queue_init(&queue->queue);
         if (ret)
                 return ret;
@@ -379,14 +382,9 @@ static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         else
                 nextbuf = NULL;
 
-        /*
-         * FIXME: with videobuf2, the sequence number or timestamp fields
-         * are valid only for video capture devices and the UVC gadget usually
-         * is a video output device. Keeping these until the specs are clear on
-         * this aspect.
-         */
+        buf->buf.v4l2_buf.field = V4L2_FIELD_NONE;
         buf->buf.v4l2_buf.sequence = queue->sequence++;
-        do_gettimeofday(&buf->buf.v4l2_buf.timestamp);
+        v4l2_get_timestamp(&buf->buf.v4l2_buf.timestamp);
 
         vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
         vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 3d9e54062d62..61b7817bd66b 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -29,6 +29,14 @@ if USB_XHCI_HCD
 config USB_XHCI_PLATFORM
         tristate
 
+config USB_XHCI_MVEBU
+        tristate "xHCI support for Marvell Armada 375/38x"
+        select USB_XHCI_PLATFORM
+        depends on ARCH_MVEBU || COMPILE_TEST
+        ---help---
+          Say 'Y' to enable the support for the xHCI host controller
+          found in Marvell Armada 375/38x ARM SOCs.
+
 endif # USB_XHCI_HCD
 
 config USB_EHCI_HCD
@@ -170,7 +178,6 @@ config USB_EHCI_MSM
         tristate "Support for Qualcomm QSD/MSM on-chip EHCI USB controller"
         depends on ARCH_MSM
         select USB_EHCI_ROOT_HUB_TT
-        select USB_MSM_OTG
         ---help---
           Enables support for the USB Host controller present on the
           Qualcomm chipsets. Root Hub has inbuilt TT.
@@ -343,10 +350,19 @@ config USB_FOTG210_HCD
           To compile this driver as a module, choose M here: the
           module will be called fotg210-hcd.
 
+config USB_MAX3421_HCD
+        tristate "MAX3421 HCD (USB-over-SPI) support"
+        depends on USB && SPI
+        ---help---
+          The Maxim MAX3421E chip supports standard USB 2.0-compliant
+          full-speed devices either in host or peripheral mode.  This
+          driver supports the host-mode of the MAX3421E only.
+
+          To compile this driver as a module, choose M here: the module will
+          be called max3421-hcd.
+
 config USB_OHCI_HCD
         tristate "OHCI HCD (USB 1.1) support"
-        select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
-        depends on USB_ISP1301 || !ARCH_LPC32XX
         ---help---
           The Open Host Controller Interface (OHCI) is a standard for accessing
           USB 1.1 host controller hardware.  It does more in hardware than Intel's
@@ -365,6 +381,7 @@ if USB_OHCI_HCD
 config USB_OHCI_HCD_OMAP1
         tristate "OHCI support for OMAP1/2 chips"
         depends on ARCH_OMAP1
+        depends on ISP1301_OMAP || !(MACH_OMAP_H2 || MACH_OMAP_H3)
         default y
         ---help---
           Enables support for the OHCI controller on OMAP1/2 chips.
@@ -388,6 +405,7 @@ config USB_OHCI_HCD_S3C2410
 config USB_OHCI_HCD_LPC32XX
         tristate "Support for LPC on-chip OHCI USB controller"
         depends on USB_OHCI_HCD && ARCH_LPC32XX
+        depends on USB_ISP1301
         default y
         ---help---
           Enables support for the on-chip OHCI controller on
@@ -417,6 +435,16 @@ config USB_OHCI_HCD_OMAP3
           Enables support for the on-chip OHCI controller on
           OMAP3 and later chips.
 
+config USB_OHCI_HCD_DAVINCI
+        bool "OHCI support for TI DaVinci DA8xx"
+        depends on ARCH_DAVINCI_DA8XX
+        depends on USB_OHCI_HCD=y
+        default y
+        help
+          Enables support for the DaVinci DA8xx integrated OHCI
+          controller. This driver cannot currently be a loadable
+          module because it lacks a proper PHY abstraction.
+
 config USB_OHCI_ATH79
         bool "USB OHCI support for the Atheros AR71XX/AR7240 SoCs (DEPRECATED)"
         depends on (SOC_AR71XX || SOC_AR724X)
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 7530468c9a4f..af89a903d97e 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -19,6 +19,9 @@ xhci-hcd-$(CONFIG_PCI)	+= xhci-pci.o
 
 ifneq ($(CONFIG_USB_XHCI_PLATFORM), )
         xhci-hcd-y              += xhci-plat.o
+ifneq ($(CONFIG_USB_XHCI_MVEBU), )
+        xhci-hcd-y              += xhci-mvebu.o
+endif
 endif
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
@@ -70,3 +73,4 @@ obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)       += ssb-hcd.o
 obj-$(CONFIG_USB_FUSBH200_HCD)  += fusbh200-hcd.o
 obj-$(CONFIG_USB_FOTG210_HCD)   += fotg210-hcd.o
+obj-$(CONFIG_USB_MAX3421_HCD)   += max3421-hcd.o
diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index 7f425acd9be5..d1c76216350f 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
+#include <linux/phy/phy.h>
 #include <linux/platform_device.h>
 #include <linux/usb/phy.h>
 #include <linux/usb/samsung_usb_phy.h>
@@ -42,17 +43,106 @@
 static const char hcd_name[] = "ehci-exynos";
 static struct hc_driver __read_mostly exynos_ehci_hc_driver;
 
+#define PHY_NUMBER 3
+
 struct exynos_ehci_hcd {
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
+        struct phy *phy_g[PHY_NUMBER];
 };
 
 #define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
 
-static void exynos_setup_vbus_gpio(struct platform_device *pdev)
+static int exynos_ehci_get_phy(struct device *dev,
+                                struct exynos_ehci_hcd *exynos_ehci)
+{
+        struct device_node *child;
+        struct phy *phy;
+        int phy_number;
+        int ret = 0;
+
+        exynos_ehci->phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
+        if (IS_ERR(exynos_ehci->phy)) {
+                ret = PTR_ERR(exynos_ehci->phy);
+                if (ret != -ENXIO && ret != -ENODEV) {
+                        dev_err(dev, "no usb2 phy configured\n");
+                        return ret;
+                }
+                dev_dbg(dev, "Failed to get usb2 phy\n");
+        } else {
+                exynos_ehci->otg = exynos_ehci->phy->otg;
+        }
+
+        for_each_available_child_of_node(dev->of_node, child) {
+                ret = of_property_read_u32(child, "reg", &phy_number);
+                if (ret) {
+                        dev_err(dev, "Failed to parse device tree\n");
+                        of_node_put(child);
+                        return ret;
+                }
+
+                if (phy_number >= PHY_NUMBER) {
+                        dev_err(dev, "Invalid number of PHYs\n");
+                        of_node_put(child);
+                        return -EINVAL;
+                }
+
+                phy = devm_of_phy_get(dev, child, 0);
+                of_node_put(child);
+                if (IS_ERR(phy)) {
+                        ret = PTR_ERR(phy);
+                        if (ret != -ENOSYS && ret != -ENODEV) {
+                                dev_err(dev, "no usb2 phy configured\n");
+                                return ret;
+                        }
+                        dev_dbg(dev, "Failed to get usb2 phy\n");
+                }
+                exynos_ehci->phy_g[phy_number] = phy;
+        }
+
+        return ret;
+}
+
+static int exynos_ehci_phy_enable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
+        int i;
+        int ret = 0;
+
+        if (!IS_ERR(exynos_ehci->phy))
+                return usb_phy_init(exynos_ehci->phy);
+
+        for (i = 0; ret == 0 && i < PHY_NUMBER; i++)
+                if (!IS_ERR(exynos_ehci->phy_g[i]))
+                        ret = phy_power_on(exynos_ehci->phy_g[i]);
+        if (ret)
+                for (i--; i >= 0; i--)
+                        if (!IS_ERR(exynos_ehci->phy_g[i]))
+                                phy_power_off(exynos_ehci->phy_g[i]);
+
+        return ret;
+}
+
+static void exynos_ehci_phy_disable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
+        int i;
+
+        if (!IS_ERR(exynos_ehci->phy)) {
+                usb_phy_shutdown(exynos_ehci->phy);
+                return;
+        }
+
+        for (i = 0; i < PHY_NUMBER; i++)
+                if (!IS_ERR(exynos_ehci->phy_g[i]))
+                        phy_power_off(exynos_ehci->phy_g[i]);
+}
+
+static void exynos_setup_vbus_gpio(struct device *dev)
 {
-        struct device *dev = &pdev->dev;
         int err;
         int gpio;
 
@@ -75,7 +165,6 @@ static int exynos_ehci_probe(struct platform_device *pdev)
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
         struct resource *res;
-        struct usb_phy *phy;
         int irq;
         int err;
 
@@ -88,7 +177,7 @@ static int exynos_ehci_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        exynos_setup_vbus_gpio(pdev);
+        exynos_setup_vbus_gpio(&pdev->dev);
 
         hcd = usb_create_hcd(&exynos_ehci_hc_driver,
                              &pdev->dev, dev_name(&pdev->dev));
@@ -102,15 +191,9 @@ static int exynos_ehci_probe(struct platform_device *pdev)
                                         "samsung,exynos5440-ehci"))
                 goto skip_phy;
 
-        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(phy)) {
-                usb_put_hcd(hcd);
-                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                return -EPROBE_DEFER;
-        } else {
-                exynos_ehci->phy = phy;
-                exynos_ehci->otg = phy->otg;
-        }
+        err = exynos_ehci_get_phy(&pdev->dev, exynos_ehci);
+        if (err)
+                goto fail_clk;
 
 skip_phy:
 
@@ -135,10 +218,9 @@ skip_phy:
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto fail_io;
         }
 
@@ -152,8 +234,11 @@ skip_phy:
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_init(exynos_ehci->phy);
+        err = exynos_ehci_phy_enable(&pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to enable USB phy\n");
+                goto fail_io;
+        }
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
@@ -173,8 +258,7 @@ skip_phy:
         return 0;
 
 fail_add_hcd:
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(&pdev->dev);
 fail_io:
         clk_disable_unprepare(exynos_ehci->clk);
 fail_clk:
@@ -192,8 +276,7 @@ static int exynos_ehci_remove(struct platform_device *pdev)
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
 
@@ -218,8 +301,7 @@ static int exynos_ehci_suspend(struct device *dev)
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
 
@@ -230,14 +312,19 @@ static int exynos_ehci_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
+        int ret;
 
         clk_prepare_enable(exynos_ehci->clk);
 
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_init(exynos_ehci->phy);
+        ret = exynos_ehci_phy_enable(dev);
+        if (ret) {
+                dev_err(dev, "Failed to enable USB phy\n");
+                clk_disable_unprepare(exynos_ehci->clk);
+                return ret;
+        }
 
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 7ae0c4d51741..cc305c71ac3d 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -33,15 +33,6 @@
 
 #ifdef  CONFIG_PM
 
-static int ehci_hub_control(
-        struct usb_hcd  *hcd,
-        u16             typeReq,
-        u16             wValue,
-        u16             wIndex,
-        char            *buf,
-        u16             wLength
-);
-
 static int persist_enabled_on_companion(struct usb_device *udev, void *unused)
 {
         return !udev->maxchild && udev->persist_enabled &&
@@ -865,7 +856,7 @@ cleanup:
 #endif /* CONFIG_USB_HCD_TEST_MODE */
 /*-------------------------------------------------------------------------*/
 
-static int ehci_hub_control (
+int ehci_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -1285,6 +1276,7 @@ error_exit:
         spin_unlock_irqrestore (&ehci->lock, flags);
         return retval;
 }
+EXPORT_SYMBOL_GPL(ehci_hub_control);
 
 static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
 {
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index f341651d6f6c..982c09bebe0f 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -96,10 +96,9 @@ static int ehci_msm_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "ioremap failed\n");
-                ret = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                ret = PTR_ERR(hcd->regs);
                 goto put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index bd61612a7251..08147c35f836 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -176,11 +176,9 @@ static int mv_ehci_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ehci_mv->phy_regs = devm_ioremap(&pdev->dev, r->start,
-                                         resource_size(r));
-        if (!ehci_mv->phy_regs) {
-                dev_err(&pdev->dev, "failed to map phy I/O memory\n");
-                retval = -EFAULT;
+        ehci_mv->phy_regs = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(ehci_mv->phy_regs)) {
+                retval = PTR_ERR(ehci_mv->phy_regs);
                 goto err_put_hcd;
         }
 
@@ -191,11 +189,9 @@ static int mv_ehci_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ehci_mv->cap_regs = devm_ioremap(&pdev->dev, r->start,
-                                         resource_size(r));
-        if (ehci_mv->cap_regs == NULL) {
-                dev_err(&pdev->dev, "failed to map I/O memory\n");
-                retval = -EFAULT;
+        ehci_mv->cap_regs = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(ehci_mv->cap_regs)) {
+                retval = PTR_ERR(ehci_mv->cap_regs);
                 goto err_put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 30d35e5e503a..22e15cab8ea5 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -15,6 +15,7 @@
 #include <linux/clk.h>
 #include <linux/platform_data/usb-ehci-orion.h>
 #include <linux/of.h>
+#include <linux/phy/phy.h>
 #include <linux/of_device.h>
 #include <linux/of_irq.h>
 #include <linux/usb.h>
@@ -42,6 +43,13 @@
 
 #define DRIVER_DESC "EHCI orion driver"
 
+#define hcd_to_orion_priv(h) ((struct orion_ehci_hcd *)hcd_to_ehci(h)->priv)
+
+struct orion_ehci_hcd {
+        struct clk *clk;
+        struct phy *phy;
+};
+
 static const char hcd_name[] = "ehci-orion";
 
 static struct hc_driver __read_mostly ehci_orion_hc_driver;
@@ -137,6 +145,10 @@ ehci_orion_conf_mbus_windows(struct usb_hcd *hcd,
         }
 }
 
+static const struct ehci_driver_overrides orion_overrides __initconst = {
+        .extra_priv_size =      sizeof(struct orion_ehci_hcd),
+};
+
 static int ehci_orion_drv_probe(struct platform_device *pdev)
 {
         struct orion_ehci_data *pd = dev_get_platdata(&pdev->dev);
@@ -144,26 +156,23 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
         struct resource *res;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
-        struct clk *clk;
         void __iomem *regs;
         int irq, err;
         enum orion_ehci_phy_ver phy_version;
+        struct orion_ehci_hcd *priv;
 
         if (usb_disabled())
                 return -ENODEV;
 
         pr_debug("Initializing Orion-SoC USB Host Controller\n");
 
-        if (pdev->dev.of_node)
-                irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
-        else
-                irq = platform_get_irq(pdev, 0);
+        irq = platform_get_irq(pdev, 0);
         if (irq <= 0) {
                 dev_err(&pdev->dev,
                         "Found HC with no IRQ. Check %s setup!\n",
                         dev_name(&pdev->dev));
                 err = -ENODEV;
-                goto err1;
+                goto err;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -172,7 +181,7 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
                         "Found HC with no register addr. Check %s setup!\n",
                         dev_name(&pdev->dev));
                 err = -ENODEV;
-                goto err1;
+                goto err;
         }
 
         /*
@@ -182,25 +191,19 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
          */
         err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
         if (err)
-                goto err1;
+                goto err;
 
         regs = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(regs)) {
                 err = PTR_ERR(regs);
-                goto err1;
+                goto err;
         }
 
-        /* Not all platforms can gate the clock, so it is not
-           an error if the clock does not exists. */
-        clk = devm_clk_get(&pdev->dev, NULL);
-        if (!IS_ERR(clk))
-                clk_prepare_enable(clk);
-
         hcd = usb_create_hcd(&ehci_orion_hc_driver,
                         &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 err = -ENOMEM;
-                goto err2;
+                goto err;
         }
 
         hcd->rsrc_start = res->start;
@@ -211,6 +214,29 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
         ehci->caps = hcd->regs + 0x100;
         hcd->has_tt = 1;
 
+        priv = hcd_to_orion_priv(hcd);
+        /*
+         * Not all platforms can gate the clock, so it is not an error if
+         * the clock does not exists.
+         */
+        priv->clk = devm_clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(priv->clk))
+                clk_prepare_enable(priv->clk);
+
+        priv->phy = devm_phy_optional_get(&pdev->dev, "usb");
+        if (IS_ERR(priv->phy)) {
+                err = PTR_ERR(priv->phy);
+                goto err_phy_get;
+        } else {
+                err = phy_init(priv->phy);
+                if (err)
+                        goto err_phy_init;
+
+                err = phy_power_on(priv->phy);
+                if (err)
+                        goto err_phy_power_on;
+        }
+
         /*
          * (Re-)program MBUS remapping windows if we are asked to.
          */
@@ -240,17 +266,23 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
 
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
-                goto err3;
+                goto err_add_hcd;
 
         device_wakeup_enable(hcd->self.controller);
         return 0;
 
-err3:
+err_add_hcd:
+        if (!IS_ERR(priv->phy))
+                phy_power_off(priv->phy);
+err_phy_power_on:
+        if (!IS_ERR(priv->phy))
+                phy_exit(priv->phy);
+err_phy_init:
+err_phy_get:
+        if (!IS_ERR(priv->clk))
+                clk_disable_unprepare(priv->clk);
         usb_put_hcd(hcd);
-err2:
-        if (!IS_ERR(clk))
-                clk_disable_unprepare(clk);
-err1:
+err:
         dev_err(&pdev->dev, "init %s fail, %d\n",
                 dev_name(&pdev->dev), err);
 
@@ -260,14 +292,20 @@ err1:
 static int ehci_orion_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct clk *clk;
+        struct orion_ehci_hcd *priv = hcd_to_orion_priv(hcd);
 
         usb_remove_hcd(hcd);
+
+        if (!IS_ERR(priv->phy)) {
+                phy_power_off(priv->phy);
+                phy_exit(priv->phy);
+        }
+
+        if (!IS_ERR(priv->clk))
+                clk_disable_unprepare(priv->clk);
+
         usb_put_hcd(hcd);
 
-        clk = devm_clk_get(&pdev->dev, NULL);
-        if (!IS_ERR(clk))
-                clk_disable_unprepare(clk);
         return 0;
 }
 
@@ -295,7 +333,7 @@ static int __init ehci_orion_init(void)
 
         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 
-        ehci_init_driver(&ehci_orion_hc_driver, NULL);
+        ehci_init_driver(&ehci_orion_hc_driver, &orion_overrides);
         return platform_driver_register(&ehci_orion_driver);
 }
 module_init(ehci_orion_init);
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index c7dd93aad20c..2f5b9ce3e042 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -29,6 +29,7 @@
 #include <linux/of.h>
 #include <linux/phy/phy.h>
 #include <linux/platform_device.h>
+#include <linux/reset.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
 #include <linux/usb/ehci_pdriver.h>
@@ -41,6 +42,7 @@
 
 struct ehci_platform_priv {
         struct clk *clks[EHCI_MAX_CLKS];
+        struct reset_control *rst;
         struct phy *phy;
 };
 
@@ -208,6 +210,18 @@ static int ehci_platform_probe(struct platform_device *dev)
                 }
         }
 
+        priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->rst = NULL;
+        } else {
+                err = reset_control_deassert(priv->rst);
+                if (err)
+                        goto err_put_clks;
+        }
+
         if (pdata->big_endian_desc)
                 ehci->big_endian_desc = 1;
         if (pdata->big_endian_mmio)
@@ -218,7 +232,7 @@ static int ehci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
@@ -226,14 +240,14 @@ static int ehci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        goto err_put_clks;
+                        goto err_reset;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -256,6 +270,9 @@ static int ehci_platform_probe(struct platform_device *dev)
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_reset:
+        if (priv->rst)
+                reset_control_assert(priv->rst);
 err_put_clks:
         while (--clk >= 0)
                 clk_put(priv->clks[clk]);
@@ -280,6 +297,9 @@ static int ehci_platform_remove(struct platform_device *dev)
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        if (priv->rst)
+                reset_control_assert(priv->rst);
+
         for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
                 clk_put(priv->clks[clk]);
 
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 8bd915b2ae8c..1d59958ad0ce 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -106,16 +106,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        if (!devm_request_mem_region(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                retval = -EBUSY;
-                goto err_put_hcd;
-        }
-
-        hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
-        if (hcd->regs == NULL) {
-                dev_dbg(&pdev->dev, "error mapping memory\n");
-                retval = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                retval = PTR_ERR(hcd->regs);
                 goto err_put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 7ef00ecb0da1..6fdcb8ad2296 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -51,10 +51,6 @@ struct tegra_ehci_soc_config {
         bool has_hostpc;
 };
 
-static int (*orig_hub_control)(struct usb_hcd *hcd,
-                                u16 typeReq, u16 wValue, u16 wIndex,
-                                char *buf, u16 wLength);
-
 struct tegra_ehci_hcd {
         struct tegra_usb_phy *phy;
         struct clk *clk;
@@ -236,7 +232,7 @@ static int tegra_ehci_hub_control(
         spin_unlock_irqrestore(&ehci->lock, flags);
 
         /* Handle the hub control events here */
-        return orig_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        return ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
 
 done:
         spin_unlock_irqrestore(&ehci->lock, flags);
@@ -415,10 +411,9 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto cleanup_clk_en;
         }
         ehci->caps = hcd->regs + 0x100;
@@ -554,8 +549,6 @@ static int __init ehci_tegra_init(void)
          * too easy.
          */
 
-        orig_hub_control = tegra_ehci_hc_driver.hub_control;
-
         tegra_ehci_hc_driver.map_urb_for_dma = tegra_ehci_map_urb_for_dma;
         tegra_ehci_hc_driver.unmap_urb_for_dma = tegra_ehci_unmap_urb_for_dma;
         tegra_ehci_hc_driver.hub_control = tegra_ehci_hub_control;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 9dfc6c1394d6..eee228a26a0e 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -872,4 +872,7 @@ extern int	ehci_suspend(struct usb_hcd *hcd, bool do_wakeup);
 extern int      ehci_resume(struct usb_hcd *hcd, bool hibernated);
 #endif  /* CONFIG_PM */
 
+extern int      ehci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                 u16 wIndex, char *buf, u16 wLength);
+
 #endif /* __LINUX_EHCI_HCD_H */
diff --git a/drivers/usb/host/max3421-hcd.c b/drivers/usb/host/max3421-hcd.c
new file mode 100644
index 000000000000..858efcfda50b
--- /dev/null
+++ b/drivers/usb/host/max3421-hcd.c
@@ -0,0 +1,1957 @@
+/*
+ * MAX3421 Host Controller driver for USB.
+ *
+ * Author: David Mosberger-Tang <davidm@egauge.net>
+ *
+ * (C) Copyright 2014 David Mosberger-Tang <davidm@egauge.net>
+ *
+ * MAX3421 is a chip implementing a USB 2.0 Full-/Low-Speed host
+ * controller on a SPI bus.
+ *
+ * Based on:
+ *      o MAX3421E datasheet
+ *              http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf
+ *      o MAX3421E Programming Guide
+ *              http://www.hdl.co.jp/ftpdata/utl-001/AN3785.pdf
+ *      o gadget/dummy_hcd.c
+ *              For USB HCD implementation.
+ *      o Arduino MAX3421 driver
+ *           https://github.com/felis/USB_Host_Shield_2.0/blob/master/Usb.cpp
+ *
+ * This file is licenced under the GPL v2.
+ *
+ * Important note on worst-case (full-speed) packet size constraints
+ * (See USB 2.0 Section 5.6.3 and following):
+ *
+ *      - control:        64 bytes
+ *      - isochronous:  1023 bytes
+ *      - interrupt:      64 bytes
+ *      - bulk:           64 bytes
+ *
+ * Since the MAX3421 FIFO size is 64 bytes, we do not have to work about
+ * multi-FIFO writes/reads for a single USB packet *except* for isochronous
+ * transfers.  We don't support isochronous transfers at this time, so we
+ * just assume that a USB packet always fits into a single FIFO buffer.
+ *
+ * NOTE: The June 2006 version of "MAX3421E Programming Guide"
+ * (AN3785) has conflicting info for the RCVDAVIRQ bit:
+ *
+ *      The description of RCVDAVIRQ says "The CPU *must* clear
+ *      this IRQ bit (by writing a 1 to it) before reading the
+ *      RCVFIFO data.
+ *
+ * However, the earlier section on "Programming BULK-IN
+ * Transfers" says * that:
+ *
+ *      After the CPU retrieves the data, it clears the
+ *      RCVDAVIRQ bit.
+ *
+ * The December 2006 version has been corrected and it consistently
+ * states the second behavior is the correct one.
+ *
+ * Synchronous SPI transactions sleep so we can't perform any such
+ * transactions while holding a spin-lock (and/or while interrupts are
+ * masked).  To achieve this, all SPI transactions are issued from a
+ * single thread (max3421_spi_thread).
+ */
+
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include <linux/platform_data/max3421-hcd.h>
+
+#define DRIVER_DESC     "MAX3421 USB Host-Controller Driver"
+#define DRIVER_VERSION  "1.0"
+
+/* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */
+#define USB_MAX_FRAME_NUMBER    0x7ff
+#define USB_MAX_RETRIES         3 /* # of retries before error is reported */
+
+/*
+ * Max. # of times we're willing to retransmit a request immediately in
+ * resposne to a NAK.  Afterwards, we fall back on trying once a frame.
+ */
+#define NAK_MAX_FAST_RETRANSMITS        2
+
+#define POWER_BUDGET    500     /* in mA; use 8 for low-power port testing */
+
+/* Port-change mask: */
+#define PORT_C_MASK     ((USB_PORT_STAT_C_CONNECTION |  \
+                          USB_PORT_STAT_C_ENABLE |      \
+                          USB_PORT_STAT_C_SUSPEND |     \
+                          USB_PORT_STAT_C_OVERCURRENT | \
+                          USB_PORT_STAT_C_RESET) << 16)
+
+enum max3421_rh_state {
+        MAX3421_RH_RESET,
+        MAX3421_RH_SUSPENDED,
+        MAX3421_RH_RUNNING
+};
+
+enum pkt_state {
+        PKT_STATE_SETUP,        /* waiting to send setup packet to ctrl pipe */
+        PKT_STATE_TRANSFER,     /* waiting to xfer transfer_buffer */
+        PKT_STATE_TERMINATE     /* waiting to terminate control transfer */
+};
+
+enum scheduling_pass {
+        SCHED_PASS_PERIODIC,
+        SCHED_PASS_NON_PERIODIC,
+        SCHED_PASS_DONE
+};
+
+struct max3421_dma_buf {
+        u8 data[2];
+};
+
+struct max3421_hcd {
+        spinlock_t lock;
+
+        struct task_struct *spi_thread;
+
+        struct max3421_hcd *next;
+
+        enum max3421_rh_state rh_state;
+        /* lower 16 bits contain port status, upper 16 bits the change mask: */
+        u32 port_status;
+
+        unsigned active:1;
+
+        struct list_head ep_list;       /* list of EP's with work */
+
+        /*
+         * The following are owned by spi_thread (may be accessed by
+         * SPI-thread without acquiring the HCD lock:
+         */
+        u8 rev;                         /* chip revision */
+        u16 frame_number;
+        /*
+         * kmalloc'd buffers guaranteed to be in separate (DMA)
+         * cache-lines:
+         */
+        struct max3421_dma_buf *tx;
+        struct max3421_dma_buf *rx;
+        /*
+         * URB we're currently processing.  Must not be reset to NULL
+         * unless MAX3421E chip is idle:
+         */
+        struct urb *curr_urb;
+        enum scheduling_pass sched_pass;
+        struct usb_device *loaded_dev;  /* dev that's loaded into the chip */
+        int loaded_epnum;               /* epnum whose toggles are loaded */
+        int urb_done;                   /* > 0 -> no errors, < 0: errno */
+        size_t curr_len;
+        u8 hien;
+        u8 mode;
+        u8 iopins[2];
+        unsigned int do_enable_irq:1;
+        unsigned int do_reset_hcd:1;
+        unsigned int do_reset_port:1;
+        unsigned int do_check_unlink:1;
+        unsigned int do_iopin_update:1;
+#ifdef DEBUG
+        unsigned long err_stat[16];
+#endif
+};
+
+struct max3421_ep {
+        struct usb_host_endpoint *ep;
+        struct list_head ep_list;
+        u32 naks;
+        u16 last_active;                /* frame # this ep was last active */
+        enum pkt_state pkt_state;
+        u8 retries;
+        u8 retransmit;                  /* packet needs retransmission */
+};
+
+static struct max3421_hcd *max3421_hcd_list;
+
+#define MAX3421_FIFO_SIZE       64
+
+#define MAX3421_SPI_DIR_RD      0       /* read register from MAX3421 */
+#define MAX3421_SPI_DIR_WR      1       /* write register to MAX3421 */
+
+/* SPI commands: */
+#define MAX3421_SPI_DIR_SHIFT   1
+#define MAX3421_SPI_REG_SHIFT   3
+
+#define MAX3421_REG_RCVFIFO     1
+#define MAX3421_REG_SNDFIFO     2
+#define MAX3421_REG_SUDFIFO     4
+#define MAX3421_REG_RCVBC       6
+#define MAX3421_REG_SNDBC       7
+#define MAX3421_REG_USBIRQ      13
+#define MAX3421_REG_USBIEN      14
+#define MAX3421_REG_USBCTL      15
+#define MAX3421_REG_CPUCTL      16
+#define MAX3421_REG_PINCTL      17
+#define MAX3421_REG_REVISION    18
+#define MAX3421_REG_IOPINS1     20
+#define MAX3421_REG_IOPINS2     21
+#define MAX3421_REG_GPINIRQ     22
+#define MAX3421_REG_GPINIEN     23
+#define MAX3421_REG_GPINPOL     24
+#define MAX3421_REG_HIRQ        25
+#define MAX3421_REG_HIEN        26
+#define MAX3421_REG_MODE        27
+#define MAX3421_REG_PERADDR     28
+#define MAX3421_REG_HCTL        29
+#define MAX3421_REG_HXFR        30
+#define MAX3421_REG_HRSL        31
+
+enum {
+        MAX3421_USBIRQ_OSCOKIRQ_BIT = 0,
+        MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5,
+        MAX3421_USBIRQ_VBUSIRQ_BIT
+};
+
+enum {
+        MAX3421_CPUCTL_IE_BIT = 0,
+        MAX3421_CPUCTL_PULSEWID0_BIT = 6,
+        MAX3421_CPUCTL_PULSEWID1_BIT
+};
+
+enum {
+        MAX3421_USBCTL_PWRDOWN_BIT = 4,
+        MAX3421_USBCTL_CHIPRES_BIT
+};
+
+enum {
+        MAX3421_PINCTL_GPXA_BIT = 0,
+        MAX3421_PINCTL_GPXB_BIT,
+        MAX3421_PINCTL_POSINT_BIT,
+        MAX3421_PINCTL_INTLEVEL_BIT,
+        MAX3421_PINCTL_FDUPSPI_BIT,
+        MAX3421_PINCTL_EP0INAK_BIT,
+        MAX3421_PINCTL_EP2INAK_BIT,
+        MAX3421_PINCTL_EP3INAK_BIT,
+};
+
+enum {
+        MAX3421_HI_BUSEVENT_BIT = 0,    /* bus-reset/-resume */
+        MAX3421_HI_RWU_BIT,             /* remote wakeup */
+        MAX3421_HI_RCVDAV_BIT,          /* receive FIFO data available */
+        MAX3421_HI_SNDBAV_BIT,          /* send buffer available */
+        MAX3421_HI_SUSDN_BIT,           /* suspend operation done */
+        MAX3421_HI_CONDET_BIT,          /* peripheral connect/disconnect */
+        MAX3421_HI_FRAME_BIT,           /* frame generator */
+        MAX3421_HI_HXFRDN_BIT,          /* host transfer done */
+};
+
+enum {
+        MAX3421_HCTL_BUSRST_BIT = 0,
+        MAX3421_HCTL_FRMRST_BIT,
+        MAX3421_HCTL_SAMPLEBUS_BIT,
+        MAX3421_HCTL_SIGRSM_BIT,
+        MAX3421_HCTL_RCVTOG0_BIT,
+        MAX3421_HCTL_RCVTOG1_BIT,
+        MAX3421_HCTL_SNDTOG0_BIT,
+        MAX3421_HCTL_SNDTOG1_BIT
+};
+
+enum {
+        MAX3421_MODE_HOST_BIT = 0,
+        MAX3421_MODE_LOWSPEED_BIT,
+        MAX3421_MODE_HUBPRE_BIT,
+        MAX3421_MODE_SOFKAENAB_BIT,
+        MAX3421_MODE_SEPIRQ_BIT,
+        MAX3421_MODE_DELAYISO_BIT,
+        MAX3421_MODE_DMPULLDN_BIT,
+        MAX3421_MODE_DPPULLDN_BIT
+};
+
+enum {
+        MAX3421_HRSL_OK = 0,
+        MAX3421_HRSL_BUSY,
+        MAX3421_HRSL_BADREQ,
+        MAX3421_HRSL_UNDEF,
+        MAX3421_HRSL_NAK,
+        MAX3421_HRSL_STALL,
+        MAX3421_HRSL_TOGERR,
+        MAX3421_HRSL_WRONGPID,
+        MAX3421_HRSL_BADBC,
+        MAX3421_HRSL_PIDERR,
+        MAX3421_HRSL_PKTERR,
+        MAX3421_HRSL_CRCERR,
+        MAX3421_HRSL_KERR,
+        MAX3421_HRSL_JERR,
+        MAX3421_HRSL_TIMEOUT,
+        MAX3421_HRSL_BABBLE,
+        MAX3421_HRSL_RESULT_MASK = 0xf,
+        MAX3421_HRSL_RCVTOGRD_BIT = 4,
+        MAX3421_HRSL_SNDTOGRD_BIT,
+        MAX3421_HRSL_KSTATUS_BIT,
+        MAX3421_HRSL_JSTATUS_BIT
+};
+
+/* Return same error-codes as ohci.h:cc_to_error: */
+static const int hrsl_to_error[] = {
+        [MAX3421_HRSL_OK] =             0,
+        [MAX3421_HRSL_BUSY] =           -EINVAL,
+        [MAX3421_HRSL_BADREQ] =         -EINVAL,
+        [MAX3421_HRSL_UNDEF] =          -EINVAL,
+        [MAX3421_HRSL_NAK] =            -EAGAIN,
+        [MAX3421_HRSL_STALL] =          -EPIPE,
+        [MAX3421_HRSL_TOGERR] =         -EILSEQ,
+        [MAX3421_HRSL_WRONGPID] =       -EPROTO,
+        [MAX3421_HRSL_BADBC] =          -EREMOTEIO,
+        [MAX3421_HRSL_PIDERR] =         -EPROTO,
+        [MAX3421_HRSL_PKTERR] =         -EPROTO,
+        [MAX3421_HRSL_CRCERR] =         -EILSEQ,
+        [MAX3421_HRSL_KERR] =           -EIO,
+        [MAX3421_HRSL_JERR] =           -EIO,
+        [MAX3421_HRSL_TIMEOUT] =        -ETIME,
+        [MAX3421_HRSL_BABBLE] =         -EOVERFLOW
+};
+
+/*
+ * See http://www.beyondlogic.org/usbnutshell/usb4.shtml#Control for a
+ * reasonable overview of how control transfers use the the IN/OUT
+ * tokens.
+ */
+#define MAX3421_HXFR_BULK_IN(ep)        (0x00 | (ep))   /* bulk or interrupt */
+#define MAX3421_HXFR_SETUP               0x10
+#define MAX3421_HXFR_BULK_OUT(ep)       (0x20 | (ep))   /* bulk or interrupt */
+#define MAX3421_HXFR_ISO_IN(ep)         (0x40 | (ep))
+#define MAX3421_HXFR_ISO_OUT(ep)        (0x60 | (ep))
+#define MAX3421_HXFR_HS_IN               0x80           /* handshake in */
+#define MAX3421_HXFR_HS_OUT              0xa0           /* handshake out */
+
+#define field(val, bit) ((val) << (bit))
+
+static inline s16
+frame_diff(u16 left, u16 right)
+{
+        return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1);
+}
+
+static inline struct max3421_hcd *
+hcd_to_max3421(struct usb_hcd *hcd)
+{
+        return (struct max3421_hcd *) hcd->hcd_priv;
+}
+
+static inline struct usb_hcd *
+max3421_to_hcd(struct max3421_hcd *max3421_hcd)
+{
+        return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv);
+}
+
+static u8
+spi_rd8(struct usb_hcd *hcd, unsigned int reg)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct spi_transfer transfer;
+        struct spi_message msg;
+
+        memset(&transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
+
+        transfer.tx_buf = max3421_hcd->tx->data;
+        transfer.rx_buf = max3421_hcd->rx->data;
+        transfer.len = 2;
+
+        spi_message_add_tail(&transfer, &msg);
+        spi_sync(spi, &msg);
+
+        return max3421_hcd->rx->data[1];
+}
+
+static void
+spi_wr8(struct usb_hcd *hcd, unsigned int reg, u8 val)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer;
+        struct spi_message msg;
+
+        memset(&transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
+        max3421_hcd->tx->data[1] = val;
+
+        transfer.tx_buf = max3421_hcd->tx->data;
+        transfer.len = 2;
+
+        spi_message_add_tail(&transfer, &msg);
+        spi_sync(spi, &msg);
+}
+
+static void
+spi_rd_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer[2];
+        struct spi_message msg;
+
+        memset(transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
+        transfer[0].tx_buf = max3421_hcd->tx->data;
+        transfer[0].len = 1;
+
+        transfer[1].rx_buf = buf;
+        transfer[1].len = len;
+
+        spi_message_add_tail(&transfer[0], &msg);
+        spi_message_add_tail(&transfer[1], &msg);
+        spi_sync(spi, &msg);
+}
+
+static void
+spi_wr_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer[2];
+        struct spi_message msg;
+
+        memset(transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
+
+        transfer[0].tx_buf = max3421_hcd->tx->data;
+        transfer[0].len = 1;
+
+        transfer[1].tx_buf = buf;
+        transfer[1].len = len;
+
+        spi_message_add_tail(&transfer[0], &msg);
+        spi_message_add_tail(&transfer[1], &msg);
+        spi_sync(spi, &msg);
+}
+
+/*
+ * Figure out the correct setting for the LOWSPEED and HUBPRE mode
+ * bits.  The HUBPRE bit needs to be set when MAX3421E operates at
+ * full speed, but it's talking to a low-speed device (i.e., through a
+ * hub).  Setting that bit ensures that every low-speed packet is
+ * preceded by a full-speed PRE PID.  Possible configurations:
+ *
+ * Hub speed:   Device speed:   =>      LOWSPEED bit:   HUBPRE bit:
+ *      FULL    FULL            =>      0               0
+ *      FULL    LOW             =>      1               1
+ *      LOW     LOW             =>      1               0
+ *      LOW     FULL            =>      1               0
+ */
+static void
+max3421_set_speed(struct usb_hcd *hcd, struct usb_device *dev)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 mode_lowspeed, mode_hubpre, mode = max3421_hcd->mode;
+
+        mode_lowspeed = BIT(MAX3421_MODE_LOWSPEED_BIT);
+        mode_hubpre   = BIT(MAX3421_MODE_HUBPRE_BIT);
+        if (max3421_hcd->port_status & USB_PORT_STAT_LOW_SPEED) {
+                mode |=  mode_lowspeed;
+                mode &= ~mode_hubpre;
+        } else if (dev->speed == USB_SPEED_LOW) {
+                mode |= mode_lowspeed | mode_hubpre;
+        } else {
+                mode &= ~(mode_lowspeed | mode_hubpre);
+        }
+        if (mode != max3421_hcd->mode) {
+                max3421_hcd->mode = mode;
+                spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+        }
+
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_set_address(struct usb_hcd *hcd, struct usb_device *dev, int epnum,
+                    int force_toggles)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int old_epnum, same_ep, rcvtog, sndtog;
+        struct usb_device *old_dev;
+        u8 hctl;
+
+        old_dev = max3421_hcd->loaded_dev;
+        old_epnum = max3421_hcd->loaded_epnum;
+
+        same_ep = (dev == old_dev && epnum == old_epnum);
+        if (same_ep && !force_toggles)
+                return;
+
+        if (old_dev && !same_ep) {
+                /* save the old end-points toggles: */
+                u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+
+                rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1;
+                sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
+
+                /* no locking: HCD (i.e., we) own toggles, don't we? */
+                usb_settoggle(old_dev, old_epnum, 0, rcvtog);
+                usb_settoggle(old_dev, old_epnum, 1, sndtog);
+        }
+        /* setup new endpoint's toggle bits: */
+        rcvtog = usb_gettoggle(dev, epnum, 0);
+        sndtog = usb_gettoggle(dev, epnum, 1);
+        hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) |
+                BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
+
+        max3421_hcd->loaded_epnum = epnum;
+        spi_wr8(hcd, MAX3421_REG_HCTL, hctl);
+
+        /*
+         * Note: devnum for one and the same device can change during
+         * address-assignment so it's best to just always load the
+         * address whenever the end-point changed/was forced.
+         */
+        max3421_hcd->loaded_dev = dev;
+        spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum);
+}
+
+static int
+max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb)
+{
+        spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8);
+        return MAX3421_HXFR_SETUP;
+}
+
+static int
+max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int epnum = usb_pipeendpoint(urb->pipe);
+
+        max3421_hcd->curr_len = 0;
+        max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT);
+        return MAX3421_HXFR_BULK_IN(epnum);
+}
+
+static int
+max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int epnum = usb_pipeendpoint(urb->pipe);
+        u32 max_packet;
+        void *src;
+
+        src = urb->transfer_buffer + urb->actual_length;
+
+        if (fast_retransmit) {
+                if (max3421_hcd->rev == 0x12) {
+                        /* work around rev 0x12 bug: */
+                        spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
+                        spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]);
+                        spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
+                }
+                return MAX3421_HXFR_BULK_OUT(epnum);
+        }
+
+        max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
+
+        if (max_packet > MAX3421_FIFO_SIZE) {
+                /*
+                 * We do not support isochronous transfers at this
+                 * time.
+                 */
+                dev_err(&spi->dev,
+                        "%s: packet-size of %u too big (limit is %u bytes)",
+                        __func__, max_packet, MAX3421_FIFO_SIZE);
+                max3421_hcd->urb_done = -EMSGSIZE;
+                return -EMSGSIZE;
+        }
+        max3421_hcd->curr_len = min((urb->transfer_buffer_length -
+                                     urb->actual_length), max_packet);
+
+        spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len);
+        spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
+        return MAX3421_HXFR_BULK_OUT(epnum);
+}
+
+/*
+ * Issue the next host-transfer command.
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+        int cmd = -EINVAL;
+
+        if (!urb)
+                return; /* nothing to do */
+
+        max3421_ep = urb->ep->hcpriv;
+
+        switch (max3421_ep->pkt_state) {
+        case PKT_STATE_SETUP:
+                cmd = max3421_ctrl_setup(hcd, urb);
+                break;
+
+        case PKT_STATE_TRANSFER:
+                if (usb_urb_dir_in(urb))
+                        cmd = max3421_transfer_in(hcd, urb);
+                else
+                        cmd = max3421_transfer_out(hcd, urb, fast_retransmit);
+                break;
+
+        case PKT_STATE_TERMINATE:
+                /*
+                 * IN transfers are terminated with HS_OUT token,
+                 * OUT transfers with HS_IN:
+                 */
+                if (usb_urb_dir_in(urb))
+                        cmd = MAX3421_HXFR_HS_OUT;
+                else
+                        cmd = MAX3421_HXFR_HS_IN;
+                break;
+        }
+
+        if (cmd < 0)
+                return;
+
+        /* issue the command and wait for host-xfer-done interrupt: */
+
+        spi_wr8(hcd, MAX3421_REG_HXFR, cmd);
+        max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT);
+}
+
+/*
+ * Find the next URB to process and start its execution.
+ *
+ * At this time, we do not anticipate ever connecting a USB hub to the
+ * MAX3421 chip, so at most USB device can be connected and we can use
+ * a simplistic scheduler: at the start of a frame, schedule all
+ * periodic transfers.  Once that is done, use the remainder of the
+ * frame to process non-periodic (bulk & control) transfers.
+ *
+ * Preconditions:
+ * o Caller must NOT hold HCD spinlock.
+ * o max3421_hcd->curr_urb MUST BE NULL.
+ * o MAX3421E chip must be idle.
+ */
+static int
+max3421_select_and_start_urb(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb, *curr_urb = NULL;
+        struct max3421_ep *max3421_ep;
+        int epnum, force_toggles = 0;
+        struct usb_host_endpoint *ep;
+        struct list_head *pos;
+        unsigned long flags;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        for (;
+             max3421_hcd->sched_pass < SCHED_PASS_DONE;
+             ++max3421_hcd->sched_pass)
+                list_for_each(pos, &max3421_hcd->ep_list) {
+                        urb = NULL;
+                        max3421_ep = container_of(pos, struct max3421_ep,
+                                                  ep_list);
+                        ep = max3421_ep->ep;
+
+                        switch (usb_endpoint_type(&ep->desc)) {
+                        case USB_ENDPOINT_XFER_ISOC:
+                        case USB_ENDPOINT_XFER_INT:
+                                if (max3421_hcd->sched_pass !=
+                                    SCHED_PASS_PERIODIC)
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_CONTROL:
+                        case USB_ENDPOINT_XFER_BULK:
+                                if (max3421_hcd->sched_pass !=
+                                    SCHED_PASS_NON_PERIODIC)
+                                        continue;
+                                break;
+                        }
+
+                        if (list_empty(&ep->urb_list))
+                                continue;       /* nothing to do */
+                        urb = list_first_entry(&ep->urb_list, struct urb,
+                                               urb_list);
+                        if (urb->unlinked) {
+                                dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
+                                        __func__, urb, urb->unlinked);
+                                max3421_hcd->curr_urb = urb;
+                                max3421_hcd->urb_done = 1;
+                                spin_unlock_irqrestore(&max3421_hcd->lock,
+                                                       flags);
+                                return 1;
+                        }
+
+                        switch (usb_endpoint_type(&ep->desc)) {
+                        case USB_ENDPOINT_XFER_CONTROL:
+                                /*
+                                 * Allow one control transaction per
+                                 * frame per endpoint:
+                                 */
+                                if (frame_diff(max3421_ep->last_active,
+                                               max3421_hcd->frame_number) == 0)
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_BULK:
+                                if (max3421_ep->retransmit
+                                    && (frame_diff(max3421_ep->last_active,
+                                                   max3421_hcd->frame_number)
+                                        == 0))
+                                        /*
+                                         * We already tried this EP
+                                         * during this frame and got a
+                                         * NAK or error; wait for next frame
+                                         */
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_ISOC:
+                        case USB_ENDPOINT_XFER_INT:
+                                if (frame_diff(max3421_hcd->frame_number,
+                                               max3421_ep->last_active)
+                                    < urb->interval)
+                                        /*
+                                         * We already processed this
+                                         * end-point in the current
+                                         * frame
+                                         */
+                                        continue;
+                                break;
+                        }
+
+                        /* move current ep to tail: */
+                        list_move_tail(pos, &max3421_hcd->ep_list);
+                        curr_urb = urb;
+                        goto done;
+                }
+done:
+        if (!curr_urb) {
+                spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+                return 0;
+        }
+
+        urb = max3421_hcd->curr_urb = curr_urb;
+        epnum = usb_endpoint_num(&urb->ep->desc);
+        if (max3421_ep->retransmit)
+                /* restart (part of) a USB transaction: */
+                max3421_ep->retransmit = 0;
+        else {
+                /* start USB transaction: */
+                if (usb_endpoint_xfer_control(&ep->desc)) {
+                        /*
+                         * See USB 2.0 spec section 8.6.1
+                         * Initialization via SETUP Token:
+                         */
+                        usb_settoggle(urb->dev, epnum, 0, 1);
+                        usb_settoggle(urb->dev, epnum, 1, 1);
+                        max3421_ep->pkt_state = PKT_STATE_SETUP;
+                        force_toggles = 1;
+                } else
+                        max3421_ep->pkt_state = PKT_STATE_TRANSFER;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+        max3421_ep->last_active = max3421_hcd->frame_number;
+        max3421_set_address(hcd, urb->dev, epnum, force_toggles);
+        max3421_set_speed(hcd, urb->dev);
+        max3421_next_transfer(hcd, 0);
+        return 1;
+}
+
+/*
+ * Check all endpoints for URBs that got unlinked.
+ *
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_check_unlink(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct list_head *pos, *upos, *next_upos;
+        struct max3421_ep *max3421_ep;
+        struct usb_host_endpoint *ep;
+        struct urb *urb;
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        list_for_each(pos, &max3421_hcd->ep_list) {
+                max3421_ep = container_of(pos, struct max3421_ep, ep_list);
+                ep = max3421_ep->ep;
+                list_for_each_safe(upos, next_upos, &ep->urb_list) {
+                        urb = container_of(upos, struct urb, urb_list);
+                        if (urb->unlinked) {
+                                retval = 1;
+                                dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
+                                        __func__, urb, urb->unlinked);
+                                usb_hcd_unlink_urb_from_ep(hcd, urb);
+                                spin_unlock_irqrestore(&max3421_hcd->lock,
+                                                       flags);
+                                usb_hcd_giveback_urb(hcd, urb, 0);
+                                spin_lock_irqsave(&max3421_hcd->lock, flags);
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_slow_retransmit(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+
+        max3421_ep = urb->ep->hcpriv;
+        max3421_ep->retransmit = 1;
+        max3421_hcd->curr_urb = NULL;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_recv_data_available(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        size_t remaining, transfer_size;
+        u8 rcvbc;
+
+        rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC);
+
+        if (rcvbc > MAX3421_FIFO_SIZE)
+                rcvbc = MAX3421_FIFO_SIZE;
+        if (urb->actual_length >= urb->transfer_buffer_length)
+                remaining = 0;
+        else
+                remaining = urb->transfer_buffer_length - urb->actual_length;
+        transfer_size = rcvbc;
+        if (transfer_size > remaining)
+                transfer_size = remaining;
+        if (transfer_size > 0) {
+                void *dst = urb->transfer_buffer + urb->actual_length;
+
+                spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);
+                urb->actual_length += transfer_size;
+                max3421_hcd->curr_len = transfer_size;
+        }
+
+        /* ack the RCVDAV irq now that the FIFO has been read: */
+        spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT));
+}
+
+static void
+max3421_handle_error(struct usb_hcd *hcd, u8 hrsl)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep = urb->ep->hcpriv;
+        int switch_sndfifo;
+
+        /*
+         * If an OUT command results in any response other than OK
+         * (i.e., error or NAK), we have to perform a dummy-write to
+         * SNDBC so the FIFO gets switched back to us.  Otherwise, we
+         * get out of sync with the SNDFIFO double buffer.
+         */
+        switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER &&
+                          usb_urb_dir_out(urb));
+
+        switch (result_code) {
+        case MAX3421_HRSL_OK:
+                return;                 /* this shouldn't happen */
+
+        case MAX3421_HRSL_WRONGPID:     /* received wrong PID */
+        case MAX3421_HRSL_BUSY:         /* SIE busy */
+        case MAX3421_HRSL_BADREQ:       /* bad val in HXFR */
+        case MAX3421_HRSL_UNDEF:        /* reserved */
+        case MAX3421_HRSL_KERR:         /* K-state instead of response */
+        case MAX3421_HRSL_JERR:         /* J-state instead of response */
+                /*
+                 * packet experienced an error that we cannot recover
+                 * from; report error
+                 */
+                max3421_hcd->urb_done = hrsl_to_error[result_code];
+                dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                        __func__, hrsl);
+                break;
+
+        case MAX3421_HRSL_TOGERR:
+                if (usb_urb_dir_in(urb))
+                        ; /* don't do anything (device will switch toggle) */
+                else {
+                        /* flip the send toggle bit: */
+                        int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
+
+                        sndtog ^= 1;
+                        spi_wr8(hcd, MAX3421_REG_HCTL,
+                                BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
+                }
+                /* FALL THROUGH */
+        case MAX3421_HRSL_BADBC:        /* bad byte count */
+        case MAX3421_HRSL_PIDERR:       /* received PID is corrupted */
+        case MAX3421_HRSL_PKTERR:       /* packet error (stuff, EOP) */
+        case MAX3421_HRSL_CRCERR:       /* CRC error */
+        case MAX3421_HRSL_BABBLE:       /* device talked too long */
+        case MAX3421_HRSL_TIMEOUT:
+                if (max3421_ep->retries++ < USB_MAX_RETRIES)
+                        /* retry the packet again in the next frame */
+                        max3421_slow_retransmit(hcd);
+                else {
+                        /* Based on ohci.h cc_to_err[]: */
+                        max3421_hcd->urb_done = hrsl_to_error[result_code];
+                        dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                                __func__, hrsl);
+                }
+                break;
+
+        case MAX3421_HRSL_STALL:
+                dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                        __func__, hrsl);
+                max3421_hcd->urb_done = hrsl_to_error[result_code];
+                break;
+
+        case MAX3421_HRSL_NAK:
+                /*
+                 * Device wasn't ready for data or has no data
+                 * available: retry the packet again.
+                 */
+                if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) {
+                        max3421_next_transfer(hcd, 1);
+                        switch_sndfifo = 0;
+                } else
+                        max3421_slow_retransmit(hcd);
+                break;
+        }
+        if (switch_sndfifo)
+                spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u32 max_packet;
+
+        if (urb->actual_length >= urb->transfer_buffer_length)
+                return 1;       /* read is complete, so we're done */
+
+        /*
+         * USB 2.0 Section 5.3.2 Pipes: packets must be full size
+         * except for last one.
+         */
+        max_packet = usb_maxpacket(urb->dev, urb->pipe, 0);
+        if (max_packet > MAX3421_FIFO_SIZE) {
+                /*
+                 * We do not support isochronous transfers at this
+                 * time...
+                 */
+                dev_err(&spi->dev,
+                        "%s: packet-size of %u too big (limit is %u bytes)",
+                        __func__, max_packet, MAX3421_FIFO_SIZE);
+                return -EINVAL;
+        }
+
+        if (max3421_hcd->curr_len < max_packet) {
+                if (urb->transfer_flags & URB_SHORT_NOT_OK) {
+                        /*
+                         * remaining > 0 and received an
+                         * unexpected partial packet ->
+                         * error
+                         */
+                        return -EREMOTEIO;
+                } else
+                        /* short read, but it's OK */
+                        return 1;
+        }
+        return 0;       /* not done */
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        urb->actual_length += max3421_hcd->curr_len;
+        if (urb->actual_length < urb->transfer_buffer_length)
+                return 0;
+        if (urb->transfer_flags & URB_ZERO_PACKET) {
+                /*
+                 * Some hardware needs a zero-size packet at the end
+                 * of a bulk-out transfer if the last transfer was a
+                 * full-sized packet (i.e., such hardware use <
+                 * max_packet as an indicator that the end of the
+                 * packet has been reached).
+                 */
+                u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
+
+                if (max3421_hcd->curr_len == max_packet)
+                        return 0;
+        }
+        return 1;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_host_transfer_done(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+        u8 result_code, hrsl;
+        int urb_done = 0;
+
+        max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) |
+                               BIT(MAX3421_HI_RCVDAV_BIT));
+
+        hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+        result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
+
+#ifdef DEBUG
+        ++max3421_hcd->err_stat[result_code];
+#endif
+
+        max3421_ep = urb->ep->hcpriv;
+
+        if (unlikely(result_code != MAX3421_HRSL_OK)) {
+                max3421_handle_error(hcd, hrsl);
+                return;
+        }
+
+        max3421_ep->naks = 0;
+        max3421_ep->retries = 0;
+        switch (max3421_ep->pkt_state) {
+
+        case PKT_STATE_SETUP:
+                if (urb->transfer_buffer_length > 0)
+                        max3421_ep->pkt_state = PKT_STATE_TRANSFER;
+                else
+                        max3421_ep->pkt_state = PKT_STATE_TERMINATE;
+                break;
+
+        case PKT_STATE_TRANSFER:
+                if (usb_urb_dir_in(urb))
+                        urb_done = max3421_transfer_in_done(hcd, urb);
+                else
+                        urb_done = max3421_transfer_out_done(hcd, urb);
+                if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) {
+                        /*
+                         * We aren't really done - we still need to
+                         * terminate the control transfer:
+                         */
+                        max3421_hcd->urb_done = urb_done = 0;
+                        max3421_ep->pkt_state = PKT_STATE_TERMINATE;
+                }
+                break;
+
+        case PKT_STATE_TERMINATE:
+                urb_done = 1;
+                break;
+        }
+
+        if (urb_done)
+                max3421_hcd->urb_done = urb_done;
+        else
+                max3421_next_transfer(hcd, 0);
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_detect_conn(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned int jk, have_conn = 0;
+        u32 old_port_status, chg;
+        unsigned long flags;
+        u8 hrsl, mode;
+
+        hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+
+        jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) |
+              (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1));
+
+        mode = max3421_hcd->mode;
+
+        switch (jk) {
+        case 0x0: /* SE0: disconnect */
+                /*
+                 * Turn off SOFKAENAB bit to avoid getting interrupt
+                 * every milli-second:
+                 */
+                mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT);
+                break;
+
+        case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */
+        case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */
+                if (jk == 0x2)
+                        /* need to switch to the other speed: */
+                        mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT);
+                /* turn on SOFKAENAB bit: */
+                mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT);
+                have_conn = 1;
+                break;
+
+        case 0x3: /* illegal */
+                break;
+        }
+
+        max3421_hcd->mode = mode;
+        spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        old_port_status = max3421_hcd->port_status;
+        if (have_conn)
+                max3421_hcd->port_status |=  USB_PORT_STAT_CONNECTION;
+        else
+                max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION;
+        if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT))
+                max3421_hcd->port_status |=  USB_PORT_STAT_LOW_SPEED;
+        else
+                max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED;
+        chg = (old_port_status ^ max3421_hcd->port_status);
+        max3421_hcd->port_status |= chg << 16;
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+static irqreturn_t
+max3421_irq_handler(int irq, void *dev_id)
+{
+        struct usb_hcd *hcd = dev_id;
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        if (max3421_hcd->spi_thread &&
+            max3421_hcd->spi_thread->state != TASK_RUNNING)
+                wake_up_process(max3421_hcd->spi_thread);
+        if (!max3421_hcd->do_enable_irq) {
+                max3421_hcd->do_enable_irq = 1;
+                disable_irq_nosync(spi->irq);
+        }
+        return IRQ_HANDLED;
+}
+
+#ifdef DEBUG
+
+static void
+dump_eps(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_ep *max3421_ep;
+        struct usb_host_endpoint *ep;
+        struct list_head *pos, *upos;
+        char ubuf[512], *dp, *end;
+        unsigned long flags;
+        struct urb *urb;
+        int epnum, ret;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        list_for_each(pos, &max3421_hcd->ep_list) {
+                max3421_ep = container_of(pos, struct max3421_ep, ep_list);
+                ep = max3421_ep->ep;
+
+                dp = ubuf;
+                end = dp + sizeof(ubuf);
+                *dp = '\0';
+                list_for_each(upos, &ep->urb_list) {
+                        urb = container_of(upos, struct urb, urb_list);
+                        ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb,
+                                       usb_pipetype(urb->pipe),
+                                       usb_urb_dir_in(urb) ? "IN" : "OUT",
+                                       urb->actual_length,
+                                       urb->transfer_buffer_length);
+                        if (ret < 0 || ret >= end - dp)
+                                break;  /* error or buffer full */
+                        dp += ret;
+                }
+
+                epnum = usb_endpoint_num(&ep->desc);
+                pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n",
+                        epnum, max3421_ep->pkt_state, max3421_ep->last_active,
+                        max3421_ep->retries, max3421_ep->naks,
+                        max3421_ep->retransmit, ubuf);
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+#endif /* DEBUG */
+
+/* Return zero if no work was performed, 1 otherwise.  */
+static int
+max3421_handle_irqs(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u32 chg, old_port_status;
+        unsigned long flags;
+        u8 hirq;
+
+        /*
+         * Read and ack pending interrupts (CPU must never
+         * clear SNDBAV directly and RCVDAV must be cleared by
+         * max3421_recv_data_available()!):
+         */
+        hirq = spi_rd8(hcd, MAX3421_REG_HIRQ);
+        hirq &= max3421_hcd->hien;
+        if (!hirq)
+                return 0;
+
+        spi_wr8(hcd, MAX3421_REG_HIRQ,
+                hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) |
+                         BIT(MAX3421_HI_RCVDAV_BIT)));
+
+        if (hirq & BIT(MAX3421_HI_FRAME_BIT)) {
+                max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1)
+                                             & USB_MAX_FRAME_NUMBER);
+                max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
+        }
+
+        if (hirq & BIT(MAX3421_HI_RCVDAV_BIT))
+                max3421_recv_data_available(hcd);
+
+        if (hirq & BIT(MAX3421_HI_HXFRDN_BIT))
+                max3421_host_transfer_done(hcd);
+
+        if (hirq & BIT(MAX3421_HI_CONDET_BIT))
+                max3421_detect_conn(hcd);
+
+        /*
+         * Now process interrupts that may affect HCD state
+         * other than the end-points:
+         */
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        old_port_status = max3421_hcd->port_status;
+        if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) {
+                if (max3421_hcd->port_status & USB_PORT_STAT_RESET) {
+                        /* BUSEVENT due to completion of Bus Reset */
+                        max3421_hcd->port_status &= ~USB_PORT_STAT_RESET;
+                        max3421_hcd->port_status |=  USB_PORT_STAT_ENABLE;
+                } else {
+                        /* BUSEVENT due to completion of Bus Resume */
+                        pr_info("%s: BUSEVENT Bus Resume Done\n", __func__);
+                }
+        }
+        if (hirq & BIT(MAX3421_HI_RWU_BIT))
+                pr_info("%s: RWU\n", __func__);
+        if (hirq & BIT(MAX3421_HI_SUSDN_BIT))
+                pr_info("%s: SUSDN\n", __func__);
+
+        chg = (old_port_status ^ max3421_hcd->port_status);
+        max3421_hcd->port_status |= chg << 16;
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+#ifdef DEBUG
+        {
+                static unsigned long last_time;
+                char sbuf[16 * 16], *dp, *end;
+                int i;
+
+                if (jiffies - last_time > 5*HZ) {
+                        dp = sbuf;
+                        end = sbuf + sizeof(sbuf);
+                        *dp = '\0';
+                        for (i = 0; i < 16; ++i) {
+                                int ret = snprintf(dp, end - dp, " %lu",
+                                                   max3421_hcd->err_stat[i]);
+                                if (ret < 0 || ret >= end - dp)
+                                        break;  /* error or buffer full */
+                                dp += ret;
+                        }
+                        pr_info("%s: hrsl_stats %s\n", __func__, sbuf);
+                        memset(max3421_hcd->err_stat, 0,
+                               sizeof(max3421_hcd->err_stat));
+                        last_time = jiffies;
+
+                        dump_eps(hcd);
+                }
+        }
+#endif
+        return 1;
+}
+
+static int
+max3421_reset_hcd(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int timeout;
+
+        /* perform a chip reset and wait for OSCIRQ signal to appear: */
+        spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT));
+        /* clear reset: */
+        spi_wr8(hcd, MAX3421_REG_USBCTL, 0);
+        timeout = 1000;
+        while (1) {
+                if (spi_rd8(hcd, MAX3421_REG_USBIRQ)
+                    & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT))
+                        break;
+                if (--timeout < 0) {
+                        dev_err(&spi->dev,
+                                "timed out waiting for oscillator OK signal");
+                        return 1;
+                }
+                cond_resched();
+        }
+
+        /*
+         * Turn on host mode, automatic generation of SOF packets, and
+         * enable pull-down registers on DM/DP:
+         */
+        max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) |
+                             BIT(MAX3421_MODE_SOFKAENAB_BIT) |
+                             BIT(MAX3421_MODE_DMPULLDN_BIT) |
+                             BIT(MAX3421_MODE_DPPULLDN_BIT));
+        spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+
+        /* reset frame-number: */
+        max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER;
+        spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT));
+
+        /* sample the state of the D+ and D- lines */
+        spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT));
+        max3421_detect_conn(hcd);
+
+        /* enable frame, connection-detected, and bus-event interrupts: */
+        max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) |
+                             BIT(MAX3421_HI_CONDET_BIT) |
+                             BIT(MAX3421_HI_BUSEVENT_BIT));
+        spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
+
+        /* enable interrupts: */
+        spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT));
+        return 1;
+}
+
+static int
+max3421_urb_done(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        struct urb *urb;
+        int status;
+
+        status = max3421_hcd->urb_done;
+        max3421_hcd->urb_done = 0;
+        if (status > 0)
+                status = 0;
+        urb = max3421_hcd->curr_urb;
+        if (urb) {
+                max3421_hcd->curr_urb = NULL;
+                spin_lock_irqsave(&max3421_hcd->lock, flags);
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+                spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+                /* must be called without the HCD spinlock: */
+                usb_hcd_giveback_urb(hcd, urb, status);
+        }
+        return 1;
+}
+
+static int
+max3421_spi_thread(void *dev_id)
+{
+        struct usb_hcd *hcd = dev_id;
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int i, i_worked = 1;
+
+        /* set full-duplex SPI mode, low-active interrupt pin: */
+        spi_wr8(hcd, MAX3421_REG_PINCTL,
+                (BIT(MAX3421_PINCTL_FDUPSPI_BIT) |      /* full-duplex */
+                 BIT(MAX3421_PINCTL_INTLEVEL_BIT)));    /* low-active irq */
+
+        while (!kthread_should_stop()) {
+                max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION);
+                if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13)
+                        break;
+                dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev);
+                msleep(10000);
+        }
+        dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n",
+                 max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word,
+                 spi->irq);
+
+        while (!kthread_should_stop()) {
+                if (!i_worked) {
+                        /*
+                         * We'll be waiting for wakeups from the hard
+                         * interrupt handler, so now is a good time to
+                         * sync our hien with the chip:
+                         */
+                        spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
+
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        if (max3421_hcd->do_enable_irq) {
+                                max3421_hcd->do_enable_irq = 0;
+                                enable_irq(spi->irq);
+                        }
+                        schedule();
+                        __set_current_state(TASK_RUNNING);
+                }
+
+                i_worked = 0;
+
+                if (max3421_hcd->urb_done)
+                        i_worked |= max3421_urb_done(hcd);
+                else if (max3421_handle_irqs(hcd))
+                        i_worked = 1;
+                else if (!max3421_hcd->curr_urb)
+                        i_worked |= max3421_select_and_start_urb(hcd);
+
+                if (max3421_hcd->do_reset_hcd) {
+                        /* reset the HCD: */
+                        max3421_hcd->do_reset_hcd = 0;
+                        i_worked |= max3421_reset_hcd(hcd);
+                }
+                if (max3421_hcd->do_reset_port) {
+                        /* perform a USB bus reset: */
+                        max3421_hcd->do_reset_port = 0;
+                        spi_wr8(hcd, MAX3421_REG_HCTL,
+                                BIT(MAX3421_HCTL_BUSRST_BIT));
+                        i_worked = 1;
+                }
+                if (max3421_hcd->do_check_unlink) {
+                        max3421_hcd->do_check_unlink = 0;
+                        i_worked |= max3421_check_unlink(hcd);
+                }
+                if (max3421_hcd->do_iopin_update) {
+                        /*
+                         * IOPINS1/IOPINS2 do not auto-increment, so we can't
+                         * use spi_wr_buf().
+                         */
+                        for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) {
+                                u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1);
+
+                                val = ((val & 0xf0) |
+                                       (max3421_hcd->iopins[i] & 0x0f));
+                                spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val);
+                                max3421_hcd->iopins[i] = val;
+                        }
+                        max3421_hcd->do_iopin_update = 0;
+                        i_worked = 1;
+                }
+        }
+        set_current_state(TASK_RUNNING);
+        dev_info(&spi->dev, "SPI thread exiting");
+        return 0;
+}
+
+static int
+max3421_reset_port(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE |
+                                      USB_PORT_STAT_LOW_SPEED);
+        max3421_hcd->do_reset_port = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+        return 0;
+}
+
+static int
+max3421_reset(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        hcd->self.sg_tablesize = 0;
+        hcd->speed = HCD_USB2;
+        hcd->self.root_hub->speed = USB_SPEED_FULL;
+        max3421_hcd->do_reset_hcd = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+        return 0;
+}
+
+static int
+max3421_start(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        spin_lock_init(&max3421_hcd->lock);
+        max3421_hcd->rh_state = MAX3421_RH_RUNNING;
+
+        INIT_LIST_HEAD(&max3421_hcd->ep_list);
+
+        hcd->power_budget = POWER_BUDGET;
+        hcd->state = HC_STATE_RUNNING;
+        hcd->uses_new_polling = 1;
+        return 0;
+}
+
+static void
+max3421_stop(struct usb_hcd *hcd)
+{
+}
+
+static int
+max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_ep *max3421_ep;
+        unsigned long flags;
+        int retval;
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_INTERRUPT:
+        case PIPE_ISOCHRONOUS:
+                if (urb->interval < 0) {
+                        dev_err(&spi->dev,
+                          "%s: interval=%d for intr-/iso-pipe; expected > 0\n",
+                                __func__, urb->interval);
+                        return -EINVAL;
+                }
+        default:
+                break;
+        }
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        max3421_ep = urb->ep->hcpriv;
+        if (!max3421_ep) {
+                /* gets freed in max3421_endpoint_disable: */
+                max3421_ep = kzalloc(sizeof(struct max3421_ep), mem_flags);
+                if (!max3421_ep) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+                max3421_ep->ep = urb->ep;
+                max3421_ep->last_active = max3421_hcd->frame_number;
+                urb->ep->hcpriv = max3421_ep;
+
+                list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list);
+        }
+
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval == 0) {
+                /* Since we added to the queue, restart scheduling: */
+                max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
+                wake_up_process(max3421_hcd->spi_thread);
+        }
+
+out:
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static int
+max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        /*
+         * This will set urb->unlinked which in turn causes the entry
+         * to be dropped at the next opportunity.
+         */
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval == 0) {
+                max3421_hcd->do_check_unlink = 1;
+                wake_up_process(max3421_hcd->spi_thread);
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static void
+max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        if (ep->hcpriv) {
+                struct max3421_ep *max3421_ep = ep->hcpriv;
+
+                /* remove myself from the ep_list: */
+                if (!list_empty(&max3421_ep->ep_list))
+                        list_del(&max3421_ep->ep_list);
+                kfree(max3421_ep);
+                ep->hcpriv = NULL;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+static int
+max3421_get_frame_number(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        return max3421_hcd->frame_number;
+}
+
+/*
+ * Should return a non-zero value when any port is undergoing a resume
+ * transition while the root hub is suspended.
+ */
+static int
+max3421_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        if (!HCD_HW_ACCESSIBLE(hcd))
+                goto done;
+
+        *buf = 0;
+        if ((max3421_hcd->port_status & PORT_C_MASK) != 0) {
+                *buf = (1 << 1); /* a hub over-current condition exists */
+                dev_dbg(hcd->self.controller,
+                        "port status 0x%08x has changes\n",
+                        max3421_hcd->port_status);
+                retval = 1;
+                if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED)
+                        usb_hcd_resume_root_hub(hcd);
+        }
+done:
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static inline void
+hub_descriptor(struct usb_hub_descriptor *desc)
+{
+        memset(desc, 0, sizeof(*desc));
+        /*
+         * See Table 11-13: Hub Descriptor in USB 2.0 spec.
+         */
+        desc->bDescriptorType = 0x29;   /* hub descriptor */
+        desc->bDescLength = 9;
+        desc->wHubCharacteristics = cpu_to_le16(0x0001);
+        desc->bNbrPorts = 1;
+}
+
+/*
+ * Set the MAX3421E general-purpose output with number PIN_NUMBER to
+ * VALUE (0 or 1).  PIN_NUMBER may be in the range from 1-8.  For
+ * any other value, this function acts as a no-op.
+ */
+static void
+max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 mask, idx;
+
+        --pin_number;
+        if (pin_number > 7)
+                return;
+
+        mask = 1u << pin_number;
+        idx = pin_number / 4;
+
+        if (value)
+                max3421_hcd->iopins[idx] |=  mask;
+        else
+                max3421_hcd->iopins[idx] &= ~mask;
+        max3421_hcd->do_iopin_update = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+}
+
+static int
+max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index,
+                    char *buf, u16 length)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_hcd_platform_data *pdata;
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        pdata = spi->dev.platform_data;
+
+        switch (type_req) {
+        case ClearHubFeature:
+                break;
+        case ClearPortFeature:
+                switch (value) {
+                case USB_PORT_FEAT_SUSPEND:
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(hcd->self.controller, "power-off\n");
+                        max3421_gpout_set_value(hcd, pdata->vbus_gpout,
+                                                !pdata->vbus_active_level);
+                        /* FALLS THROUGH */
+                default:
+                        max3421_hcd->port_status &= ~(1 << value);
+                }
+                break;
+        case GetHubDescriptor:
+                hub_descriptor((struct usb_hub_descriptor *) buf);
+                break;
+
+        case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
+        case GetPortErrorCount:
+        case SetHubDepth:
+                /* USB3 only */
+                goto error;
+
+        case GetHubStatus:
+                *(__le32 *) buf = cpu_to_le32(0);
+                break;
+
+        case GetPortStatus:
+                if (index != 1) {
+                        retval = -EPIPE;
+                        goto error;
+                }
+                ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status);
+                ((__le16 *) buf)[1] =
+                        cpu_to_le16(max3421_hcd->port_status >> 16);
+                break;
+
+        case SetHubFeature:
+                retval = -EPIPE;
+                break;
+
+        case SetPortFeature:
+                switch (value) {
+                case USB_PORT_FEAT_LINK_STATE:
+                case USB_PORT_FEAT_U1_TIMEOUT:
+                case USB_PORT_FEAT_U2_TIMEOUT:
+                case USB_PORT_FEAT_BH_PORT_RESET:
+                        goto error;
+                case USB_PORT_FEAT_SUSPEND:
+                        if (max3421_hcd->active)
+                                max3421_hcd->port_status |=
+                                        USB_PORT_STAT_SUSPEND;
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(hcd->self.controller, "power-on\n");
+                        max3421_hcd->port_status |= USB_PORT_STAT_POWER;
+                        max3421_gpout_set_value(hcd, pdata->vbus_gpout,
+                                                pdata->vbus_active_level);
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        max3421_reset_port(hcd);
+                        /* FALLS THROUGH */
+                default:
+                        if ((max3421_hcd->port_status & USB_PORT_STAT_POWER)
+                            != 0)
+                                max3421_hcd->port_status |= (1 << value);
+                }
+                break;
+
+        default:
+                dev_dbg(hcd->self.controller,
+                        "hub control req%04x v%04x i%04x l%d\n",
+                        type_req, value, index, length);
+error:          /* "protocol stall" on error */
+                retval = -EPIPE;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static int
+max3421_bus_suspend(struct usb_hcd *hcd)
+{
+        return -1;
+}
+
+static int
+max3421_bus_resume(struct usb_hcd *hcd)
+{
+        return -1;
+}
+
+/*
+ * The SPI driver already takes care of DMA-mapping/unmapping, so no
+ * reason to do it twice.
+ */
+static int
+max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
+{
+        return 0;
+}
+
+static void
+max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+}
+
+static struct hc_driver max3421_hcd_desc = {
+        .description =          "max3421",
+        .product_desc =         DRIVER_DESC,
+        .hcd_priv_size =        sizeof(struct max3421_hcd),
+        .flags =                HCD_USB11,
+        .reset =                max3421_reset,
+        .start =                max3421_start,
+        .stop =                 max3421_stop,
+        .get_frame_number =     max3421_get_frame_number,
+        .urb_enqueue =          max3421_urb_enqueue,
+        .urb_dequeue =          max3421_urb_dequeue,
+        .map_urb_for_dma =      max3421_map_urb_for_dma,
+        .unmap_urb_for_dma =    max3421_unmap_urb_for_dma,
+        .endpoint_disable =     max3421_endpoint_disable,
+        .hub_status_data =      max3421_hub_status_data,
+        .hub_control =          max3421_hub_control,
+        .bus_suspend =          max3421_bus_suspend,
+        .bus_resume =           max3421_bus_resume,
+};
+
+static int
+max3421_probe(struct spi_device *spi)
+{
+        struct max3421_hcd *max3421_hcd;
+        struct usb_hcd *hcd = NULL;
+        int retval = -ENOMEM;
+
+        if (spi_setup(spi) < 0) {
+                dev_err(&spi->dev, "Unable to setup SPI bus");
+                return -EFAULT;
+        }
+
+        hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev,
+                             dev_name(&spi->dev));
+        if (!hcd) {
+                dev_err(&spi->dev, "failed to create HCD structure\n");
+                goto error;
+        }
+        set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        max3421_hcd = hcd_to_max3421(hcd);
+        max3421_hcd->next = max3421_hcd_list;
+        max3421_hcd_list = max3421_hcd;
+        INIT_LIST_HEAD(&max3421_hcd->ep_list);
+
+        max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL);
+        if (!max3421_hcd->tx) {
+                dev_err(&spi->dev, "failed to kmalloc tx buffer\n");
+                goto error;
+        }
+        max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL);
+        if (!max3421_hcd->rx) {
+                dev_err(&spi->dev, "failed to kmalloc rx buffer\n");
+                goto error;
+        }
+
+        max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd,
+                                              "max3421_spi_thread");
+        if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) {
+                dev_err(&spi->dev,
+                        "failed to create SPI thread (out of memory)\n");
+                goto error;
+        }
+
+        retval = usb_add_hcd(hcd, 0, 0);
+        if (retval) {
+                dev_err(&spi->dev, "failed to add HCD\n");
+                goto error;
+        }
+
+        retval = request_irq(spi->irq, max3421_irq_handler,
+                             IRQF_TRIGGER_LOW, "max3421", hcd);
+        if (retval < 0) {
+                dev_err(&spi->dev, "failed to request irq %d\n", spi->irq);
+                goto error;
+        }
+        return 0;
+
+error:
+        if (hcd) {
+                kfree(max3421_hcd->tx);
+                kfree(max3421_hcd->rx);
+                if (max3421_hcd->spi_thread)
+                        kthread_stop(max3421_hcd->spi_thread);
+                usb_put_hcd(hcd);
+        }
+        return retval;
+}
+
+static int
+max3421_remove(struct spi_device *spi)
+{
+        struct max3421_hcd *max3421_hcd = NULL, **prev;
+        struct usb_hcd *hcd = NULL;
+        unsigned long flags;
+
+        for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) {
+                max3421_hcd = *prev;
+                hcd = max3421_to_hcd(max3421_hcd);
+                if (hcd->self.controller == &spi->dev)
+                        break;
+        }
+        if (!max3421_hcd) {
+                dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n",
+                        spi);
+                return -ENODEV;
+        }
+
+        usb_remove_hcd(hcd);
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        kthread_stop(max3421_hcd->spi_thread);
+        *prev = max3421_hcd->next;
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+        free_irq(spi->irq, hcd);
+
+        usb_put_hcd(hcd);
+        return 0;
+}
+
+static struct spi_driver max3421_driver = {
+        .probe          = max3421_probe,
+        .remove         = max3421_remove,
+        .driver         = {
+                .name   = "max3421-hcd",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_spi_driver(max3421_driver);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("David Mosberger <davidm@egauge.net>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 091ae4905cfc..e49eb4f90f5d 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -46,9 +46,6 @@ static const char hcd_name[] = "ohci-atmel";
 
 static struct hc_driver __read_mostly ohci_at91_hc_driver;
 static int clocked;
-static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
-                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
-static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
 
 extern int usb_disabled(void);
 
@@ -262,7 +259,7 @@ static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
-        int length = orig_ohci_hub_status_data(hcd, buf);
+        int length = ohci_hub_status_data(hcd, buf);
         int port;
 
         at91_for_each_port(port) {
@@ -340,8 +337,7 @@ static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 break;
         }
 
-        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex + 1,
-                                buf, wLength);
+        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
         if (ret)
                 goto out;
 
@@ -690,9 +686,6 @@ static int __init ohci_at91_init(void)
          * too easy.
          */
 
-        orig_ohci_hub_control = ohci_at91_hc_driver.hub_control;
-        orig_ohci_hub_status_data = ohci_at91_hc_driver.hub_status_data;
-
         ohci_at91_hc_driver.hub_status_data     = ohci_at91_hub_status_data;
         ohci_at91_hc_driver.hub_control         = ohci_at91_hub_control;
 
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index 68588d8a09bb..060a6a414750 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/phy/phy.h>
 #include <linux/usb/phy.h>
 #include <linux/usb/samsung_usb_phy.h>
 #include <linux/usb.h>
@@ -33,28 +34,110 @@ static struct hc_driver __read_mostly exynos_ohci_hc_driver;
 
 #define to_exynos_ohci(hcd) (struct exynos_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
 
+#define PHY_NUMBER 3
+
 struct exynos_ohci_hcd {
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
+        struct phy *phy_g[PHY_NUMBER];
 };
 
-static void exynos_ohci_phy_enable(struct platform_device *pdev)
+static int exynos_ohci_get_phy(struct device *dev,
+                                struct exynos_ohci_hcd *exynos_ohci)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct device_node *child;
+        struct phy *phy;
+        int phy_number;
+        int ret = 0;
+
+        exynos_ohci->phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
+        if (IS_ERR(exynos_ohci->phy)) {
+                ret = PTR_ERR(exynos_ohci->phy);
+                if (ret != -ENXIO && ret != -ENODEV) {
+                        dev_err(dev, "no usb2 phy configured\n");
+                        return ret;
+                }
+                dev_dbg(dev, "Failed to get usb2 phy\n");
+        } else {
+                exynos_ohci->otg = exynos_ohci->phy->otg;
+        }
+
+        /*
+         * Getting generic phy:
+         * We are keeping both types of phys as a part of transiting OHCI
+         * to generic phy framework, so as to maintain backward compatibilty
+         * with old DTB.
+         * If there are existing devices using DTB files built from them,
+         * to remove the support for old bindings in this driver,
+         * we need to make sure that such devices have their DTBs
+         * updated to ones built from new DTS.
+         */
+        for_each_available_child_of_node(dev->of_node, child) {
+                ret = of_property_read_u32(child, "reg", &phy_number);
+                if (ret) {
+                        dev_err(dev, "Failed to parse device tree\n");
+                        of_node_put(child);
+                        return ret;
+                }
+
+                if (phy_number >= PHY_NUMBER) {
+                        dev_err(dev, "Invalid number of PHYs\n");
+                        of_node_put(child);
+                        return -EINVAL;
+                }
+
+                phy = devm_of_phy_get(dev, child, 0);
+                of_node_put(child);
+                if (IS_ERR(phy)) {
+                        ret = PTR_ERR(phy);
+                        if (ret != -ENOSYS && ret != -ENODEV) {
+                                dev_err(dev, "no usb2 phy configured\n");
+                                return ret;
+                        }
+                        dev_dbg(dev, "Failed to get usb2 phy\n");
+                }
+                exynos_ohci->phy_g[phy_number] = phy;
+        }
+
+        return ret;
+}
+
+static int exynos_ohci_phy_enable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
+        int i;
+        int ret = 0;
+
+        if (!IS_ERR(exynos_ohci->phy))
+                return usb_phy_init(exynos_ohci->phy);
+
+        for (i = 0; ret == 0 && i < PHY_NUMBER; i++)
+                if (!IS_ERR(exynos_ohci->phy_g[i]))
+                        ret = phy_power_on(exynos_ohci->phy_g[i]);
+        if (ret)
+                for (i--; i >= 0; i--)
+                        if (!IS_ERR(exynos_ohci->phy_g[i]))
+                                phy_power_off(exynos_ohci->phy_g[i]);
 
-        if (exynos_ohci->phy)
-                usb_phy_init(exynos_ohci->phy);
+        return ret;
 }
 
-static void exynos_ohci_phy_disable(struct platform_device *pdev)
+static void exynos_ohci_phy_disable(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
+        int i;
 
-        if (exynos_ohci->phy)
+        if (!IS_ERR(exynos_ohci->phy)) {
                 usb_phy_shutdown(exynos_ohci->phy);
+                return;
+        }
+
+        for (i = 0; i < PHY_NUMBER; i++)
+                if (!IS_ERR(exynos_ohci->phy_g[i]))
+                        phy_power_off(exynos_ohci->phy_g[i]);
 }
 
 static int exynos_ohci_probe(struct platform_device *pdev)
@@ -62,7 +145,6 @@ static int exynos_ohci_probe(struct platform_device *pdev)
         struct exynos_ohci_hcd *exynos_ohci;
         struct usb_hcd *hcd;
         struct resource *res;
-        struct usb_phy *phy;
         int irq;
         int err;
 
@@ -88,15 +170,9 @@ static int exynos_ohci_probe(struct platform_device *pdev)
                                         "samsung,exynos5440-ohci"))
                 goto skip_phy;
 
-        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(phy)) {
-                usb_put_hcd(hcd);
-                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                return -EPROBE_DEFER;
-        } else {
-                exynos_ohci->phy = phy;
-                exynos_ohci->otg = phy->otg;
-        }
+        err = exynos_ohci_get_phy(&pdev->dev, exynos_ohci);
+        if (err)
+                goto fail_clk;
 
 skip_phy:
         exynos_ohci->clk = devm_clk_get(&pdev->dev, "usbhost");
@@ -120,10 +196,9 @@ skip_phy:
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto fail_io;
         }
 
@@ -139,7 +214,11 @@ skip_phy:
 
         platform_set_drvdata(pdev, hcd);
 
-        exynos_ohci_phy_enable(pdev);
+        err = exynos_ohci_phy_enable(&pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to enable USB phy\n");
+                goto fail_io;
+        }
 
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
@@ -150,7 +229,7 @@ skip_phy:
         return 0;
 
 fail_add_hcd:
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(&pdev->dev);
 fail_io:
         clk_disable_unprepare(exynos_ohci->clk);
 fail_clk:
@@ -168,7 +247,7 @@ static int exynos_ohci_remove(struct platform_device *pdev)
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -190,26 +269,19 @@ static int exynos_ohci_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct platform_device *pdev = to_platform_device(dev);
         bool do_wakeup = device_may_wakeup(dev);
-        unsigned long flags;
         int rc = ohci_suspend(hcd, do_wakeup);
 
         if (rc)
                 return rc;
 
-        spin_lock_irqsave(&ohci->lock, flags);
-
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
-        spin_unlock_irqrestore(&ohci->lock, flags);
-
         return 0;
 }
 
@@ -217,14 +289,19 @@ static int exynos_ohci_resume(struct device *dev)
 {
         struct usb_hcd *hcd                     = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci     = to_exynos_ohci(hcd);
-        struct platform_device *pdev            = to_platform_device(dev);
+        int ret;
 
         clk_prepare_enable(exynos_ohci->clk);
 
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_enable(pdev);
+        ret = exynos_ohci_phy_enable(dev);
+        if (ret) {
+                dev_err(dev, "Failed to enable USB phy\n");
+                clk_disable_unprepare(exynos_ohci->clk);
+                return ret;
+        }
 
         ohci_resume(hcd, false);
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 3586460fb2a1..f98d03f3144c 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1178,7 +1178,7 @@ MODULE_LICENSE ("GPL");
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
 
-#ifdef CONFIG_ARCH_DAVINCI_DA8XX
+#ifdef CONFIG_USB_OHCI_HCD_DAVINCI
 #include "ohci-da8xx.c"
 #define DAVINCI_PLATFORM_DRIVER ohci_hcd_da8xx_driver
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index cd871b895013..b4940de1eba3 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -456,8 +456,7 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
 
 /* build "status change" packet (one or two bytes) from HC registers */
 
-static int
-ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
+int ohci_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
         int             i, changed = 0, length = 1;
@@ -522,6 +521,7 @@ done:
 
         return changed ? length : 0;
 }
+EXPORT_SYMBOL_GPL(ohci_hub_status_data);
 
 /*-------------------------------------------------------------------------*/
 
@@ -664,7 +664,7 @@ static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
         return 0;
 }
 
-static int ohci_hub_control (
+int ohci_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -790,4 +790,4 @@ error:
         }
         return retval;
 }
-
+EXPORT_SYMBOL_GPL(ohci_hub_control);
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index b6002c951c5c..4369299064c7 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -24,6 +24,7 @@
 #include <linux/err.h>
 #include <linux/phy/phy.h>
 #include <linux/platform_device.h>
+#include <linux/reset.h>
 #include <linux/usb/ohci_pdriver.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -36,6 +37,7 @@
 
 struct ohci_platform_priv {
         struct clk *clks[OHCI_MAX_CLKS];
+        struct reset_control *rst;
         struct phy *phy;
 };
 
@@ -191,6 +193,19 @@ static int ohci_platform_probe(struct platform_device *dev)
                                 break;
                         }
                 }
+
+        }
+
+        priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->rst = NULL;
+        } else {
+                err = reset_control_deassert(priv->rst);
+                if (err)
+                        goto err_put_clks;
         }
 
         if (pdata->big_endian_desc)
@@ -203,7 +218,7 @@ static int ohci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_OHCI_BIG_ENDIAN_MMIO not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_DESC
@@ -211,14 +226,14 @@ static int ohci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_OHCI_BIG_ENDIAN_DESC not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        goto err_put_clks;
+                        goto err_reset;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -242,6 +257,9 @@ static int ohci_platform_probe(struct platform_device *dev)
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_reset:
+        if (priv->rst)
+                reset_control_assert(priv->rst);
 err_put_clks:
         while (--clk >= 0)
                 clk_put(priv->clks[clk]);
@@ -266,6 +284,9 @@ static int ohci_platform_remove(struct platform_device *dev)
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        if (priv->rst)
+                reset_control_assert(priv->rst);
+
         for (clk = 0; clk < OHCI_MAX_CLKS && priv->clks[clk]; clk++)
                 clk_put(priv->clks[clk]);
 
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index d21d5fefa76c..e68f3d02cd1a 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -30,6 +30,7 @@
 #include <linux/platform_data/usb-ohci-pxa27x.h>
 #include <linux/platform_data/usb-pxa3xx-ulpi.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
 #include <linux/signal.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -120,6 +121,8 @@ static struct hc_driver __read_mostly ohci_pxa27x_hc_driver;
 struct pxa27x_ohci {
         struct clk      *clk;
         void __iomem    *mmio_base;
+        struct regulator *vbus[3];
+        bool            vbus_enabled[3];
 };
 
 #define to_pxa27x_ohci(hcd)     (struct pxa27x_ohci *)(hcd_to_ohci(hcd)->priv)
@@ -166,6 +169,52 @@ static int pxa27x_ohci_select_pmm(struct pxa27x_ohci *pxa_ohci, int mode)
         return 0;
 }
 
+static int pxa27x_ohci_set_vbus_power(struct pxa27x_ohci *pxa_ohci,
+                                      unsigned int port, bool enable)
+{
+        struct regulator *vbus = pxa_ohci->vbus[port];
+        int ret = 0;
+
+        if (IS_ERR_OR_NULL(vbus))
+                return 0;
+
+        if (enable && !pxa_ohci->vbus_enabled[port])
+                ret = regulator_enable(vbus);
+        else if (!enable && pxa_ohci->vbus_enabled[port])
+                ret = regulator_disable(vbus);
+
+        if (ret < 0)
+                return ret;
+
+        pxa_ohci->vbus_enabled[port] = enable;
+
+        return 0;
+}
+
+static int pxa27x_ohci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                   u16 wIndex, char *buf, u16 wLength)
+{
+        struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
+        int ret;
+
+        switch (typeReq) {
+        case SetPortFeature:
+        case ClearPortFeature:
+                if (!wIndex || wIndex > 3)
+                        return -EPIPE;
+
+                if (wValue != USB_PORT_FEAT_POWER)
+                        break;
+
+                ret = pxa27x_ohci_set_vbus_power(pxa_ohci, wIndex - 1,
+                                                 typeReq == SetPortFeature);
+                if (ret)
+                        return ret;
+                break;
+        }
+
+        return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+}
 /*-------------------------------------------------------------------------*/
 
 static inline void pxa27x_setup_hc(struct pxa27x_ohci *pxa_ohci,
@@ -372,6 +421,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         struct ohci_hcd *ohci;
         struct resource *r;
         struct clk *usb_clk;
+        unsigned int i;
 
         retval = ohci_pxa_of_init(pdev);
         if (retval)
@@ -417,6 +467,16 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         pxa_ohci->clk = usb_clk;
         pxa_ohci->mmio_base = (void __iomem *)hcd->regs;
 
+        for (i = 0; i < 3; ++i) {
+                char name[6];
+
+                if (!(inf->flags & (ENABLE_PORT1 << i)))
+                        continue;
+
+                sprintf(name, "vbus%u", i + 1);
+                pxa_ohci->vbus[i] = devm_regulator_get(&pdev->dev, name);
+        }
+
         retval = pxa27x_start_hc(pxa_ohci, &pdev->dev);
         if (retval < 0) {
                 pr_debug("pxa27x_start_hc failed");
@@ -462,9 +522,14 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
 void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *pdev)
 {
         struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
+        unsigned int i;
 
         usb_remove_hcd(hcd);
         pxa27x_stop_hc(pxa_ohci, &pdev->dev);
+
+        for (i = 0; i < 3; ++i)
+                pxa27x_ohci_set_vbus_power(pxa_ohci, i, false);
+
         usb_put_hcd(hcd);
 }
 
@@ -563,7 +628,10 @@ static int __init ohci_pxa27x_init(void)
                 return -ENODEV;
 
         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
         ohci_init_driver(&ohci_pxa27x_hc_driver, &pxa27x_overrides);
+        ohci_pxa27x_hc_driver.hub_control = pxa27x_ohci_hub_control;
+
         return platform_driver_register(&ohci_hcd_pxa27x_driver);
 }
 module_init(ohci_pxa27x_init);
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index ff7c8f1c48fb..3d753a9d3141 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -45,10 +45,6 @@ static struct clk *usb_clk;
 
 /* forward definitions */
 
-static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
-                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
-static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
-
 static void s3c2410_hcd_oc(struct s3c2410_hcd_info *info, int port_oc);
 
 /* conversion functions */
@@ -110,7 +106,7 @@ ohci_s3c2410_hub_status_data(struct usb_hcd *hcd, char *buf)
         int orig;
         int portno;
 
-        orig = orig_ohci_hub_status_data(hcd, buf);
+        orig = ohci_hub_status_data(hcd, buf);
 
         if (info == NULL)
                 return orig;
@@ -181,7 +177,7 @@ static int ohci_s3c2410_hub_control(
          * process the request straight away and exit */
 
         if (info == NULL) {
-                ret = orig_ohci_hub_control(hcd, typeReq, wValue,
+                ret = ohci_hub_control(hcd, typeReq, wValue,
                                        wIndex, buf, wLength);
                 goto out;
         }
@@ -231,7 +227,7 @@ static int ohci_s3c2410_hub_control(
                 break;
         }
 
-        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
         if (ret)
                 goto out;
 
@@ -489,9 +485,6 @@ static int __init ohci_s3c2410_init(void)
          * override these functions by making it too easy.
          */
 
-        orig_ohci_hub_control = ohci_s3c2410_hc_driver.hub_control;
-        orig_ohci_hub_status_data = ohci_s3c2410_hc_driver.hub_status_data;
-
         ohci_s3c2410_hc_driver.hub_status_data  = ohci_s3c2410_hub_status_data;
         ohci_s3c2410_hc_driver.hub_control      = ohci_s3c2410_hub_control;
 
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 4550ce05af7f..05e02a709d4f 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -729,3 +729,6 @@ extern int	ohci_setup(struct usb_hcd *hcd);
 extern int      ohci_suspend(struct usb_hcd *hcd, bool do_wakeup);
 extern int      ohci_resume(struct usb_hcd *hcd, bool hibernated);
 #endif
+extern int      ohci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                 u16 wIndex, char *buf, u16 wLength);
+extern int      ohci_hub_status_data(struct usb_hcd *hcd, char *buf);
diff --git a/drivers/usb/host/pci-quirks.h b/drivers/usb/host/pci-quirks.h
index 638e88f7a28b..c622ddf21c94 100644
--- a/drivers/usb/host/pci-quirks.h
+++ b/drivers/usb/host/pci-quirks.h
@@ -5,6 +5,7 @@
 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
 int usb_amd_find_chipset_info(void);
+int usb_hcd_amd_remote_wakeup_quirk(struct pci_dev *pdev);
 bool usb_amd_hang_symptom_quirk(void);
 bool usb_amd_prefetch_quirk(void);
 void usb_amd_dev_put(void);
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 1ad6bc1951c7..6231ce6aa0c3 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -20,7 +20,8 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/gfp.h>
+
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 #include "xhci.h"
@@ -270,7 +271,6 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
         struct xhci_virt_device *virt_dev;
         struct xhci_command *cmd;
         unsigned long flags;
-        int timeleft;
         int ret;
         int i;
 
@@ -284,34 +284,31 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
 
         spin_lock_irqsave(&xhci->lock, flags);
         for (i = LAST_EP_INDEX; i > 0; i--) {
-                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
-                        xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
+                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue) {
+                        struct xhci_command *command;
+                        command = xhci_alloc_command(xhci, false, false,
+                                                     GFP_NOIO);
+                        if (!command) {
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                xhci_free_command(xhci, cmd);
+                                return -ENOMEM;
+
+                        }
+                        xhci_queue_stop_endpoint(xhci, command, slot_id, i,
+                                                 suspend);
+                }
         }
-        cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
-        xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
+        xhci_queue_stop_endpoint(xhci, cmd, slot_id, 0, suspend);
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for last stop endpoint command to finish */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        cmd->completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                spin_lock_irqsave(&xhci->lock, flags);
-                /* The timeout might have raced with the event ring handler, so
-                 * only delete from the list if the item isn't poisoned.
-                 */
-                if (cmd->cmd_list.next != LIST_POISON1)
-                        list_del(&cmd->cmd_list);
-                spin_unlock_irqrestore(&xhci->lock, flags);
+        wait_for_completion(cmd->completion);
+
+        if (cmd->status == COMP_CMD_ABORT || cmd->status == COMP_CMD_STOP) {
+                xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
                 ret = -ETIME;
-                goto command_cleanup;
         }
-
-command_cleanup:
         xhci_free_command(xhci, cmd);
         return ret;
 }
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index c089668308ad..6a57e81c2a76 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1020,7 +1020,6 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         dev->num_rings_cached = 0;
 
         init_completion(&dev->cmd_completion);
-        INIT_LIST_HEAD(&dev->cmd_list);
         dev->udev = udev;
 
         /* Point to output device context in dcbaa. */
@@ -1794,10 +1793,11 @@ void xhci_free_command(struct xhci_hcd *xhci,
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct device   *dev = xhci_to_hcd(xhci)->self.controller;
-        struct xhci_cd  *cur_cd, *next_cd;
         int size;
         int i, j, num_ports;
 
+        del_timer_sync(&xhci->cmd_timer);
+
         /* Free the Event Ring Segment Table and the actual Event Ring */
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
@@ -1816,11 +1816,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed command ring");
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                list_del(&cur_cd->cancel_cmd_list);
-                kfree(cur_cd);
-        }
+        xhci_cleanup_command_queue(xhci);
 
         for (i = 1; i < MAX_HC_SLOTS; ++i)
                 xhci_free_virt_device(xhci, i);
@@ -2323,7 +2319,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         u32 page_size, temp;
         int i;
 
-        INIT_LIST_HEAD(&xhci->cancel_cmd_list);
+        INIT_LIST_HEAD(&xhci->cmd_list);
 
         page_size = readl(&xhci->op_regs->page_size);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
@@ -2509,6 +2505,11 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                         "Wrote ERST address to ir_set 0.");
         xhci_print_ir_set(xhci, 0);
 
+        /* init command timeout timer */
+        init_timer(&xhci->cmd_timer);
+        xhci->cmd_timer.data = (unsigned long) xhci;
+        xhci->cmd_timer.function = xhci_handle_command_timeout;
+
         /*
          * XXX: Might need to set the Interrupter Moderation Register to
          * something other than the default (~1ms minimum between interrupts).
diff --git a/drivers/usb/host/xhci-mvebu.c b/drivers/usb/host/xhci-mvebu.c
new file mode 100644
index 000000000000..1eefc988192d
--- /dev/null
+++ b/drivers/usb/host/xhci-mvebu.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 Marvell
+ * Author: Gregory CLEMENT <gregory.clement@free-electrons.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/io.h>
+#include <linux/mbus.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+
+#include "xhci-mvebu.h"
+
+#define USB3_MAX_WINDOWS        4
+#define USB3_WIN_CTRL(w)        (0x0 + ((w) * 8))
+#define USB3_WIN_BASE(w)        (0x4 + ((w) * 8))
+
+static void xhci_mvebu_mbus_config(void __iomem *base,
+                        const struct mbus_dram_target_info *dram)
+{
+        int win;
+
+        /* Clear all existing windows */
+        for (win = 0; win < USB3_MAX_WINDOWS; win++) {
+                writel(0, base + USB3_WIN_CTRL(win));
+                writel(0, base + USB3_WIN_BASE(win));
+        }
+
+        /* Program each DRAM CS in a seperate window */
+        for (win = 0; win < dram->num_cs; win++) {
+                const struct mbus_dram_window *cs = dram->cs + win;
+
+                writel(((cs->size - 1) & 0xffff0000) | (cs->mbus_attr << 8) |
+                       (dram->mbus_dram_target_id << 4) | 1,
+                       base + USB3_WIN_CTRL(win));
+
+                writel((cs->base & 0xffff0000), base + USB3_WIN_BASE(win));
+        }
+}
+
+int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev)
+{
+        struct resource *res;
+        void __iomem *base;
+        const struct mbus_dram_target_info *dram;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res)
+                return -ENODEV;
+
+        /*
+         * We don't use devm_ioremap() because this mapping should
+         * only exists for the duration of this probe function.
+         */
+        base = ioremap(res->start, resource_size(res));
+        if (!base)
+                return -ENODEV;
+
+        dram = mv_mbus_dram_info();
+        xhci_mvebu_mbus_config(base, dram);
+
+        /*
+         * This memory area was only needed to configure the MBus
+         * windows, and is therefore no longer useful.
+         */
+        iounmap(base);
+
+        return 0;
+}
diff --git a/drivers/usb/host/xhci-mvebu.h b/drivers/usb/host/xhci-mvebu.h
new file mode 100644
index 000000000000..7ede92aa41f6
--- /dev/null
+++ b/drivers/usb/host/xhci-mvebu.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2014 Marvell
+ *
+ * Gregory Clement <gregory.clement@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __LINUX_XHCI_MVEBU_H
+#define __LINUX_XHCI_MVEBU_H
+#if IS_ENABLED(CONFIG_USB_XHCI_MVEBU)
+int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev);
+#else
+static inline int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+#endif /* __LINUX_XHCI_MVEBU_H */
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 35d447780707..e20520f42753 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -134,14 +134,14 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  */
                 if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP)
                         xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
-
+        }
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI) {
                 xhci->quirks |= XHCI_SPURIOUS_REBOOT;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
-                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
-                                "QUIRK: Resetting on resume");
                 xhci->quirks |= XHCI_TRUST_TX_LENGTH;
         }
         if (pdev->vendor == PCI_VENDOR_ID_RENESAS &&
@@ -149,6 +149,10 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
         if (pdev->vendor == PCI_VENDOR_ID_VIA)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
+
+        if (xhci->quirks & XHCI_RESET_ON_RESUME)
+                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
+                                "QUIRK: Resetting on resume");
 }
 
 /* called during probe() after chip reset completes */
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 151901ce1ba9..29d8adb5c8d1 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -11,13 +11,15 @@
  * version 2 as published by the Free Software Foundation.
  */
 
-#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
 #include <linux/module.h>
-#include <linux/slab.h>
 #include <linux/of.h>
-#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include "xhci.h"
+#include "xhci-mvebu.h"
 
 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
@@ -35,6 +37,11 @@ static int xhci_plat_setup(struct usb_hcd *hcd)
         return xhci_gen_setup(hcd, xhci_plat_quirks);
 }
 
+static int xhci_plat_start(struct usb_hcd *hcd)
+{
+        return xhci_run(hcd);
+}
+
 static const struct hc_driver xhci_plat_xhci_driver = {
         .description =          "xhci-hcd",
         .product_desc =         "xHCI Host Controller",
@@ -50,7 +57,7 @@ static const struct hc_driver xhci_plat_xhci_driver = {
          * basic lifecycle operations
          */
         .reset =                xhci_plat_setup,
-        .start =                xhci_run,
+        .start =                xhci_plat_start,
         .stop =                 xhci_stop,
         .shutdown =             xhci_shutdown,
 
@@ -91,6 +98,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
         struct xhci_hcd         *xhci;
         struct resource         *res;
         struct usb_hcd          *hcd;
+        struct clk              *clk;
         int                     ret;
         int                     irq;
 
@@ -107,6 +115,15 @@ static int xhci_plat_probe(struct platform_device *pdev)
         if (!res)
                 return -ENODEV;
 
+        if (of_device_is_compatible(pdev->dev.of_node,
+                                    "marvell,armada-375-xhci") ||
+            of_device_is_compatible(pdev->dev.of_node,
+                                    "marvell,armada-380-xhci")) {
+                ret = xhci_mvebu_mbus_init_quirk(pdev);
+                if (ret)
+                        return ret;
+        }
+
         /* Initialize dma_mask and coherent_dma_mask to 32-bits */
         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
         if (ret)
@@ -137,14 +154,27 @@ static int xhci_plat_probe(struct platform_device *pdev)
                 goto release_mem_region;
         }
 
+        /*
+         * Not all platforms have a clk so it is not an error if the
+         * clock does not exists.
+         */
+        clk = devm_clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(clk)) {
+                ret = clk_prepare_enable(clk);
+                if (ret)
+                        goto unmap_registers;
+        }
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
-                goto unmap_registers;
+                goto disable_clk;
+
         device_wakeup_enable(hcd->self.controller);
 
         /* USB 2.0 roothub is stored in the platform_device now. */
         hcd = platform_get_drvdata(pdev);
         xhci = hcd_to_xhci(hcd);
+        xhci->clk = clk;
         xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
                         dev_name(&pdev->dev), hcd);
         if (!xhci->shared_hcd) {
@@ -173,6 +203,10 @@ put_usb3_hcd:
 dealloc_usb2_hcd:
         usb_remove_hcd(hcd);
 
+disable_clk:
+        if (!IS_ERR(clk))
+                clk_disable_unprepare(clk);
+
 unmap_registers:
         iounmap(hcd->regs);
 
@@ -189,11 +223,14 @@ static int xhci_plat_remove(struct platform_device *dev)
 {
         struct usb_hcd  *hcd = platform_get_drvdata(dev);
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct clk *clk = xhci->clk;
 
         usb_remove_hcd(xhci->shared_hcd);
         usb_put_hcd(xhci->shared_hcd);
 
         usb_remove_hcd(hcd);
+        if (!IS_ERR(clk))
+                clk_disable_unprepare(clk);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
@@ -202,7 +239,7 @@ static int xhci_plat_remove(struct platform_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int xhci_plat_suspend(struct device *dev)
 {
         struct usb_hcd  *hcd = dev_get_drvdata(dev);
@@ -231,6 +268,8 @@ static const struct dev_pm_ops xhci_plat_pm_ops = {
 static const struct of_device_id usb_xhci_of_match[] = {
         { .compatible = "generic-xhci" },
         { .compatible = "xhci-platform" },
+        { .compatible = "marvell,armada-375-xhci"},
+        { .compatible = "marvell,armada-380-xhci"},
         { },
 };
 MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7a0e3c720c00..d67ff71209f5 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -69,10 +69,6 @@
 #include "xhci.h"
 #include "xhci-trace.h"
 
-static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_virt_device *virt_dev,
-                struct xhci_event_cmd *event);
-
 /*
  * Returns zero if the TRB isn't in this segment, otherwise it returns the DMA
  * address of the TRB.
@@ -123,16 +119,6 @@ static int enqueue_is_link_trb(struct xhci_ring *ring)
         return TRB_TYPE_LINK_LE32(link->control);
 }
 
-union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring)
-{
-        /* Enqueue pointer can be left pointing to the link TRB,
-         * we must handle that
-         */
-        if (TRB_TYPE_LINK_LE32(ring->enqueue->link.control))
-                return ring->enq_seg->next->trbs;
-        return ring->enqueue;
-}
-
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
  * TRB is in a new segment.  This does not skip over link TRBs, and it does not
  * effect the ring dequeue or enqueue pointers.
@@ -301,17 +287,7 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
 
         xhci_dbg(xhci, "Abort command ring\n");
 
-        if (!(xhci->cmd_ring_state & CMD_RING_STATE_RUNNING)) {
-                xhci_dbg(xhci, "The command ring isn't running, "
-                                "Have the command ring been stopped?\n");
-                return 0;
-        }
-
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
-        if (!(temp_64 & CMD_RING_RUNNING)) {
-                xhci_dbg(xhci, "Command ring had been stopped\n");
-                return 0;
-        }
         xhci->cmd_ring_state = CMD_RING_STATE_ABORTED;
         xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
                         &xhci->op_regs->cmd_ring);
@@ -337,71 +313,6 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
         return 0;
 }
 
-static int xhci_queue_cd(struct xhci_hcd *xhci,
-                struct xhci_command *command,
-                union xhci_trb *cmd_trb)
-{
-        struct xhci_cd *cd;
-        cd = kzalloc(sizeof(struct xhci_cd), GFP_ATOMIC);
-        if (!cd)
-                return -ENOMEM;
-        INIT_LIST_HEAD(&cd->cancel_cmd_list);
-
-        cd->command = command;
-        cd->cmd_trb = cmd_trb;
-        list_add_tail(&cd->cancel_cmd_list, &xhci->cancel_cmd_list);
-
-        return 0;
-}
-
-/*
- * Cancel the command which has issue.
- *
- * Some commands may hang due to waiting for acknowledgement from
- * usb device. It is outside of the xHC's ability to control and
- * will cause the command ring is blocked. When it occurs software
- * should intervene to recover the command ring.
- * See Section 4.6.1.1 and 4.6.1.2
- */
-int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
-                union xhci_trb *cmd_trb)
-{
-        int retval = 0;
-        unsigned long flags;
-
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        if (xhci->xhc_state & XHCI_STATE_DYING) {
-                xhci_warn(xhci, "Abort the command ring,"
-                                " but the xHCI is dead.\n");
-                retval = -ESHUTDOWN;
-                goto fail;
-        }
-
-        /* queue the cmd desriptor to cancel_cmd_list */
-        retval = xhci_queue_cd(xhci, command, cmd_trb);
-        if (retval) {
-                xhci_warn(xhci, "Queuing command descriptor failed.\n");
-                goto fail;
-        }
-
-        /* abort command ring */
-        retval = xhci_abort_cmd_ring(xhci);
-        if (retval) {
-                xhci_err(xhci, "Abort command ring failed\n");
-                if (unlikely(retval == -ESHUTDOWN)) {
-                        spin_unlock_irqrestore(&xhci->lock, flags);
-                        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
-                        xhci_dbg(xhci, "xHCI host controller is dead.\n");
-                        return retval;
-                }
-        }
-
-fail:
-        spin_unlock_irqrestore(&xhci->lock, flags);
-        return retval;
-}
-
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
                 unsigned int ep_index,
@@ -684,12 +595,14 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
         }
 }
 
-static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
+static int queue_set_tr_deq(struct xhci_hcd *xhci,
+                struct xhci_command *cmd, int slot_id,
                 unsigned int ep_index, unsigned int stream_id,
                 struct xhci_segment *deq_seg,
                 union xhci_trb *deq_ptr, u32 cycle_state);
 
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
+                struct xhci_command *cmd,
                 unsigned int slot_id, unsigned int ep_index,
                 unsigned int stream_id,
                 struct xhci_dequeue_state *deq_state)
@@ -704,7 +617,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
                         deq_state->new_deq_ptr,
                         (unsigned long long)xhci_trb_virt_to_dma(deq_state->new_deq_seg, deq_state->new_deq_ptr),
                         deq_state->new_cycle_state);
-        queue_set_tr_deq(xhci, slot_id, ep_index, stream_id,
+        queue_set_tr_deq(xhci, cmd, slot_id, ep_index, stream_id,
                         deq_state->new_deq_seg,
                         deq_state->new_deq_ptr,
                         (u32) deq_state->new_cycle_state);
@@ -773,7 +686,6 @@ static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
                 union xhci_trb *trb, struct xhci_event_cmd *event)
 {
         unsigned int ep_index;
-        struct xhci_virt_device *virt_dev;
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
         struct list_head *entry;
@@ -783,11 +695,7 @@ static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
         struct xhci_dequeue_state deq_state;
 
         if (unlikely(TRB_TO_SUSPEND_PORT(le32_to_cpu(trb->generic.field[3])))) {
-                virt_dev = xhci->devs[slot_id];
-                if (virt_dev)
-                        handle_cmd_in_cmd_wait_list(xhci, virt_dev,
-                                event);
-                else
+                if (!xhci->devs[slot_id])
                         xhci_warn(xhci, "Stop endpoint command "
                                 "completion for disabled slot %u\n",
                                 slot_id);
@@ -858,7 +766,9 @@ remove_finished_td:
 
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
-                xhci_queue_new_dequeue_state(xhci,
+                struct xhci_command *command;
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+                xhci_queue_new_dequeue_state(xhci, command,
                                 slot_id, ep_index,
                                 ep->stopped_td->urb->stream_id,
                                 &deq_state);
@@ -1206,9 +1116,11 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
          * because the HW can't handle two commands being queued in a row.
          */
         if (xhci->quirks & XHCI_RESET_EP_QUIRK) {
+                struct xhci_command *command;
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
                 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
                                 "Queueing configure endpoint command");
-                xhci_queue_configure_endpoint(xhci,
+                xhci_queue_configure_endpoint(xhci, command,
                                 xhci->devs[slot_id]->in_ctx->dma, slot_id,
                                 false);
                 xhci_ring_cmd_db(xhci);
@@ -1219,187 +1131,6 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
         }
 }
 
-/* Complete the command and detele it from the devcie's command queue.
- */
-static void xhci_complete_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_command *command, u32 status)
-{
-        command->status = status;
-        list_del(&command->cmd_list);
-        if (command->completion)
-                complete(command->completion);
-        else
-                xhci_free_command(xhci, command);
-}
-
-
-/* Check to see if a command in the device's command queue matches this one.
- * Signal the completion or free the command, and return 1.  Return 0 if the
- * completed command isn't at the head of the command list.
- */
-static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_virt_device *virt_dev,
-                struct xhci_event_cmd *event)
-{
-        struct xhci_command *command;
-
-        if (list_empty(&virt_dev->cmd_list))
-                return 0;
-
-        command = list_entry(virt_dev->cmd_list.next,
-                        struct xhci_command, cmd_list);
-        if (xhci->cmd_ring->dequeue != command->command_trb)
-                return 0;
-
-        xhci_complete_cmd_in_cmd_wait_list(xhci, command,
-                        GET_COMP_CODE(le32_to_cpu(event->status)));
-        return 1;
-}
-
-/*
- * Finding the command trb need to be cancelled and modifying it to
- * NO OP command. And if the command is in device's command wait
- * list, finishing and freeing it.
- *
- * If we can't find the command trb, we think it had already been
- * executed.
- */
-static void xhci_cmd_to_noop(struct xhci_hcd *xhci, struct xhci_cd *cur_cd)
-{
-        struct xhci_segment *cur_seg;
-        union xhci_trb *cmd_trb;
-        u32 cycle_state;
-
-        if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
-                return;
-
-        /* find the current segment of command ring */
-        cur_seg = find_trb_seg(xhci->cmd_ring->first_seg,
-                        xhci->cmd_ring->dequeue, &cycle_state);
-
-        if (!cur_seg) {
-                xhci_warn(xhci, "Command ring mismatch, dequeue = %p %llx (dma)\n",
-                                xhci->cmd_ring->dequeue,
-                                (unsigned long long)
-                                xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
-                                        xhci->cmd_ring->dequeue));
-                xhci_debug_ring(xhci, xhci->cmd_ring);
-                xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
-                return;
-        }
-
-        /* find the command trb matched by cd from command ring */
-        for (cmd_trb = xhci->cmd_ring->dequeue;
-                        cmd_trb != xhci->cmd_ring->enqueue;
-                        next_trb(xhci, xhci->cmd_ring, &cur_seg, &cmd_trb)) {
-                /* If the trb is link trb, continue */
-                if (TRB_TYPE_LINK_LE32(cmd_trb->generic.field[3]))
-                        continue;
-
-                if (cur_cd->cmd_trb == cmd_trb) {
-
-                        /* If the command in device's command list, we should
-                         * finish it and free the command structure.
-                         */
-                        if (cur_cd->command)
-                                xhci_complete_cmd_in_cmd_wait_list(xhci,
-                                        cur_cd->command, COMP_CMD_STOP);
-
-                        /* get cycle state from the origin command trb */
-                        cycle_state = le32_to_cpu(cmd_trb->generic.field[3])
-                                & TRB_CYCLE;
-
-                        /* modify the command trb to NO OP command */
-                        cmd_trb->generic.field[0] = 0;
-                        cmd_trb->generic.field[1] = 0;
-                        cmd_trb->generic.field[2] = 0;
-                        cmd_trb->generic.field[3] = cpu_to_le32(
-                                        TRB_TYPE(TRB_CMD_NOOP) | cycle_state);
-                        break;
-                }
-        }
-}
-
-static void xhci_cancel_cmd_in_cd_list(struct xhci_hcd *xhci)
-{
-        struct xhci_cd *cur_cd, *next_cd;
-
-        if (list_empty(&xhci->cancel_cmd_list))
-                return;
-
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                xhci_cmd_to_noop(xhci, cur_cd);
-                list_del(&cur_cd->cancel_cmd_list);
-                kfree(cur_cd);
-        }
-}
-
-/*
- * traversing the cancel_cmd_list. If the command descriptor according
- * to cmd_trb is found, the function free it and return 1, otherwise
- * return 0.
- */
-static int xhci_search_cmd_trb_in_cd_list(struct xhci_hcd *xhci,
-                union xhci_trb *cmd_trb)
-{
-        struct xhci_cd *cur_cd, *next_cd;
-
-        if (list_empty(&xhci->cancel_cmd_list))
-                return 0;
-
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                if (cur_cd->cmd_trb == cmd_trb) {
-                        if (cur_cd->command)
-                                xhci_complete_cmd_in_cmd_wait_list(xhci,
-                                        cur_cd->command, COMP_CMD_STOP);
-                        list_del(&cur_cd->cancel_cmd_list);
-                        kfree(cur_cd);
-                        return 1;
-                }
-        }
-
-        return 0;
-}
-
-/*
- * If the cmd_trb_comp_code is COMP_CMD_ABORT, we just check whether the
- * trb pointed by the command ring dequeue pointer is the trb we want to
- * cancel or not. And if the cmd_trb_comp_code is COMP_CMD_STOP, we will
- * traverse the cancel_cmd_list to trun the all of the commands according
- * to command descriptor to NO-OP trb.
- */
-static int handle_stopped_cmd_ring(struct xhci_hcd *xhci,
-                int cmd_trb_comp_code)
-{
-        int cur_trb_is_good = 0;
-
-        /* Searching the cmd trb pointed by the command ring dequeue
-         * pointer in command descriptor list. If it is found, free it.
-         */
-        cur_trb_is_good = xhci_search_cmd_trb_in_cd_list(xhci,
-                        xhci->cmd_ring->dequeue);
-
-        if (cmd_trb_comp_code == COMP_CMD_ABORT)
-                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
-        else if (cmd_trb_comp_code == COMP_CMD_STOP) {
-                /* traversing the cancel_cmd_list and canceling
-                 * the command according to command descriptor
-                 */
-                xhci_cancel_cmd_in_cd_list(xhci);
-
-                xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
-                /*
-                 * ring command ring doorbell again to restart the
-                 * command ring
-                 */
-                if (xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue)
-                        xhci_ring_cmd_db(xhci);
-        }
-        return cur_trb_is_good;
-}
-
 static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
                 u32 cmd_comp_code)
 {
@@ -1407,7 +1138,6 @@ static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
                 xhci->slot_id = slot_id;
         else
                 xhci->slot_id = 0;
-        complete(&xhci->addr_dev);
 }
 
 static void xhci_handle_cmd_disable_slot(struct xhci_hcd *xhci, int slot_id)
@@ -1432,9 +1162,6 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
         unsigned int ep_state;
         u32 add_flags, drop_flags;
 
-        virt_dev = xhci->devs[slot_id];
-        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                return;
         /*
          * Configure endpoint commands can come from the USB core
          * configuration or alt setting changes, or because the HW
@@ -1443,6 +1170,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
          * If the command was for a halted endpoint, the xHCI driver
          * is not waiting on the configure endpoint command.
          */
+        virt_dev = xhci->devs[slot_id];
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "Could not get input context, bad type.\n");
@@ -1465,7 +1193,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
                         add_flags - SLOT_FLAG == drop_flags) {
                 ep_state = virt_dev->eps[ep_index].ep_state;
                 if (!(ep_state & EP_HALTED))
-                        goto bandwidth_change;
+                        return;
                 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
                                 "Completed config ep cmd - "
                                 "last ep index = %d, state = %d",
@@ -1475,43 +1203,14 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
-bandwidth_change:
-        xhci_dbg_trace(xhci,  trace_xhci_dbg_context_change,
-                        "Completed config ep cmd");
-        virt_dev->cmd_status = cmd_comp_code;
-        complete(&virt_dev->cmd_completion);
         return;
 }
 
-static void xhci_handle_cmd_eval_ctx(struct xhci_hcd *xhci, int slot_id,
-                struct xhci_event_cmd *event, u32 cmd_comp_code)
-{
-        struct xhci_virt_device *virt_dev;
-
-        virt_dev = xhci->devs[slot_id];
-        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                return;
-        virt_dev->cmd_status = cmd_comp_code;
-        complete(&virt_dev->cmd_completion);
-}
-
-static void xhci_handle_cmd_addr_dev(struct xhci_hcd *xhci, int slot_id,
-                u32 cmd_comp_code)
-{
-        xhci->devs[slot_id]->cmd_status = cmd_comp_code;
-        complete(&xhci->addr_dev);
-}
-
 static void xhci_handle_cmd_reset_dev(struct xhci_hcd *xhci, int slot_id,
                 struct xhci_event_cmd *event)
 {
-        struct xhci_virt_device *virt_dev;
-
         xhci_dbg(xhci, "Completed reset device command.\n");
-        virt_dev = xhci->devs[slot_id];
-        if (virt_dev)
-                handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
-        else
+        if (!xhci->devs[slot_id])
                 xhci_warn(xhci, "Reset device command completion "
                                 "for disabled slot %u\n", slot_id);
 }
@@ -1529,6 +1228,116 @@ static void xhci_handle_cmd_nec_get_fw(struct xhci_hcd *xhci,
                         NEC_FW_MINOR(le32_to_cpu(event->status)));
 }
 
+static void xhci_complete_del_and_free_cmd(struct xhci_command *cmd, u32 status)
+{
+        list_del(&cmd->cmd_list);
+
+        if (cmd->completion) {
+                cmd->status = status;
+                complete(cmd->completion);
+        } else {
+                kfree(cmd);
+        }
+}
+
+void xhci_cleanup_command_queue(struct xhci_hcd *xhci)
+{
+        struct xhci_command *cur_cmd, *tmp_cmd;
+        list_for_each_entry_safe(cur_cmd, tmp_cmd, &xhci->cmd_list, cmd_list)
+                xhci_complete_del_and_free_cmd(cur_cmd, COMP_CMD_ABORT);
+}
+
+/*
+ * Turn all commands on command ring with status set to "aborted" to no-op trbs.
+ * If there are other commands waiting then restart the ring and kick the timer.
+ * This must be called with command ring stopped and xhci->lock held.
+ */
+static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci,
+                                         struct xhci_command *cur_cmd)
+{
+        struct xhci_command *i_cmd, *tmp_cmd;
+        u32 cycle_state;
+
+        /* Turn all aborted commands in list to no-ops, then restart */
+        list_for_each_entry_safe(i_cmd, tmp_cmd, &xhci->cmd_list,
+                                 cmd_list) {
+
+                if (i_cmd->status != COMP_CMD_ABORT)
+                        continue;
+
+                i_cmd->status = COMP_CMD_STOP;
+
+                xhci_dbg(xhci, "Turn aborted command %p to no-op\n",
+                         i_cmd->command_trb);
+                /* get cycle state from the original cmd trb */
+                cycle_state = le32_to_cpu(
+                        i_cmd->command_trb->generic.field[3]) & TRB_CYCLE;
+                /* modify the command trb to no-op command */
+                i_cmd->command_trb->generic.field[0] = 0;
+                i_cmd->command_trb->generic.field[1] = 0;
+                i_cmd->command_trb->generic.field[2] = 0;
+                i_cmd->command_trb->generic.field[3] = cpu_to_le32(
+                        TRB_TYPE(TRB_CMD_NOOP) | cycle_state);
+
+                /*
+                 * caller waiting for completion is called when command
+                 *  completion event is received for these no-op commands
+                 */
+        }
+
+        xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
+
+        /* ring command ring doorbell to restart the command ring */
+        if ((xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue) &&
+            !(xhci->xhc_state & XHCI_STATE_DYING)) {
+                xhci->current_cmd = cur_cmd;
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+                xhci_ring_cmd_db(xhci);
+        }
+        return;
+}
+
+
+void xhci_handle_command_timeout(unsigned long data)
+{
+        struct xhci_hcd *xhci;
+        int ret;
+        unsigned long flags;
+        u64 hw_ring_state;
+        struct xhci_command *cur_cmd = NULL;
+        xhci = (struct xhci_hcd *) data;
+
+        /* mark this command to be cancelled */
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (xhci->current_cmd) {
+                cur_cmd = xhci->current_cmd;
+                cur_cmd->status = COMP_CMD_ABORT;
+        }
+
+
+        /* Make sure command ring is running before aborting it */
+        hw_ring_state = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        if ((xhci->cmd_ring_state & CMD_RING_STATE_RUNNING) &&
+            (hw_ring_state & CMD_RING_RUNNING))  {
+
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_dbg(xhci, "Command timeout\n");
+                ret = xhci_abort_cmd_ring(xhci);
+                if (unlikely(ret == -ESHUTDOWN)) {
+                        xhci_err(xhci, "Abort command ring failed\n");
+                        xhci_cleanup_command_queue(xhci);
+                        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
+                        xhci_dbg(xhci, "xHCI host controller is dead.\n");
+                }
+                return;
+        }
+        /* command timeout on stopped ring, ring can't be aborted */
+        xhci_dbg(xhci, "Command timeout on stopped ring\n");
+        xhci_handle_stopped_cmd_ring(xhci, xhci->current_cmd);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return;
+}
+
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
@@ -1537,6 +1346,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         dma_addr_t cmd_dequeue_dma;
         u32 cmd_comp_code;
         union xhci_trb *cmd_trb;
+        struct xhci_command *cmd;
         u32 cmd_type;
 
         cmd_dma = le64_to_cpu(event->cmd_trb);
@@ -1554,26 +1364,35 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 return;
         }
 
+        cmd = list_entry(xhci->cmd_list.next, struct xhci_command, cmd_list);
+
+        if (cmd->command_trb != xhci->cmd_ring->dequeue) {
+                xhci_err(xhci,
+                         "Command completion event does not match command\n");
+                return;
+        }
+
+        del_timer(&xhci->cmd_timer);
+
         trace_xhci_cmd_completion(cmd_trb, (struct xhci_generic_trb *) event);
 
         cmd_comp_code = GET_COMP_CODE(le32_to_cpu(event->status));
-        if (cmd_comp_code == COMP_CMD_ABORT || cmd_comp_code == COMP_CMD_STOP) {
-                /* If the return value is 0, we think the trb pointed by
-                 * command ring dequeue pointer is a good trb. The good
-                 * trb means we don't want to cancel the trb, but it have
-                 * been stopped by host. So we should handle it normally.
-                 * Otherwise, driver should invoke inc_deq() and return.
-                 */
-                if (handle_stopped_cmd_ring(xhci, cmd_comp_code)) {
-                        inc_deq(xhci, xhci->cmd_ring);
-                        return;
-                }
-                /* There is no command to handle if we get a stop event when the
-                 * command ring is empty, event->cmd_trb points to the next
-                 * unset command
-                 */
-                if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
-                        return;
+
+        /* If CMD ring stopped we own the trbs between enqueue and dequeue */
+        if (cmd_comp_code == COMP_CMD_STOP) {
+                xhci_handle_stopped_cmd_ring(xhci, cmd);
+                return;
+        }
+        /*
+         * Host aborted the command ring, check if the current command was
+         * supposed to be aborted, otherwise continue normally.
+         * The command ring is stopped now, but the xHC will issue a Command
+         * Ring Stopped event which will cause us to restart it.
+         */
+        if (cmd_comp_code == COMP_CMD_ABORT) {
+                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
+                if (cmd->status == COMP_CMD_ABORT)
+                        goto event_handled;
         }
 
         cmd_type = TRB_FIELD_TO_TYPE(le32_to_cpu(cmd_trb->generic.field[3]));
@@ -1585,13 +1404,13 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci_handle_cmd_disable_slot(xhci, slot_id);
                 break;
         case TRB_CONFIG_EP:
-                xhci_handle_cmd_config_ep(xhci, slot_id, event, cmd_comp_code);
+                if (!cmd->completion)
+                        xhci_handle_cmd_config_ep(xhci, slot_id, event,
+                                                  cmd_comp_code);
                 break;
         case TRB_EVAL_CONTEXT:
-                xhci_handle_cmd_eval_ctx(xhci, slot_id, event, cmd_comp_code);
                 break;
         case TRB_ADDR_DEV:
-                xhci_handle_cmd_addr_dev(xhci, slot_id, cmd_comp_code);
                 break;
         case TRB_STOP_RING:
                 WARN_ON(slot_id != TRB_TO_SLOT_ID(
@@ -1604,6 +1423,9 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci_handle_cmd_set_deq(xhci, slot_id, cmd_trb, cmd_comp_code);
                 break;
         case TRB_CMD_NOOP:
+                /* Is this an aborted command turned to NO-OP? */
+                if (cmd->status == COMP_CMD_STOP)
+                        cmd_comp_code = COMP_CMD_STOP;
                 break;
         case TRB_RESET_EP:
                 WARN_ON(slot_id != TRB_TO_SLOT_ID(
@@ -1623,6 +1445,17 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci->error_bitmask |= 1 << 6;
                 break;
         }
+
+        /* restart timer if this wasn't the last command */
+        if (cmd->cmd_list.next != &xhci->cmd_list) {
+                xhci->current_cmd = list_entry(cmd->cmd_list.next,
+                                               struct xhci_command, cmd_list);
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+        }
+
+event_handled:
+        xhci_complete_del_and_free_cmd(cmd, cmd_comp_code);
+
         inc_deq(xhci, xhci->cmd_ring);
 }
 
@@ -1938,11 +1771,16 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
                 struct xhci_td *td, union xhci_trb *event_trb)
 {
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
+        struct xhci_command *command;
+        command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+        if (!command)
+                return;
+
         ep->ep_state |= EP_HALTED;
         ep->stopped_td = td;
         ep->stopped_stream = stream_id;
 
-        xhci_queue_reset_ep(xhci, slot_id, ep_index);
+        xhci_queue_reset_ep(xhci, command, slot_id, ep_index);
         xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
 
         ep->stopped_td = NULL;
@@ -2654,7 +2492,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                  * successful event after a short transfer.
                                  * Ignore it.
                                  */
-                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) && 
+                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) &&
                                                 ep_ring->last_td_was_short) {
                                         ep_ring->last_td_was_short = false;
                                         ret = 0;
@@ -3996,11 +3834,14 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
  * Don't decrement xhci->cmd_ring_reserved_trbs after we've queued the TRB
  * because the command event handler may want to resubmit a failed command.
  */
-static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
-                u32 field3, u32 field4, bool command_must_succeed)
+static int queue_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                         u32 field1, u32 field2,
+                         u32 field3, u32 field4, bool command_must_succeed)
 {
         int reserved_trbs = xhci->cmd_ring_reserved_trbs;
         int ret;
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ESHUTDOWN;
 
         if (!command_must_succeed)
                 reserved_trbs++;
@@ -4014,57 +3855,71 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                                         "unfailable commands failed.\n");
                 return ret;
         }
+
+        cmd->command_trb = xhci->cmd_ring->enqueue;
+        list_add_tail(&cmd->cmd_list, &xhci->cmd_list);
+
+        /* if there are no other commands queued we start the timeout timer */
+        if (xhci->cmd_list.next == &cmd->cmd_list &&
+            !timer_pending(&xhci->cmd_timer)) {
+                xhci->current_cmd = cmd;
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+        }
+
         queue_trb(xhci, xhci->cmd_ring, false, field1, field2, field3,
                         field4 | xhci->cmd_ring->cycle_state);
         return 0;
 }
 
 /* Queue a slot enable or disable request on the command ring */
-int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id)
+int xhci_queue_slot_control(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 trb_type, u32 slot_id)
 {
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         TRB_TYPE(trb_type) | SLOT_ID_FOR_TRB(slot_id), false);
 }
 
 /* Queue an address device command TRB */
-int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                              u32 slot_id, enum xhci_setup_dev setup)
+int xhci_queue_address_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, enum xhci_setup_dev setup)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id)
                         | (setup == SETUP_CONTEXT_ONLY ? TRB_BSR : 0), false);
 }
 
-int xhci_queue_vendor_command(struct xhci_hcd *xhci,
+int xhci_queue_vendor_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
                 u32 field1, u32 field2, u32 field3, u32 field4)
 {
-        return queue_command(xhci, field1, field2, field3, field4, false);
+        return queue_command(xhci, cmd, field1, field2, field3, field4, false);
 }
 
 /* Queue a reset device command TRB */
-int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id)
+int xhci_queue_reset_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 slot_id)
 {
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         TRB_TYPE(TRB_RESET_DEV) | SLOT_ID_FOR_TRB(slot_id),
                         false);
 }
 
 /* Queue a configure endpoint command TRB */
-int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
+int xhci_queue_configure_endpoint(struct xhci_hcd *xhci,
+                struct xhci_command *cmd, dma_addr_t in_ctx_ptr,
                 u32 slot_id, bool command_must_succeed)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_CONFIG_EP) | SLOT_ID_FOR_TRB(slot_id),
                         command_must_succeed);
 }
 
 /* Queue an evaluate context command TRB */
-int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed)
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, bool command_must_succeed)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_EVAL_CONTEXT) | SLOT_ID_FOR_TRB(slot_id),
                         command_must_succeed);
@@ -4074,25 +3929,26 @@ int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
  * Suspend is set to indicate "Stop Endpoint Command" is being issued to stop
  * activity on an endpoint that is about to be suspended.
  */
-int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, int suspend)
+int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                             int slot_id, unsigned int ep_index, int suspend)
 {
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_STOP_RING);
         u32 trb_suspend = SUSPEND_PORT_FOR_TRB(suspend);
 
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         trb_slot_id | trb_ep_index | type | trb_suspend, false);
 }
 
 /* Set Transfer Ring Dequeue Pointer command.
  * This should not be used for endpoints that have streams enabled.
  */
-static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, unsigned int stream_id,
-                struct xhci_segment *deq_seg,
-                union xhci_trb *deq_ptr, u32 cycle_state)
+static int queue_set_tr_deq(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                        int slot_id,
+                        unsigned int ep_index, unsigned int stream_id,
+                        struct xhci_segment *deq_seg,
+                        union xhci_trb *deq_ptr, u32 cycle_state)
 {
         dma_addr_t addr;
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
@@ -4119,18 +3975,19 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         ep->queued_deq_ptr = deq_ptr;
         if (stream_id)
                 trb_sct = SCT_FOR_TRB(SCT_PRI_TR);
-        return queue_command(xhci, lower_32_bits(addr) | trb_sct | cycle_state,
+        return queue_command(xhci, cmd,
+                        lower_32_bits(addr) | trb_sct | cycle_state,
                         upper_32_bits(addr), trb_stream_id,
                         trb_slot_id | trb_ep_index | type, false);
 }
 
-int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index)
+int xhci_queue_reset_ep(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                        int slot_id, unsigned int ep_index)
 {
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_RESET_EP);
 
-        return queue_command(xhci, 0, 0, 0, trb_slot_id | trb_ep_index | type,
-                        false);
+        return queue_command(xhci, cmd, 0, 0, 0,
+                        trb_slot_id | trb_ep_index | type, false);
 }
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 300836972faa..2b8d9a24af09 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -291,7 +291,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
                 xhci->msix_entries[i].vector = 0;
         }
 
-        ret = pci_enable_msix(pdev, xhci->msix_entries, xhci->msix_count);
+        ret = pci_enable_msix_exact(pdev, xhci->msix_entries, xhci->msix_count);
         if (ret) {
                 xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                                 "Failed to enable MSI-X");
@@ -641,10 +641,14 @@ int xhci_run(struct usb_hcd *hcd)
         writel(ER_IRQ_ENABLE(temp), &xhci->ir_set->irq_pending);
         xhci_print_ir_set(xhci, 0);
 
-        if (xhci->quirks & XHCI_NEC_HOST)
-                xhci_queue_vendor_command(xhci, 0, 0, 0,
+        if (xhci->quirks & XHCI_NEC_HOST) {
+                struct xhci_command *command;
+                command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+                if (!command)
+                        return -ENOMEM;
+                xhci_queue_vendor_command(xhci, command, 0, 0, 0,
                                 TRB_TYPE(TRB_NEC_GET_FW));
-
+        }
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "Finished xhci_run for USB2 roothub");
         return 0;
@@ -1187,10 +1191,10 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
 static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, struct urb *urb)
 {
-        struct xhci_container_ctx *in_ctx;
         struct xhci_container_ctx *out_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
         struct xhci_ep_ctx *ep_ctx;
+        struct xhci_command *command;
         int max_packet_size;
         int hw_max_packet_size;
         int ret = 0;
@@ -1215,18 +1219,24 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 /* FIXME: This won't work if a non-default control endpoint
                  * changes max packet sizes.
                  */
-                in_ctx = xhci->devs[slot_id]->in_ctx;
-                ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+
+                command = xhci_alloc_command(xhci, false, true, GFP_KERNEL);
+                if (!command)
+                        return -ENOMEM;
+
+                command->in_ctx = xhci->devs[slot_id]->in_ctx;
+                ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
                 if (!ctrl_ctx) {
                         xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                         __func__);
-                        return -ENOMEM;
+                        ret = -ENOMEM;
+                        goto command_cleanup;
                 }
                 /* Set up the modified control endpoint 0 */
                 xhci_endpoint_copy(xhci, xhci->devs[slot_id]->in_ctx,
                                 xhci->devs[slot_id]->out_ctx, ep_index);
 
-                ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
+                ep_ctx = xhci_get_ep_ctx(xhci, command->in_ctx, ep_index);
                 ep_ctx->ep_info2 &= cpu_to_le32(~MAX_PACKET_MASK);
                 ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet_size));
 
@@ -1234,17 +1244,20 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 ctrl_ctx->drop_flags = 0;
 
                 xhci_dbg(xhci, "Slot %d input context\n", slot_id);
-                xhci_dbg_ctx(xhci, in_ctx, ep_index);
+                xhci_dbg_ctx(xhci, command->in_ctx, ep_index);
                 xhci_dbg(xhci, "Slot %d output context\n", slot_id);
                 xhci_dbg_ctx(xhci, out_ctx, ep_index);
 
-                ret = xhci_configure_endpoint(xhci, urb->dev, NULL,
+                ret = xhci_configure_endpoint(xhci, urb->dev, command,
                                 true, false);
 
                 /* Clean up the input context for later use by bandwidth
                  * functions.
                  */
                 ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG);
+command_cleanup:
+                kfree(command->completion);
+                kfree(command);
         }
         return ret;
 }
@@ -1465,6 +1478,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         unsigned int ep_index;
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
+        struct xhci_command *command;
 
         xhci = hcd_to_xhci(hcd);
         spin_lock_irqsave(&xhci->lock, flags);
@@ -1534,12 +1548,14 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
          * the first cancellation to be handled.
          */
         if (!(ep->ep_state & EP_HALT_PENDING)) {
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
                 ep->ep_state |= EP_HALT_PENDING;
                 ep->stop_cmds_pending++;
                 ep->stop_cmd_timer.expires = jiffies +
                         XHCI_STOP_EP_CMD_TIMEOUT * HZ;
                 add_timer(&ep->stop_cmd_timer);
-                xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index, 0);
+                xhci_queue_stop_endpoint(xhci, command, urb->dev->slot_id,
+                                         ep_index, 0);
                 xhci_ring_cmd_db(xhci);
         }
 done:
@@ -1804,6 +1820,11 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
         int ret;
 
         switch (*cmd_status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for configure endpoint command\n");
+                ret = -ETIME;
+                break;
         case COMP_ENOMEM:
                 dev_warn(&udev->dev, "Not enough host controller resources "
                                 "for new device state.\n");
@@ -1850,6 +1871,11 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
         struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
 
         switch (*cmd_status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for evaluate context command\n");
+                ret = -ETIME;
+                break;
         case COMP_EINVAL:
                 dev_warn(&udev->dev, "WARN: xHCI driver setup invalid evaluate "
                                 "context command.\n");
@@ -2574,23 +2600,17 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 bool ctx_change, bool must_succeed)
 {
         int ret;
-        int timeleft;
         unsigned long flags;
-        struct xhci_container_ctx *in_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
-        struct completion *cmd_completion;
-        u32 *cmd_status;
         struct xhci_virt_device *virt_dev;
-        union xhci_trb *cmd_trb;
+
+        if (!command)
+                return -EINVAL;
 
         spin_lock_irqsave(&xhci->lock, flags);
         virt_dev = xhci->devs[udev->slot_id];
 
-        if (command)
-                in_ctx = command->in_ctx;
-        else
-                in_ctx = virt_dev->in_ctx;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
         if (!ctrl_ctx) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@@ -2607,7 +2627,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 return -ENOMEM;
         }
         if ((xhci->quirks & XHCI_SW_BW_CHECKING) &&
-                        xhci_reserve_bandwidth(xhci, virt_dev, in_ctx)) {
+            xhci_reserve_bandwidth(xhci, virt_dev, command->in_ctx)) {
                 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
                         xhci_free_host_resources(xhci, ctrl_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -2615,27 +2635,15 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 return -ENOMEM;
         }
 
-        if (command) {
-                cmd_completion = command->completion;
-                cmd_status = &command->status;
-                command->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-                list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
-        } else {
-                cmd_completion = &virt_dev->cmd_completion;
-                cmd_status = &virt_dev->cmd_status;
-        }
-        init_completion(cmd_completion);
-
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         if (!ctx_change)
-                ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
+                ret = xhci_queue_configure_endpoint(xhci, command,
+                                command->in_ctx->dma,
                                 udev->slot_id, must_succeed);
         else
-                ret = xhci_queue_evaluate_context(xhci, in_ctx->dma,
+                ret = xhci_queue_evaluate_context(xhci, command,
+                                command->in_ctx->dma,
                                 udev->slot_id, must_succeed);
         if (ret < 0) {
-                if (command)
-                        list_del(&command->cmd_list);
                 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
                         xhci_free_host_resources(xhci, ctrl_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -2647,26 +2655,14 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for the configure endpoint command to complete */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        cmd_completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for %s command\n",
-                                timeleft == 0 ? "Timeout" : "Signal",
-                                ctx_change == 0 ?
-                                        "configure endpoint" :
-                                        "evaluate context");
-                /* cancel the configure endpoint command */
-                ret = xhci_cancel_cmd(xhci, command, cmd_trb);
-                if (ret < 0)
-                        return ret;
-                return -ETIME;
-        }
+        wait_for_completion(command->completion);
 
         if (!ctx_change)
-                ret = xhci_configure_endpoint_result(xhci, udev, cmd_status);
+                ret = xhci_configure_endpoint_result(xhci, udev,
+                                                     &command->status);
         else
-                ret = xhci_evaluate_context_result(xhci, udev, cmd_status);
+                ret = xhci_evaluate_context_result(xhci, udev,
+                                                   &command->status);
 
         if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -2714,6 +2710,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_virt_device *virt_dev;
         struct xhci_input_control_ctx *ctrl_ctx;
         struct xhci_slot_ctx *slot_ctx;
+        struct xhci_command *command;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
         if (ret <= 0)
@@ -2725,12 +2722,19 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         virt_dev = xhci->devs[udev->slot_id];
 
+        command = xhci_alloc_command(xhci, false, true, GFP_KERNEL);
+        if (!command)
+                return -ENOMEM;
+
+        command->in_ctx = virt_dev->in_ctx;
+
         /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                 __func__);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto command_cleanup;
         }
         ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
         ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
@@ -2738,20 +2742,20 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Don't issue the command if there's no endpoints to update. */
         if (ctrl_ctx->add_flags == cpu_to_le32(SLOT_FLAG) &&
-                        ctrl_ctx->drop_flags == 0)
-                return 0;
-
+            ctrl_ctx->drop_flags == 0) {
+                ret = 0;
+                goto command_cleanup;
+        }
         xhci_dbg(xhci, "New Input Control Context:\n");
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
                      LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
-        ret = xhci_configure_endpoint(xhci, udev, NULL,
+        ret = xhci_configure_endpoint(xhci, udev, command,
                         false, false);
-        if (ret) {
+        if (ret)
                 /* Callee should call reset_bandwidth() */
-                return ret;
-        }
+                goto command_cleanup;
 
         xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx,
@@ -2783,6 +2787,9 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                 virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
                 virt_dev->eps[i].new_ring = NULL;
         }
+command_cleanup:
+        kfree(command->completion);
+        kfree(command);
 
         return ret;
 }
@@ -2884,9 +2891,14 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
          * issue a configure endpoint command later.
          */
         if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {
+                struct xhci_command *command;
+                /* Can't sleep if we're called from cleanup_halted_endpoint() */
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+                if (!command)
+                        return;
                 xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
                                 "Queueing new dequeue state");
-                xhci_queue_new_dequeue_state(xhci, udev->slot_id,
+                xhci_queue_new_dequeue_state(xhci, command, udev->slot_id,
                                 ep_index, ep->stopped_stream, &deq_state);
         } else {
                 /* Better hope no one uses the input context between now and the
@@ -2917,6 +2929,7 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
         unsigned long flags;
         int ret;
         struct xhci_virt_ep *virt_ep;
+        struct xhci_command *command;
 
         xhci = hcd_to_xhci(hcd);
         udev = (struct usb_device *) ep->hcpriv;
@@ -2939,10 +2952,14 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
                 return;
         }
 
+        command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+        if (!command)
+                return;
+
         xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
                         "Queueing reset endpoint command");
         spin_lock_irqsave(&xhci->lock, flags);
-        ret = xhci_queue_reset_ep(xhci, udev->slot_id, ep_index);
+        ret = xhci_queue_reset_ep(xhci, command, udev->slot_id, ep_index);
         /*
          * Can't change the ring dequeue pointer until it's transitioned to the
          * stopped state, which is only upon a successful reset endpoint
@@ -3416,7 +3433,6 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         unsigned int slot_id;
         struct xhci_virt_device *virt_dev;
         struct xhci_command *reset_device_cmd;
-        int timeleft;
         int last_freed_endpoint;
         struct xhci_slot_ctx *slot_ctx;
         int old_active_eps = 0;
@@ -3473,13 +3489,10 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Attempt to submit the Reset Device command to the command ring */
         spin_lock_irqsave(&xhci->lock, flags);
-        reset_device_cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
 
-        list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
-        ret = xhci_queue_reset_device(xhci, slot_id);
+        ret = xhci_queue_reset_device(xhci, reset_device_cmd, slot_id);
         if (ret) {
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
-                list_del(&reset_device_cmd->cmd_list);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 goto command_cleanup;
         }
@@ -3487,22 +3500,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for the Reset Device command to finish */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        reset_device_cmd->completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for reset device command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                spin_lock_irqsave(&xhci->lock, flags);
-                /* The timeout might have raced with the event ring handler, so
-                 * only delete from the list if the item isn't poisoned.
-                 */
-                if (reset_device_cmd->cmd_list.next != LIST_POISON1)
-                        list_del(&reset_device_cmd->cmd_list);
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                ret = -ETIME;
-                goto command_cleanup;
-        }
+        wait_for_completion(reset_device_cmd->completion);
 
         /* The Reset Device command can't fail, according to the 0.95/0.96 spec,
          * unless we tried to reset a slot ID that wasn't enabled,
@@ -3510,6 +3508,11 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
          */
         ret = reset_device_cmd->status;
         switch (ret) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout waiting for reset device command\n");
+                ret = -ETIME;
+                goto command_cleanup;
         case COMP_EBADSLT: /* 0.95 completion code for bad slot ID */
         case COMP_CTX_STATE: /* 0.96 completion code for same thing */
                 xhci_dbg(xhci, "Can't reset device (slot ID %u) in %s state\n",
@@ -3589,6 +3592,11 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         unsigned long flags;
         u32 state;
         int i, ret;
+        struct xhci_command *command;
+
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return;
 
 #ifndef CONFIG_USB_DEFAULT_PERSIST
         /*
@@ -3604,8 +3612,10 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         /* If the host is halted due to driver unload, we still need to free the
          * device.
          */
-        if (ret <= 0 && ret != -ENODEV)
+        if (ret <= 0 && ret != -ENODEV) {
+                kfree(command);
                 return;
+        }
 
         virt_dev = xhci->devs[udev->slot_id];
 
@@ -3622,16 +3632,19 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
                         (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
                 spin_unlock_irqrestore(&xhci->lock, flags);
+                kfree(command);
                 return;
         }
 
-        if (xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id)) {
+        if (xhci_queue_slot_control(xhci, command, TRB_DISABLE_SLOT,
+                                    udev->slot_id)) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
                 return;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
+
         /*
          * Event command completion handler will free any data structures
          * associated with the slot.  XXX Can free sleep?
@@ -3669,33 +3682,33 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         unsigned long flags;
-        int timeleft;
         int ret;
-        union xhci_trb *cmd_trb;
+        struct xhci_command *command;
+
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return 0;
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0);
+        command->completion = &xhci->addr_dev;
+        ret = xhci_queue_slot_control(xhci, command, TRB_ENABLE_SLOT, 0);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+                kfree(command);
                 return 0;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
-        /* XXX: how much time for xHC slot assignment? */
-        timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for a slot\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                /* cancel the enable slot request */
-                return xhci_cancel_cmd(xhci, NULL, cmd_trb);
-        }
+        wait_for_completion(command->completion);
 
-        if (!xhci->slot_id) {
+        if (!xhci->slot_id || command->status != COMP_SUCCESS) {
                 xhci_err(xhci, "Error while assigning device slot ID\n");
+                xhci_err(xhci, "Max number of devices this xHCI host supports is %u.\n",
+                                HCS_MAX_SLOTS(
+                                        readl(&xhci->cap_regs->hcs_params1)));
+                kfree(command);
                 return 0;
         }
 
@@ -3730,6 +3743,8 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 pm_runtime_get_noresume(hcd->self.controller);
 #endif
 
+
+        kfree(command);
         /* Is this a LS or FS device under a HS hub? */
         /* Hub or peripherial? */
         return 1;
@@ -3737,7 +3752,10 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 disable_slot:
         /* Disable slot, if we can do it without mem alloc */
         spin_lock_irqsave(&xhci->lock, flags);
-        if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
+        command->completion = NULL;
+        command->status = 0;
+        if (!xhci_queue_slot_control(xhci, command, TRB_DISABLE_SLOT,
+                                     udev->slot_id))
                 xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
         return 0;
@@ -3754,14 +3772,13 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
 {
         const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
         unsigned long flags;
-        int timeleft;
         struct xhci_virt_device *virt_dev;
         int ret = 0;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         struct xhci_slot_ctx *slot_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
         u64 temp_64;
-        union xhci_trb *cmd_trb;
+        struct xhci_command *command;
 
         if (!udev->slot_id) {
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
@@ -3782,11 +3799,19 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                 return -EINVAL;
         }
 
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return -ENOMEM;
+
+        command->in_ctx = virt_dev->in_ctx;
+        command->completion = &xhci->addr_dev;
+
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                 __func__);
+                kfree(command);
                 return -EINVAL;
         }
         /*
@@ -3808,36 +3833,31 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                                 le32_to_cpu(slot_ctx->dev_info) >> 27);
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma,
+        ret = xhci_queue_address_device(xhci, command, virt_dev->in_ctx->dma,
                                         udev->slot_id, setup);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                                 "FIXME: allocate a command ring segment");
+                kfree(command);
                 return ret;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */
-        timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
+        wait_for_completion(command->completion);
+
         /* FIXME: From section 4.3.4: "Software shall be responsible for timing
          * the SetAddress() "recovery interval" required by USB and aborting the
          * command on a timeout.
          */
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for setup %s command\n",
-                          timeleft == 0 ? "Timeout" : "Signal", act);
-                /* cancel the address device command */
-                ret = xhci_cancel_cmd(xhci, NULL, cmd_trb);
-                if (ret < 0)
-                        return ret;
-                return -ETIME;
-        }
-
-        switch (virt_dev->cmd_status) {
+        switch (command->status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for setup device command\n");
+                ret = -ETIME;
+                break;
         case COMP_CTX_STATE:
         case COMP_EBADSLT:
                 xhci_err(xhci, "Setup ERROR: setup %s command for slot %d.\n",
@@ -3860,7 +3880,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         default:
                 xhci_err(xhci,
                          "ERROR: unexpected setup %s command completion code 0x%x.\n",
-                         act, virt_dev->cmd_status);
+                         act, command->status);
                 xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
                 xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
                 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, 1);
@@ -3868,6 +3888,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                 break;
         }
         if (ret) {
+                kfree(command);
                 return ret;
         }
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
@@ -3902,7 +3923,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                        "Internal device address = %d",
                        le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK);
-
+        kfree(command);
         return 0;
 }
 
@@ -4092,7 +4113,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
         field = le32_to_cpu(udev->bos->ext_cap->bmAttributes);
 
         xhci_dbg(xhci, "%s port %d USB2 hardware LPM\n",
-                        enable ? "enable" : "disable", port_num);
+                        enable ? "enable" : "disable", port_num + 1);
 
         if (enable) {
                 /* Host supports BESL timeout instead of HIRD */
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 4746816aed3e..9ffecd56600d 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -937,9 +937,6 @@ struct xhci_virt_device {
 #define XHCI_MAX_RINGS_CACHED   31
         struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
-        /* Status of the last command issued for this device */
-        u32                             cmd_status;
-        struct list_head                cmd_list;
         u8                              fake_port;
         u8                              real_port;
         struct xhci_interval_bw_table   *bw_table;
@@ -1298,7 +1295,6 @@ struct xhci_td {
 
 /* command descriptor */
 struct xhci_cd {
-        struct list_head        cancel_cmd_list;
         struct xhci_command     *command;
         union xhci_trb          *cmd_trb;
 };
@@ -1476,6 +1472,8 @@ struct xhci_hcd {
         /* msi-x vectors */
         int             msix_count;
         struct msix_entry       *msix_entries;
+        /* optional clock */
+        struct clk              *clk;
         /* data structures */
         struct xhci_device_context_array *dcbaa;
         struct xhci_ring        *cmd_ring;
@@ -1483,8 +1481,10 @@ struct xhci_hcd {
 #define CMD_RING_STATE_RUNNING         (1 << 0)
 #define CMD_RING_STATE_ABORTED         (1 << 1)
 #define CMD_RING_STATE_STOPPED         (1 << 2)
-        struct list_head        cancel_cmd_list;
+        struct list_head        cmd_list;
         unsigned int            cmd_ring_reserved_trbs;
+        struct timer_list       cmd_timer;
+        struct xhci_command     *current_cmd;
         struct xhci_ring        *event_ring;
         struct xhci_erst        erst;
         /* Scratchpad */
@@ -1738,8 +1738,7 @@ static inline int xhci_register_pci(void) { return 0; }
 static inline void xhci_unregister_pci(void) {}
 #endif
 
-#if defined(CONFIG_USB_XHCI_PLATFORM) \
-        || defined(CONFIG_USB_XHCI_PLATFORM_MODULE)
+#if IS_ENABLED(CONFIG_USB_XHCI_PLATFORM)
 int xhci_register_plat(void);
 void xhci_unregister_plat(void);
 #else
@@ -1808,13 +1807,14 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 dma_addr_t suspect_dma);
 int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code);
 void xhci_ring_cmd_db(struct xhci_hcd *xhci);
-int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id);
-int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, enum xhci_setup_dev);
-int xhci_queue_vendor_command(struct xhci_hcd *xhci,
+int xhci_queue_slot_control(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 trb_type, u32 slot_id);
+int xhci_queue_address_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, enum xhci_setup_dev);
+int xhci_queue_vendor_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
                 u32 field1, u32 field2, u32 field3, u32 field4);
-int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, int suspend);
+int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                int slot_id, unsigned int ep_index, int suspend);
 int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
@@ -1823,18 +1823,21 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index);
-int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed);
-int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed);
-int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index);
-int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id);
+int xhci_queue_configure_endpoint(struct xhci_hcd *xhci,
+                struct xhci_command *cmd, dma_addr_t in_ctx_ptr, u32 slot_id,
+                bool command_must_succeed);
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, bool command_must_succeed);
+int xhci_queue_reset_ep(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                int slot_id, unsigned int ep_index);
+int xhci_queue_reset_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 slot_id);
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 unsigned int stream_id, struct xhci_td *cur_td,
                 struct xhci_dequeue_state *state);
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
+                struct xhci_command *cmd,
                 unsigned int slot_id, unsigned int ep_index,
                 unsigned int stream_id,
                 struct xhci_dequeue_state *deq_state);
@@ -1844,11 +1847,11 @@ void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state);
 void xhci_stop_endpoint_command_watchdog(unsigned long arg);
-int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
-                union xhci_trb *cmd_trb);
+void xhci_handle_command_timeout(unsigned long data);
+
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, unsigned int stream_id);
-union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring);
+void xhci_cleanup_command_queue(struct xhci_hcd *xhci);
 
 /* xHCI roothub code */
 void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index ba6a5d6e618e..b3d245ef46ef 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -81,6 +81,7 @@ struct appledisplay {
         struct delayed_work work;
         int button_pressed;
         spinlock_t lock;
+        struct mutex sysfslock;         /* concurrent read and write */
 };
 
 static atomic_t count_displays = ATOMIC_INIT(0);
@@ -110,7 +111,7 @@ static void appledisplay_complete(struct urb *urb)
                         __func__, status);
                 return;
         default:
-                dev_dbg(dev, "%s - nonzero urb status received: %d/n",
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n",
                         __func__, status);
                 goto exit;
         }
@@ -144,6 +145,7 @@ static int appledisplay_bl_update_status(struct backlight_device *bd)
         struct appledisplay *pdata = bl_get_data(bd);
         int retval;
 
+        mutex_lock(&pdata->sysfslock);
         pdata->msgdata[0] = 0x10;
         pdata->msgdata[1] = bd->props.brightness;
 
@@ -156,15 +158,17 @@ static int appledisplay_bl_update_status(struct backlight_device *bd)
                 0,
                 pdata->msgdata, 2,
                 ACD_USB_TIMEOUT);
-
+        mutex_unlock(&pdata->sysfslock);
+        
         return retval;
 }
 
 static int appledisplay_bl_get_brightness(struct backlight_device *bd)
 {
         struct appledisplay *pdata = bl_get_data(bd);
-        int retval;
+        int retval, brightness;
 
+        mutex_lock(&pdata->sysfslock);
         retval = usb_control_msg(
                 pdata->udev,
                 usb_rcvctrlpipe(pdata->udev, 0),
@@ -174,11 +178,13 @@ static int appledisplay_bl_get_brightness(struct backlight_device *bd)
                 0,
                 pdata->msgdata, 2,
                 ACD_USB_TIMEOUT);
+        brightness = pdata->msgdata[1];
+        mutex_unlock(&pdata->sysfslock);
 
         if (retval < 0)
                 return retval;
         else
-                return pdata->msgdata[1];
+                return brightness;
 }
 
 static const struct backlight_ops appledisplay_bl_data = {
@@ -241,6 +247,7 @@ static int appledisplay_probe(struct usb_interface *iface,
 
         spin_lock_init(&pdata->lock);
         INIT_DELAYED_WORK(&pdata->work, appledisplay_work);
+        mutex_init(&pdata->sysfslock);
 
         /* Allocate buffer for control messages */
         pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index a4a3c7cd4a11..8ab1f8f3c26e 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -1,40 +1,43 @@
 /*
-* USB FTDI client driver for Elan Digital Systems's Uxxx adapters
-*
-* Copyright(C) 2006 Elan Digital Systems Limited
-* http://www.elandigitalsystems.com
-*
-* Author and Maintainer - Tony Olech - Elan Digital Systems
-* tony.olech@elandigitalsystems.com
-*
-* This program is free software;you can redistribute it and/or
-* modify it under the terms of the GNU General Public License as
-* published by the Free Software Foundation, version 2.
-*
-*
-* This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
-* based on various USB client drivers in the 2.6.15 linux kernel
-* with constant reference to the 3rd Edition of Linux Device Drivers
-* published by O'Reilly
-*
-* The U132 adapter is a USB to CardBus adapter specifically designed
-* for PC cards that contain an OHCI host controller. Typical PC cards
-* are the Orange Mobile 3G Option GlobeTrotter Fusion card.
-*
-* The U132 adapter will *NOT *work with PC cards that do not contain
-* an OHCI controller. A simple way to test whether a PC card has an
-* OHCI controller as an interface is to insert the PC card directly
-* into a laptop(or desktop) with a CardBus slot and if "lspci" shows
-* a new USB controller and "lsusb -v" shows a new OHCI Host Controller
-* then there is a good chance that the U132 adapter will support the
-* PC card.(you also need the specific client driver for the PC card)
-*
-* Please inform the Author and Maintainer about any PC cards that
-* contain OHCI Host Controller and work when directly connected to
-* an embedded CardBus slot but do not work when they are connected
-* via an ELAN U132 adapter.
-*
-*/
+ * USB FTDI client driver for Elan Digital Systems's Uxxx adapters
+ *
+ * Copyright(C) 2006 Elan Digital Systems Limited
+ * http://www.elandigitalsystems.com
+ *
+ * Author and Maintainer - Tony Olech - Elan Digital Systems
+ * tony.olech@elandigitalsystems.com
+ *
+ * This program is free software;you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ *
+ *
+ * This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
+ * based on various USB client drivers in the 2.6.15 linux kernel
+ * with constant reference to the 3rd Edition of Linux Device Drivers
+ * published by O'Reilly
+ *
+ * The U132 adapter is a USB to CardBus adapter specifically designed
+ * for PC cards that contain an OHCI host controller. Typical PC cards
+ * are the Orange Mobile 3G Option GlobeTrotter Fusion card.
+ *
+ * The U132 adapter will *NOT *work with PC cards that do not contain
+ * an OHCI controller. A simple way to test whether a PC card has an
+ * OHCI controller as an interface is to insert the PC card directly
+ * into a laptop(or desktop) with a CardBus slot and if "lspci" shows
+ * a new USB controller and "lsusb -v" shows a new OHCI Host Controller
+ * then there is a good chance that the U132 adapter will support the
+ * PC card.(you also need the specific client driver for the PC card)
+ *
+ * Please inform the Author and Maintainer about any PC cards that
+ * contain OHCI Host Controller and work when directly connected to
+ * an embedded CardBus slot but do not work when they are connected
+ * via an ELAN U132 adapter.
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
@@ -55,31 +58,31 @@ MODULE_LICENSE("GPL");
 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
 static bool distrust_firmware = 1;
 module_param(distrust_firmware, bool, 0);
-MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
-        "t setup");
+MODULE_PARM_DESC(distrust_firmware,
+                 "true to distrust firmware power/overcurrent setup");
 extern struct platform_driver u132_platform_driver;
 static struct workqueue_struct *status_queue;
 static struct workqueue_struct *command_queue;
 static struct workqueue_struct *respond_queue;
 /*
-* ftdi_module_lock exists to protect access to global variables
-*
-*/
+ * ftdi_module_lock exists to protect access to global variables
+ *
+ */
 static struct mutex ftdi_module_lock;
 static int ftdi_instances = 0;
 static struct list_head ftdi_static_list;
 /*
-* end of the global variables protected by ftdi_module_lock
-*/
+ * end of the global variables protected by ftdi_module_lock
+ */
 #include "usb_u132.h"
 #include <asm/io.h>
 #include <linux/usb/hcd.h>
 
-        /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
-         * If you're going to try stuff like this, you need to split
-         * out shareable stuff (register declarations?) into its own
-         * file, maybe name <linux/usb/ohci.h>
-         */
+/* FIXME ohci.h is ONLY for internal use by the OHCI driver.
+ * If you're going to try stuff like this, you need to split
+ * out shareable stuff (register declarations?) into its own
+ * file, maybe name <linux/usb/ohci.h>
+ */
 
 #include "../host/ohci.h"
 /* Define these values to match your devices*/
@@ -87,140 +90,140 @@ static struct list_head ftdi_static_list;
 #define USB_FTDI_ELAN_PRODUCT_ID 0xd6ea
 /* table of devices that work with this driver*/
 static const struct usb_device_id ftdi_elan_table[] = {
-        {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
-        { /* Terminating entry */ }
+        {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
+        { /* Terminating entry */ }
 };
 
 MODULE_DEVICE_TABLE(usb, ftdi_elan_table);
 /* only the jtag(firmware upgrade device) interface requires
-* a device file and corresponding minor number, but the
-* interface is created unconditionally - I suppose it could
-* be configured or not according to a module parameter.
-* But since we(now) require one interface per device,
-* and since it unlikely that a normal installation would
-* require more than a couple of elan-ftdi devices, 8 seems
-* like a reasonable limit to have here, and if someone
-* really requires more than 8 devices, then they can frig the
-* code and recompile
-*/
+ * a device file and corresponding minor number, but the
+ * interface is created unconditionally - I suppose it could
+ * be configured or not according to a module parameter.
+ * But since we(now) require one interface per device,
+ * and since it unlikely that a normal installation would
+ * require more than a couple of elan-ftdi devices, 8 seems
+ * like a reasonable limit to have here, and if someone
+ * really requires more than 8 devices, then they can frig the
+ * code and recompile
+ */
 #define USB_FTDI_ELAN_MINOR_BASE 192
 #define COMMAND_BITS 5
 #define COMMAND_SIZE (1<<COMMAND_BITS)
 #define COMMAND_MASK (COMMAND_SIZE-1)
 struct u132_command {
-        u8 header;
-        u16 length;
-        u8 address;
-        u8 width;
-        u32 value;
-        int follows;
-        void *buffer;
+        u8 header;
+        u16 length;
+        u8 address;
+        u8 width;
+        u32 value;
+        int follows;
+        void *buffer;
 };
 #define RESPOND_BITS 5
 #define RESPOND_SIZE (1<<RESPOND_BITS)
 #define RESPOND_MASK (RESPOND_SIZE-1)
 struct u132_respond {
-        u8 header;
-        u8 address;
-        u32 *value;
-        int *result;
-        struct completion wait_completion;
+        u8 header;
+        u8 address;
+        u32 *value;
+        int *result;
+        struct completion wait_completion;
 };
 struct u132_target {
-        void *endp;
-        struct urb *urb;
-        int toggle_bits;
-        int error_count;
-        int condition_code;
-        int repeat_number;
-        int halted;
-        int skipped;
-        int actual;
-        int non_null;
-        int active;
-        int abandoning;
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-                int toggle_bits, int error_count, int condition_code,
-                int repeat_number, int halted, int skipped, int actual,
-                int non_null);
+        void *endp;
+        struct urb *urb;
+        int toggle_bits;
+        int error_count;
+        int condition_code;
+        int repeat_number;
+        int halted;
+        int skipped;
+        int actual;
+        int non_null;
+        int active;
+        int abandoning;
+        void (*callback)(void *endp, struct urb *urb, u8 *buf, int len,
+                         int toggle_bits, int error_count, int condition_code,
+                         int repeat_number, int halted, int skipped, int actual,
+                         int non_null);
 };
 /* Structure to hold all of our device specific stuff*/
 struct usb_ftdi {
-        struct list_head ftdi_list;
-        struct mutex u132_lock;
-        int command_next;
-        int command_head;
-        struct u132_command command[COMMAND_SIZE];
-        int respond_next;
-        int respond_head;
-        struct u132_respond respond[RESPOND_SIZE];
-        struct u132_target target[4];
-        char device_name[16];
-        unsigned synchronized:1;
-        unsigned enumerated:1;
-        unsigned registered:1;
-        unsigned initialized:1;
-        unsigned card_ejected:1;
-        int function;
-        int sequence_num;
-        int disconnected;
-        int gone_away;
-        int stuck_status;
-        int status_queue_delay;
-        struct semaphore sw_lock;
-        struct usb_device *udev;
-        struct usb_interface *interface;
-        struct usb_class_driver *class;
-        struct delayed_work status_work;
-        struct delayed_work command_work;
-        struct delayed_work respond_work;
-        struct u132_platform_data platform_data;
-        struct resource resources[0];
-        struct platform_device platform_dev;
-        unsigned char *bulk_in_buffer;
-        size_t bulk_in_size;
-        size_t bulk_in_last;
-        size_t bulk_in_left;
-        __u8 bulk_in_endpointAddr;
-        __u8 bulk_out_endpointAddr;
-        struct kref kref;
-        u32 controlreg;
-        u8 response[4 + 1024];
-        int expected;
-        int received;
-        int ed_found;
+        struct list_head ftdi_list;
+        struct mutex u132_lock;
+        int command_next;
+        int command_head;
+        struct u132_command command[COMMAND_SIZE];
+        int respond_next;
+        int respond_head;
+        struct u132_respond respond[RESPOND_SIZE];
+        struct u132_target target[4];
+        char device_name[16];
+        unsigned synchronized:1;
+        unsigned enumerated:1;
+        unsigned registered:1;
+        unsigned initialized:1;
+        unsigned card_ejected:1;
+        int function;
+        int sequence_num;
+        int disconnected;
+        int gone_away;
+        int stuck_status;
+        int status_queue_delay;
+        struct semaphore sw_lock;
+        struct usb_device *udev;
+        struct usb_interface *interface;
+        struct usb_class_driver *class;
+        struct delayed_work status_work;
+        struct delayed_work command_work;
+        struct delayed_work respond_work;
+        struct u132_platform_data platform_data;
+        struct resource resources[0];
+        struct platform_device platform_dev;
+        unsigned char *bulk_in_buffer;
+        size_t bulk_in_size;
+        size_t bulk_in_last;
+        size_t bulk_in_left;
+        __u8 bulk_in_endpointAddr;
+        __u8 bulk_out_endpointAddr;
+        struct kref kref;
+        u32 controlreg;
+        u8 response[4 + 1024];
+        int expected;
+        int received;
+        int ed_found;
 };
 #define kref_to_usb_ftdi(d) container_of(d, struct usb_ftdi, kref)
 #define platform_device_to_usb_ftdi(d) container_of(d, struct usb_ftdi, \
-        platform_dev)
+                                                    platform_dev)
 static struct usb_driver ftdi_elan_driver;
 static void ftdi_elan_delete(struct kref *kref)
 {
-        struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
-        dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
-        usb_put_dev(ftdi->udev);
-        ftdi->disconnected += 1;
-        mutex_lock(&ftdi_module_lock);
-        list_del_init(&ftdi->ftdi_list);
-        ftdi_instances -= 1;
-        mutex_unlock(&ftdi_module_lock);
-        kfree(ftdi->bulk_in_buffer);
-        ftdi->bulk_in_buffer = NULL;
+        struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
+        dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
+        usb_put_dev(ftdi->udev);
+        ftdi->disconnected += 1;
+        mutex_lock(&ftdi_module_lock);
+        list_del_init(&ftdi->ftdi_list);
+        ftdi_instances -= 1;
+        mutex_unlock(&ftdi_module_lock);
+        kfree(ftdi->bulk_in_buffer);
+        ftdi->bulk_in_buffer = NULL;
 }
 
 static void ftdi_elan_put_kref(struct usb_ftdi *ftdi)
 {
-        kref_put(&ftdi->kref, ftdi_elan_delete);
+        kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_elan_get_kref(struct usb_ftdi *ftdi)
 {
-        kref_get(&ftdi->kref);
+        kref_get(&ftdi->kref);
 }
 
 static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
 {
-        kref_init(&ftdi->kref);
+        kref_init(&ftdi->kref);
 }
 
 static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
@@ -237,8 +240,8 @@ static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->status_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->status_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
@@ -255,12 +258,12 @@ static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->command_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->command_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_response_requeue_work(struct usb_ftdi *ftdi,
-        unsigned int delta)
+                                       unsigned int delta)
 {
         if (!queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
                 kref_put(&ftdi->kref, ftdi_elan_delete);
@@ -274,26 +277,26 @@ static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_response_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->respond_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->respond_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 void ftdi_elan_gone_away(struct platform_device *pdev)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        ftdi->gone_away += 1;
-        ftdi_elan_put_kref(ftdi);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        ftdi->gone_away += 1;
+        ftdi_elan_put_kref(ftdi);
 }
 
 
 EXPORT_SYMBOL_GPL(ftdi_elan_gone_away);
 static void ftdi_release_platform_dev(struct device *dev)
 {
-        dev->parent = NULL;
+        dev->parent = NULL;
 }
 
 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
-        struct u132_target *target, u8 *buffer, int length);
+                                  struct u132_target *target, u8 *buffer, int length);
 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi);
 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi);
 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi);
@@ -305,421 +308,416 @@ static int ftdi_elan_command_engine(struct usb_ftdi *ftdi);
 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi);
 static int ftdi_elan_hcd_init(struct usb_ftdi *ftdi)
 {
-        int result;
-        if (ftdi->platform_dev.dev.parent)
-                return -EBUSY;
-        ftdi_elan_get_kref(ftdi);
-        ftdi->platform_data.potpg = 100;
-        ftdi->platform_data.reset = NULL;
-        ftdi->platform_dev.id = ftdi->sequence_num;
-        ftdi->platform_dev.resource = ftdi->resources;
-        ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
-        ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
-        ftdi->platform_dev.dev.parent = NULL;
-        ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
-        ftdi->platform_dev.dev.dma_mask = NULL;
-        snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
-        ftdi->platform_dev.name = ftdi->device_name;
-        dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
-        request_module("u132_hcd");
-        dev_info(&ftdi->udev->dev, "registering '%s'\n",
-                ftdi->platform_dev.name);
-        result = platform_device_register(&ftdi->platform_dev);
-        return result;
+        int result;
+        if (ftdi->platform_dev.dev.parent)
+                return -EBUSY;
+        ftdi_elan_get_kref(ftdi);
+        ftdi->platform_data.potpg = 100;
+        ftdi->platform_data.reset = NULL;
+        ftdi->platform_dev.id = ftdi->sequence_num;
+        ftdi->platform_dev.resource = ftdi->resources;
+        ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
+        ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
+        ftdi->platform_dev.dev.parent = NULL;
+        ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
+        ftdi->platform_dev.dev.dma_mask = NULL;
+        snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
+        ftdi->platform_dev.name = ftdi->device_name;
+        dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
+        request_module("u132_hcd");
+        dev_info(&ftdi->udev->dev, "registering '%s'\n",
+                 ftdi->platform_dev.name);
+        result = platform_device_register(&ftdi->platform_dev);
+        return result;
 }
 
 static void ftdi_elan_abandon_completions(struct usb_ftdi *ftdi)
 {
-        mutex_lock(&ftdi->u132_lock);
-        while (ftdi->respond_next > ftdi->respond_head) {
-                struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
-                        ftdi->respond_head++];
-                *respond->result = -ESHUTDOWN;
-                *respond->value = 0;
-                complete(&respond->wait_completion);
-        } mutex_unlock(&ftdi->u132_lock);
+        mutex_lock(&ftdi->u132_lock);
+        while (ftdi->respond_next > ftdi->respond_head) {
+                struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
+                                                              ftdi->respond_head++];
+                *respond->result = -ESHUTDOWN;
+                *respond->value = 0;
+                complete(&respond->wait_completion);
+        } mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_abandon_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                if (target->active == 1) {
-                        target->condition_code = TD_DEVNOTRESP;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, NULL, 0);
-                        mutex_lock(&ftdi->u132_lock);
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                if (target->active == 1) {
+                        target->condition_code = TD_DEVNOTRESP;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, NULL, 0);
+                        mutex_lock(&ftdi->u132_lock);
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_flush_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                target->abandoning = 1;
-              wait_1:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x80 | (ed_number << 5) | 0x4;
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait_1;
-                        }
-                }
-              wait_2:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x90 | (ed_number << 5);
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait_2;
-                        }
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                target->abandoning = 1;
+        wait_1:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x80 | (ed_number << 5) | 0x4;
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait_1;
+                        }
+                }
+        wait_2:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x90 | (ed_number << 5);
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait_2;
+                        }
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                target->abandoning = 1;
-              wait:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x80 | (ed_number << 5) | 0x4;
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait;
-                        }
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                target->abandoning = 1;
+        wait:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x80 | (ed_number << 5) | 0x4;
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait;
+                        }
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
 {
-        ftdi_command_queue_work(ftdi, 0);
+        ftdi_command_queue_work(ftdi, 0);
 }
 
 static void ftdi_elan_command_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, command_work.work);
 
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                int retval = ftdi_elan_command_engine(ftdi);
-                if (retval == -ESHUTDOWN) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -ENODEV) {
-                        ftdi->disconnected += 1;
-                } else if (retval)
-                        dev_err(&ftdi->udev->dev, "command error %d\n", retval);
-                ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
-                return;
-        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                int retval = ftdi_elan_command_engine(ftdi);
+                if (retval == -ESHUTDOWN) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -ENODEV) {
+                        ftdi->disconnected += 1;
+                } else if (retval)
+                        dev_err(&ftdi->udev->dev, "command error %d\n", retval);
+                ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
+                return;
+        }
 }
 
 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
 {
-        ftdi_respond_queue_work(ftdi, 0);
+        ftdi_respond_queue_work(ftdi, 0);
 }
 
 static void ftdi_elan_respond_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, respond_work.work);
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                int retval = ftdi_elan_respond_engine(ftdi);
-                if (retval == 0) {
-                } else if (retval == -ESHUTDOWN) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -ENODEV) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -EILSEQ) {
-                        ftdi->disconnected += 1;
-                } else {
-                        ftdi->disconnected += 1;
-                        dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
-                }
-                if (ftdi->disconnected > 0) {
-                        ftdi_elan_abandon_completions(ftdi);
-                        ftdi_elan_abandon_targets(ftdi);
-                }
-                ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
-                return;
-        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                int retval = ftdi_elan_respond_engine(ftdi);
+                if (retval == 0) {
+                } else if (retval == -ESHUTDOWN) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -ENODEV) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -EILSEQ) {
+                        ftdi->disconnected += 1;
+                } else {
+                        ftdi->disconnected += 1;
+                        dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
+                }
+                if (ftdi->disconnected > 0) {
+                        ftdi_elan_abandon_completions(ftdi);
+                        ftdi_elan_abandon_targets(ftdi);
+                }
+                ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
+                return;
+        }
 }
 
 
 /*
-* the sw_lock is initially held and will be freed
-* after the FTDI has been synchronized
-*
-*/
+ * the sw_lock is initially held and will be freed
+ * after the FTDI has been synchronized
+ *
+ */
 static void ftdi_elan_status_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, status_work.work);
-        int work_delay_in_msec = 0;
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else if (ftdi->synchronized == 0) {
-                down(&ftdi->sw_lock);
-                if (ftdi_elan_synchronize(ftdi) == 0) {
-                        ftdi->synchronized = 1;
-                        ftdi_command_queue_work(ftdi, 1);
-                        ftdi_respond_queue_work(ftdi, 1);
-                        up(&ftdi->sw_lock);
-                        work_delay_in_msec = 100;
-                } else {
-                        dev_err(&ftdi->udev->dev, "synchronize failed\n");
-                        up(&ftdi->sw_lock);
-                        work_delay_in_msec = 10 *1000;
-                }
-        } else if (ftdi->stuck_status > 0) {
-                if (ftdi_elan_stuck_waiting(ftdi) == 0) {
-                        ftdi->stuck_status = 0;
-                        ftdi->synchronized = 0;
-                } else if ((ftdi->stuck_status++ % 60) == 1) {
-                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
-                                "- please remove\n");
-                } else
-                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
-                                "- checked %d times\n", ftdi->stuck_status);
-                work_delay_in_msec = 100;
-        } else if (ftdi->enumerated == 0) {
-                if (ftdi_elan_enumeratePCI(ftdi) == 0) {
-                        ftdi->enumerated = 1;
-                        work_delay_in_msec = 250;
-                } else
-                        work_delay_in_msec = 1000;
-        } else if (ftdi->initialized == 0) {
-                if (ftdi_elan_setupOHCI(ftdi) == 0) {
-                        ftdi->initialized = 1;
-                        work_delay_in_msec = 500;
-                } else {
-                        dev_err(&ftdi->udev->dev, "initialized failed - trying "
-                                "again in 10 seconds\n");
-                        work_delay_in_msec = 1 *1000;
-                }
-        } else if (ftdi->registered == 0) {
-                work_delay_in_msec = 10;
-                if (ftdi_elan_hcd_init(ftdi) == 0) {
-                        ftdi->registered = 1;
-                } else
-                        dev_err(&ftdi->udev->dev, "register failed\n");
-                work_delay_in_msec = 250;
-        } else {
-                if (ftdi_elan_checkingPCI(ftdi) == 0) {
-                        work_delay_in_msec = 250;
-                } else if (ftdi->controlreg & 0x00400000) {
-                        if (ftdi->gone_away > 0) {
-                                dev_err(&ftdi->udev->dev, "PCI device eject con"
-                                        "firmed platform_dev.dev.parent=%p plat"
-                                        "form_dev.dev=%p\n",
-                                        ftdi->platform_dev.dev.parent,
-                                        &ftdi->platform_dev.dev);
-                                platform_device_unregister(&ftdi->platform_dev);
-                                ftdi->platform_dev.dev.parent = NULL;
-                                ftdi->registered = 0;
-                                ftdi->enumerated = 0;
-                                ftdi->card_ejected = 0;
-                                ftdi->initialized = 0;
-                                ftdi->gone_away = 0;
-                        } else
-                                ftdi_elan_flush_targets(ftdi);
-                        work_delay_in_msec = 250;
-                } else {
-                        dev_err(&ftdi->udev->dev, "PCI device has disappeared\n"
-                                );
-                        ftdi_elan_cancel_targets(ftdi);
-                        work_delay_in_msec = 500;
-                        ftdi->enumerated = 0;
-                        ftdi->initialized = 0;
-                }
-        }
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                ftdi_status_requeue_work(ftdi,
-                        msecs_to_jiffies(work_delay_in_msec));
-                return;
-        }
+        int work_delay_in_msec = 0;
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else if (ftdi->synchronized == 0) {
+                down(&ftdi->sw_lock);
+                if (ftdi_elan_synchronize(ftdi) == 0) {
+                        ftdi->synchronized = 1;
+                        ftdi_command_queue_work(ftdi, 1);
+                        ftdi_respond_queue_work(ftdi, 1);
+                        up(&ftdi->sw_lock);
+                        work_delay_in_msec = 100;
+                } else {
+                        dev_err(&ftdi->udev->dev, "synchronize failed\n");
+                        up(&ftdi->sw_lock);
+                        work_delay_in_msec = 10 *1000;
+                }
+        } else if (ftdi->stuck_status > 0) {
+                if (ftdi_elan_stuck_waiting(ftdi) == 0) {
+                        ftdi->stuck_status = 0;
+                        ftdi->synchronized = 0;
+                } else if ((ftdi->stuck_status++ % 60) == 1) {
+                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted - please remove\n");
+                } else
+                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted - checked %d times\n",
+                                ftdi->stuck_status);
+                work_delay_in_msec = 100;
+        } else if (ftdi->enumerated == 0) {
+                if (ftdi_elan_enumeratePCI(ftdi) == 0) {
+                        ftdi->enumerated = 1;
+                        work_delay_in_msec = 250;
+                } else
+                        work_delay_in_msec = 1000;
+        } else if (ftdi->initialized == 0) {
+                if (ftdi_elan_setupOHCI(ftdi) == 0) {
+                        ftdi->initialized = 1;
+                        work_delay_in_msec = 500;
+                } else {
+                        dev_err(&ftdi->udev->dev, "initialized failed - trying again in 10 seconds\n");
+                        work_delay_in_msec = 1 *1000;
+                }
+        } else if (ftdi->registered == 0) {
+                work_delay_in_msec = 10;
+                if (ftdi_elan_hcd_init(ftdi) == 0) {
+                        ftdi->registered = 1;
+                } else
+                        dev_err(&ftdi->udev->dev, "register failed\n");
+                work_delay_in_msec = 250;
+        } else {
+                if (ftdi_elan_checkingPCI(ftdi) == 0) {
+                        work_delay_in_msec = 250;
+                } else if (ftdi->controlreg & 0x00400000) {
+                        if (ftdi->gone_away > 0) {
+                                dev_err(&ftdi->udev->dev, "PCI device eject confirmed platform_dev.dev.parent=%p platform_dev.dev=%p\n",
+                                        ftdi->platform_dev.dev.parent,
+                                        &ftdi->platform_dev.dev);
+                                platform_device_unregister(&ftdi->platform_dev);
+                                ftdi->platform_dev.dev.parent = NULL;
+                                ftdi->registered = 0;
+                                ftdi->enumerated = 0;
+                                ftdi->card_ejected = 0;
+                                ftdi->initialized = 0;
+                                ftdi->gone_away = 0;
+                        } else
+                                ftdi_elan_flush_targets(ftdi);
+                        work_delay_in_msec = 250;
+                } else {
+                        dev_err(&ftdi->udev->dev, "PCI device has disappeared\n");
+                        ftdi_elan_cancel_targets(ftdi);
+                        work_delay_in_msec = 500;
+                        ftdi->enumerated = 0;
+                        ftdi->initialized = 0;
+                }
+        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                ftdi_status_requeue_work(ftdi,
+                                         msecs_to_jiffies(work_delay_in_msec));
+                return;
+        }
 }
 
 
 /*
-* file_operations for the jtag interface
-*
-* the usage count for the device is incremented on open()
-* and decremented on release()
-*/
+ * file_operations for the jtag interface
+ *
+ * the usage count for the device is incremented on open()
+ * and decremented on release()
+ */
 static int ftdi_elan_open(struct inode *inode, struct file *file)
 {
         int subminor;
         struct usb_interface *interface;
 
-        subminor = iminor(inode);
-        interface = usb_find_interface(&ftdi_elan_driver, subminor);
-
-        if (!interface) {
-                printk(KERN_ERR "can't find device for minor %d\n", subminor);
-                return -ENODEV;
-        } else {
-                struct usb_ftdi *ftdi = usb_get_intfdata(interface);
-                if (!ftdi) {
-                        return -ENODEV;
-                } else {
-                        if (down_interruptible(&ftdi->sw_lock)) {
-                                return -EINTR;
-                        } else {
-                                ftdi_elan_get_kref(ftdi);
-                                file->private_data = ftdi;
-                                return 0;
-                        }
-                }
-        }
+        subminor = iminor(inode);
+        interface = usb_find_interface(&ftdi_elan_driver, subminor);
+
+        if (!interface) {
+                pr_err("can't find device for minor %d\n", subminor);
+                return -ENODEV;
+        } else {
+                struct usb_ftdi *ftdi = usb_get_intfdata(interface);
+                if (!ftdi) {
+                        return -ENODEV;
+                } else {
+                        if (down_interruptible(&ftdi->sw_lock)) {
+                                return -EINTR;
+                        } else {
+                                ftdi_elan_get_kref(ftdi);
+                                file->private_data = ftdi;
+                                return 0;
+                        }
+                }
+        }
 }
 
 static int ftdi_elan_release(struct inode *inode, struct file *file)
 {
-        struct usb_ftdi *ftdi = file->private_data;
-        if (ftdi == NULL)
-                return -ENODEV;
-        up(&ftdi->sw_lock);        /* decrement the count on our device */
-        ftdi_elan_put_kref(ftdi);
-        return 0;
+        struct usb_ftdi *ftdi = file->private_data;
+        if (ftdi == NULL)
+                return -ENODEV;
+        up(&ftdi->sw_lock);        /* decrement the count on our device */
+        ftdi_elan_put_kref(ftdi);
+        return 0;
 }
 
 
 /*
-*
-* blocking bulk reads are used to get data from the device
-*
-*/
+ *
+ * blocking bulk reads are used to get data from the device
+ *
+ */
 static ssize_t ftdi_elan_read(struct file *file, char __user *buffer,
                               size_t count, loff_t *ppos)
 {
-        char data[30 *3 + 4];
-        char *d = data;
-        int m = (sizeof(data) - 1) / 3;
-        int bytes_read = 0;
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        struct usb_ftdi *ftdi = file->private_data;
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        }
-        data[0] = 0;
-      have:if (ftdi->bulk_in_left > 0) {
-                if (count-- > 0) {
-                        char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
-                        ftdi->bulk_in_left -= 1;
-                        if (bytes_read < m) {
-                                d += sprintf(d, " %02X", 0x000000FF & *p);
-                        } else if (bytes_read > m) {
-                        } else
-                                d += sprintf(d, " ..");
-                        if (copy_to_user(buffer++, p, 1)) {
-                                return -EFAULT;
-                        } else {
-                                bytes_read += 1;
-                                goto have;
-                        }
-                } else
-                        return bytes_read;
-        }
-      more:if (count > 0) {
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 50);
-                if (packet_bytes > 2) {
-                        ftdi->bulk_in_left = packet_bytes - 2;
-                        ftdi->bulk_in_last = 1;
-                        goto have;
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else if (bytes_read > 0) {
-                                return bytes_read;
-                        } else
-                                return retval;
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return bytes_read;
-                } else
-                        return retval;
-        } else
-                return bytes_read;
+        char data[30 *3 + 4];
+        char *d = data;
+        int m = (sizeof(data) - 1) / 3;
+        int bytes_read = 0;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        struct usb_ftdi *ftdi = file->private_data;
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        }
+        data[0] = 0;
+have:if (ftdi->bulk_in_left > 0) {
+                if (count-- > 0) {
+                        char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
+                        ftdi->bulk_in_left -= 1;
+                        if (bytes_read < m) {
+                                d += sprintf(d, " %02X", 0x000000FF & *p);
+                        } else if (bytes_read > m) {
+                        } else
+                                d += sprintf(d, " ..");
+                        if (copy_to_user(buffer++, p, 1)) {
+                                return -EFAULT;
+                        } else {
+                                bytes_read += 1;
+                                goto have;
+                        }
+                } else
+                        return bytes_read;
+        }
+more:if (count > 0) {
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 50);
+                if (packet_bytes > 2) {
+                        ftdi->bulk_in_left = packet_bytes - 2;
+                        ftdi->bulk_in_last = 1;
+                        goto have;
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else if (bytes_read > 0) {
+                                return bytes_read;
+                        } else
+                                return retval;
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return bytes_read;
+                } else
+                        return retval;
+        } else
+                return bytes_read;
 }
 
 static void ftdi_elan_write_bulk_callback(struct urb *urb)
@@ -728,467 +726,460 @@ static void ftdi_elan_write_bulk_callback(struct urb *urb)
         int status = urb->status;
 
         if (status && !(status == -ENOENT || status == -ECONNRESET ||
-            status == -ESHUTDOWN)) {
-                dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %"
-                        "d\n", urb, status);
-        }
-        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
-                urb->transfer_buffer, urb->transfer_dma);
+                        status == -ESHUTDOWN)) {
+                dev_err(&ftdi->udev->dev,
+                        "urb=%p write bulk status received: %d\n", urb, status);
+        }
+        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
+                          urb->transfer_buffer, urb->transfer_dma);
 }
 
 static int fill_buffer_with_all_queued_commands(struct usb_ftdi *ftdi,
-        char *buf, int command_size, int total_size)
-{
-        int ed_commands = 0;
-        int b = 0;
-        int I = command_size;
-        int i = ftdi->command_head;
-        while (I-- > 0) {
-                struct u132_command *command = &ftdi->command[COMMAND_MASK &
-                        i++];
-                int F = command->follows;
-                u8 *f = command->buffer;
-                if (command->header & 0x80) {
-                        ed_commands |= 1 << (0x3 & (command->header >> 5));
-                }
-                buf[b++] = command->header;
-                buf[b++] = (command->length >> 0) & 0x00FF;
-                buf[b++] = (command->length >> 8) & 0x00FF;
-                buf[b++] = command->address;
-                buf[b++] = command->width;
-                while (F-- > 0) {
-                        buf[b++] = *f++;
-                }
-        }
-        return ed_commands;
+                                                char *buf, int command_size, int total_size)
+{
+        int ed_commands = 0;
+        int b = 0;
+        int I = command_size;
+        int i = ftdi->command_head;
+        while (I-- > 0) {
+                struct u132_command *command = &ftdi->command[COMMAND_MASK &
+                                                              i++];
+                int F = command->follows;
+                u8 *f = command->buffer;
+                if (command->header & 0x80) {
+                        ed_commands |= 1 << (0x3 & (command->header >> 5));
+                }
+                buf[b++] = command->header;
+                buf[b++] = (command->length >> 0) & 0x00FF;
+                buf[b++] = (command->length >> 8) & 0x00FF;
+                buf[b++] = command->address;
+                buf[b++] = command->width;
+                while (F-- > 0) {
+                        buf[b++] = *f++;
+                }
+        }
+        return ed_commands;
 }
 
 static int ftdi_elan_total_command_size(struct usb_ftdi *ftdi, int command_size)
 {
-        int total_size = 0;
-        int I = command_size;
-        int i = ftdi->command_head;
-        while (I-- > 0) {
-                struct u132_command *command = &ftdi->command[COMMAND_MASK &
-                        i++];
-                total_size += 5 + command->follows;
-        } return total_size;
+        int total_size = 0;
+        int I = command_size;
+        int i = ftdi->command_head;
+        while (I-- > 0) {
+                struct u132_command *command = &ftdi->command[COMMAND_MASK &
+                                                              i++];
+                total_size += 5 + command->follows;
+        } return total_size;
 }
 
 static int ftdi_elan_command_engine(struct usb_ftdi *ftdi)
 {
-        int retval;
-        char *buf;
-        int ed_commands;
-        int total_size;
-        struct urb *urb;
-        int command_size = ftdi->command_next - ftdi->command_head;
-        if (command_size == 0)
-                return 0;
-        total_size = ftdi_elan_total_command_size(ftdi, command_size);
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not get a urb to write %d comm"
-                        "ands totaling %d bytes to the Uxxx\n", command_size,
-                        total_size);
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
-                &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer to write %d c"
-                        "ommands totaling %d bytes to the Uxxx\n", command_size,
-                         total_size);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
-                command_size, total_size);
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, total_size,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        if (ed_commands) {
-                char diag[40 *3 + 4];
-                char *d = diag;
-                int m = total_size;
-                u8 *c = buf;
-                int s = (sizeof(diag) - 1) / 3;
-                diag[0] = 0;
-                while (s-- > 0 && m-- > 0) {
-                        if (s > 0 || m == 0) {
-                                d += sprintf(d, " %02X", *c++);
-                        } else
-                                d += sprintf(d, " ..");
-                }
-        }
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write "
-                        "%d commands totaling %d bytes to the Uxxx\n", retval,
-                        urb, command_size, total_size);
-                usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return retval;
-        }
-        usb_free_urb(urb);        /* release our reference to this urb,
-                the USB core will eventually free it entirely */
-        ftdi->command_head += command_size;
-        ftdi_elan_kick_respond_queue(ftdi);
-        return 0;
+        int retval;
+        char *buf;
+        int ed_commands;
+        int total_size;
+        struct urb *urb;
+        int command_size = ftdi->command_next - ftdi->command_head;
+        if (command_size == 0)
+                return 0;
+        total_size = ftdi_elan_total_command_size(ftdi, command_size);
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not get a urb to write %d commands totaling %d bytes to the Uxxx\n",
+                        command_size, total_size);
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
+                                 &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer to write %d commands totaling %d bytes to the Uxxx\n",
+                        command_size, total_size);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
+                                                           command_size, total_size);
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, total_size,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        if (ed_commands) {
+                char diag[40 *3 + 4];
+                char *d = diag;
+                int m = total_size;
+                u8 *c = buf;
+                int s = (sizeof(diag) - 1) / 3;
+                diag[0] = 0;
+                while (s-- > 0 && m-- > 0) {
+                        if (s > 0 || m == 0) {
+                                d += sprintf(d, " %02X", *c++);
+                        } else
+                                d += sprintf(d, " ..");
+                }
+        }
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write %d commands totaling %d bytes to the Uxxx\n",
+                        retval, urb, command_size, total_size);
+                usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return retval;
+        }
+        usb_free_urb(urb);        /* release our reference to this urb,
+                                     the USB core will eventually free it entirely */
+        ftdi->command_head += command_size;
+        ftdi_elan_kick_respond_queue(ftdi);
+        return 0;
 }
 
 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
-        struct u132_target *target, u8 *buffer, int length)
-{
-        struct urb *urb = target->urb;
-        int halted = target->halted;
-        int skipped = target->skipped;
-        int actual = target->actual;
-        int non_null = target->non_null;
-        int toggle_bits = target->toggle_bits;
-        int error_count = target->error_count;
-        int condition_code = target->condition_code;
-        int repeat_number = target->repeat_number;
-        void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int,
-                int, int, int, int) = target->callback;
-        target->active -= 1;
-        target->callback = NULL;
-        (*callback) (target->endp, urb, buffer, length, toggle_bits,
-                error_count, condition_code, repeat_number, halted, skipped,
-                actual, non_null);
+                                  struct u132_target *target, u8 *buffer, int length)
+{
+        struct urb *urb = target->urb;
+        int halted = target->halted;
+        int skipped = target->skipped;
+        int actual = target->actual;
+        int non_null = target->non_null;
+        int toggle_bits = target->toggle_bits;
+        int error_count = target->error_count;
+        int condition_code = target->condition_code;
+        int repeat_number = target->repeat_number;
+        void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int,
+                          int, int, int, int) = target->callback;
+        target->active -= 1;
+        target->callback = NULL;
+        (*callback) (target->endp, urb, buffer, length, toggle_bits,
+                     error_count, condition_code, repeat_number, halted, skipped,
+                     actual, non_null);
 }
 
 static char *have_ed_set_response(struct usb_ftdi *ftdi,
-        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
-        char *b)
-{
-        int payload = (ed_length >> 0) & 0x07FF;
-        mutex_lock(&ftdi->u132_lock);
-        target->actual = 0;
-        target->non_null = (ed_length >> 15) & 0x0001;
-        target->repeat_number = (ed_length >> 11) & 0x000F;
-        if (ed_type == 0x02) {
-                if (payload == 0 || target->abandoning > 0) {
-                        target->abandoning = 0;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        return ftdi->response;
-                } else {
-                        ftdi->expected = 4 + payload;
-                        ftdi->ed_found = 1;
-                        mutex_unlock(&ftdi->u132_lock);
-                        return b;
-                }
-        } else if (ed_type == 0x03) {
-                if (payload == 0 || target->abandoning > 0) {
-                        target->abandoning = 0;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        return ftdi->response;
-                } else {
-                        ftdi->expected = 4 + payload;
-                        ftdi->ed_found = 1;
-                        mutex_unlock(&ftdi->u132_lock);
-                        return b;
-                }
-        } else if (ed_type == 0x01) {
-                target->abandoning = 0;
-                mutex_unlock(&ftdi->u132_lock);
-                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                        payload);
-                ftdi->received = 0;
-                ftdi->expected = 4;
-                ftdi->ed_found = 0;
-                return ftdi->response;
-        } else {
-                target->abandoning = 0;
-                mutex_unlock(&ftdi->u132_lock);
-                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                        payload);
-                ftdi->received = 0;
-                ftdi->expected = 4;
-                ftdi->ed_found = 0;
-                return ftdi->response;
-        }
+                                  struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
+                                  char *b)
+{
+        int payload = (ed_length >> 0) & 0x07FF;
+        mutex_lock(&ftdi->u132_lock);
+        target->actual = 0;
+        target->non_null = (ed_length >> 15) & 0x0001;
+        target->repeat_number = (ed_length >> 11) & 0x000F;
+        if (ed_type == 0x02) {
+                if (payload == 0 || target->abandoning > 0) {
+                        target->abandoning = 0;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        return ftdi->response;
+                } else {
+                        ftdi->expected = 4 + payload;
+                        ftdi->ed_found = 1;
+                        mutex_unlock(&ftdi->u132_lock);
+                        return b;
+                }
+        } else if (ed_type == 0x03) {
+                if (payload == 0 || target->abandoning > 0) {
+                        target->abandoning = 0;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        return ftdi->response;
+                } else {
+                        ftdi->expected = 4 + payload;
+                        ftdi->ed_found = 1;
+                        mutex_unlock(&ftdi->u132_lock);
+                        return b;
+                }
+        } else if (ed_type == 0x01) {
+                target->abandoning = 0;
+                mutex_unlock(&ftdi->u132_lock);
+                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                      payload);
+                ftdi->received = 0;
+                ftdi->expected = 4;
+                ftdi->ed_found = 0;
+                return ftdi->response;
+        } else {
+                target->abandoning = 0;
+                mutex_unlock(&ftdi->u132_lock);
+                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                      payload);
+                ftdi->received = 0;
+                ftdi->expected = 4;
+                ftdi->ed_found = 0;
+                return ftdi->response;
+        }
 }
 
 static char *have_ed_get_response(struct usb_ftdi *ftdi,
-        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
-        char *b)
+                                  struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
+                                  char *b)
 {
-        mutex_lock(&ftdi->u132_lock);
-        target->condition_code = TD_DEVNOTRESP;
-        target->actual = (ed_length >> 0) & 0x01FF;
-        target->non_null = (ed_length >> 15) & 0x0001;
-        target->repeat_number = (ed_length >> 11) & 0x000F;
-        mutex_unlock(&ftdi->u132_lock);
-        if (target->active)
-                ftdi_elan_do_callback(ftdi, target, NULL, 0);
-        target->abandoning = 0;
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        return ftdi->response;
+        mutex_lock(&ftdi->u132_lock);
+        target->condition_code = TD_DEVNOTRESP;
+        target->actual = (ed_length >> 0) & 0x01FF;
+        target->non_null = (ed_length >> 15) & 0x0001;
+        target->repeat_number = (ed_length >> 11) & 0x000F;
+        mutex_unlock(&ftdi->u132_lock);
+        if (target->active)
+                ftdi_elan_do_callback(ftdi, target, NULL, 0);
+        target->abandoning = 0;
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        return ftdi->response;
 }
 
 
 /*
-* The engine tries to empty the FTDI fifo
-*
-* all responses found in the fifo data are dispatched thus
-* the response buffer can only ever hold a maximum sized
-* response from the Uxxx.
-*
-*/
+ * The engine tries to empty the FTDI fifo
+ *
+ * all responses found in the fifo data are dispatched thus
+ * the response buffer can only ever hold a maximum sized
+ * response from the Uxxx.
+ *
+ */
 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi)
 {
-        u8 *b = ftdi->response + ftdi->received;
-        int bytes_read = 0;
-        int retry_on_empty = 1;
-        int retry_on_timeout = 3;
-        int empty_packets = 0;
-      read:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 500);
-                char diag[30 *3 + 4];
-                char *d = diag;
-                int m = packet_bytes;
-                u8 *c = ftdi->bulk_in_buffer;
-                int s = (sizeof(diag) - 1) / 3;
-                diag[0] = 0;
-                while (s-- > 0 && m-- > 0) {
-                        if (s > 0 || m == 0) {
-                                d += sprintf(d, " %02X", *c++);
-                        } else
-                                d += sprintf(d, " ..");
-                }
-                if (packet_bytes > 2) {
-                        ftdi->bulk_in_left = packet_bytes - 2;
-                        ftdi->bulk_in_last = 1;
-                        goto have;
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
-                                        "t_bytes = %d with total %d bytes%s\n",
-                                        packet_bytes, bytes_read, diag);
-                                goto more;
-                        } else if (bytes_read > 0) {
-                                dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
-                                        bytes_read, diag);
-                                return -ENOMEM;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
-                                        "t_bytes = %d with total %d bytes%s\n",
-                                        packet_bytes, bytes_read, diag);
-                                return -ENOMEM;
-                        }
-                } else if (retval == -EILSEQ) {
-                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
-                                " = %d with total %d bytes%s\n", retval,
-                                packet_bytes, bytes_read, diag);
-                        return retval;
-                } else if (retval) {
-                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
-                                " = %d with total %d bytes%s\n", retval,
-                                packet_bytes, bytes_read, diag);
-                        return retval;
-                } else if (packet_bytes == 2) {
-                        unsigned char s0 = ftdi->bulk_in_buffer[0];
-                        unsigned char s1 = ftdi->bulk_in_buffer[1];
-                        empty_packets += 1;
-                        if (s0 == 0x31 && s1 == 0x60) {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        } else if (s0 == 0x31 && s1 == 0x00) {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        } else {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        }
-                } else if (packet_bytes == 1) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return 0;
-                } else {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return 0;
-                }
-        }
-      more:{
-                goto read;
-        }
-      have:if (ftdi->bulk_in_left > 0) {
-                u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
-                bytes_read += 1;
-                ftdi->bulk_in_left -= 1;
-                if (ftdi->received == 0 && c == 0xFF) {
-                        goto have;
-                } else
-                        *b++ = c;
-                if (++ftdi->received < ftdi->expected) {
-                        goto have;
-                } else if (ftdi->ed_found) {
-                        int ed_number = (ftdi->response[0] >> 5) & 0x03;
-                        u16 ed_length = (ftdi->response[2] << 8) |
-                                ftdi->response[1];
-                        struct u132_target *target = &ftdi->target[ed_number];
-                        int payload = (ed_length >> 0) & 0x07FF;
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = payload;
-                        u8 *c = 4 + ftdi->response;
-                        int s = (sizeof(diag) - 1) / 3;
-                        diag[0] = 0;
-                        while (s-- > 0 && m-- > 0) {
-                                if (s > 0 || m == 0) {
-                                        d += sprintf(d, " %02X", *c++);
-                                } else
-                                        d += sprintf(d, " ..");
-                        }
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        b = ftdi->response;
-                        goto have;
-                } else if (ftdi->expected == 8) {
-                        u8 buscmd;
-                        int respond_head = ftdi->respond_head++;
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & respond_head];
-                        u32 data = ftdi->response[7];
-                        data <<= 8;
-                        data |= ftdi->response[6];
-                        data <<= 8;
-                        data |= ftdi->response[5];
-                        data <<= 8;
-                        data |= ftdi->response[4];
-                        *respond->value = data;
-                        *respond->result = 0;
-                        complete(&respond->wait_completion);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        b = ftdi->response;
-                        buscmd = (ftdi->response[0] >> 0) & 0x0F;
-                        if (buscmd == 0x00) {
-                        } else if (buscmd == 0x02) {
-                        } else if (buscmd == 0x06) {
-                        } else if (buscmd == 0x0A) {
-                        } else
-                                dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) va"
-                                        "lue = %08X\n", buscmd, data);
-                        goto have;
-                } else {
-                        if ((ftdi->response[0] & 0x80) == 0x00) {
-                                ftdi->expected = 8;
-                                goto have;
-                        } else {
-                                int ed_number = (ftdi->response[0] >> 5) & 0x03;
-                                int ed_type = (ftdi->response[0] >> 0) & 0x03;
-                                u16 ed_length = (ftdi->response[2] << 8) |
-                                        ftdi->response[1];
-                                struct u132_target *target = &ftdi->target[
-                                        ed_number];
-                                target->halted = (ftdi->response[0] >> 3) &
-                                        0x01;
-                                target->skipped = (ftdi->response[0] >> 2) &
-                                        0x01;
-                                target->toggle_bits = (ftdi->response[3] >> 6)
-                                        & 0x03;
-                                target->error_count = (ftdi->response[3] >> 4)
-                                        & 0x03;
-                                target->condition_code = (ftdi->response[
-                                        3] >> 0) & 0x0F;
-                                if ((ftdi->response[0] & 0x10) == 0x00) {
-                                        b = have_ed_set_response(ftdi, target,
-                                                ed_length, ed_number, ed_type,
-                                                b);
-                                        goto have;
-                                } else {
-                                        b = have_ed_get_response(ftdi, target,
-                                                ed_length, ed_number, ed_type,
-                                                b);
-                                        goto have;
-                                }
-                        }
-                }
-        } else
-                goto more;
+        u8 *b = ftdi->response + ftdi->received;
+        int bytes_read = 0;
+        int retry_on_empty = 1;
+        int retry_on_timeout = 3;
+        int empty_packets = 0;
+read:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 500);
+                char diag[30 *3 + 4];
+                char *d = diag;
+                int m = packet_bytes;
+                u8 *c = ftdi->bulk_in_buffer;
+                int s = (sizeof(diag) - 1) / 3;
+                diag[0] = 0;
+                while (s-- > 0 && m-- > 0) {
+                        if (s > 0 || m == 0) {
+                                d += sprintf(d, " %02X", *c++);
+                        } else
+                                d += sprintf(d, " ..");
+                }
+                if (packet_bytes > 2) {
+                        ftdi->bulk_in_left = packet_bytes - 2;
+                        ftdi->bulk_in_last = 1;
+                        goto have;
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
+                                        packet_bytes, bytes_read, diag);
+                                goto more;
+                        } else if (bytes_read > 0) {
+                                dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
+                                        bytes_read, diag);
+                                return -ENOMEM;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
+                                        packet_bytes, bytes_read, diag);
+                                return -ENOMEM;
+                        }
+                } else if (retval == -EILSEQ) {
+                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
+                                retval, packet_bytes, bytes_read, diag);
+                        return retval;
+                } else if (retval) {
+                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
+                                retval, packet_bytes, bytes_read, diag);
+                        return retval;
+                } else if (packet_bytes == 2) {
+                        unsigned char s0 = ftdi->bulk_in_buffer[0];
+                        unsigned char s1 = ftdi->bulk_in_buffer[1];
+                        empty_packets += 1;
+                        if (s0 == 0x31 && s1 == 0x60) {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        } else if (s0 == 0x31 && s1 == 0x00) {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        } else {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        }
+                } else if (packet_bytes == 1) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return 0;
+                } else {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return 0;
+                }
+        }
+more:{
+                goto read;
+        }
+have:if (ftdi->bulk_in_left > 0) {
+                u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
+                bytes_read += 1;
+                ftdi->bulk_in_left -= 1;
+                if (ftdi->received == 0 && c == 0xFF) {
+                        goto have;
+                } else
+                        *b++ = c;
+                if (++ftdi->received < ftdi->expected) {
+                        goto have;
+                } else if (ftdi->ed_found) {
+                        int ed_number = (ftdi->response[0] >> 5) & 0x03;
+                        u16 ed_length = (ftdi->response[2] << 8) |
+                                ftdi->response[1];
+                        struct u132_target *target = &ftdi->target[ed_number];
+                        int payload = (ed_length >> 0) & 0x07FF;
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = payload;
+                        u8 *c = 4 + ftdi->response;
+                        int s = (sizeof(diag) - 1) / 3;
+                        diag[0] = 0;
+                        while (s-- > 0 && m-- > 0) {
+                                if (s > 0 || m == 0) {
+                                        d += sprintf(d, " %02X", *c++);
+                                } else
+                                        d += sprintf(d, " ..");
+                        }
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        b = ftdi->response;
+                        goto have;
+                } else if (ftdi->expected == 8) {
+                        u8 buscmd;
+                        int respond_head = ftdi->respond_head++;
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & respond_head];
+                        u32 data = ftdi->response[7];
+                        data <<= 8;
+                        data |= ftdi->response[6];
+                        data <<= 8;
+                        data |= ftdi->response[5];
+                        data <<= 8;
+                        data |= ftdi->response[4];
+                        *respond->value = data;
+                        *respond->result = 0;
+                        complete(&respond->wait_completion);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        b = ftdi->response;
+                        buscmd = (ftdi->response[0] >> 0) & 0x0F;
+                        if (buscmd == 0x00) {
+                        } else if (buscmd == 0x02) {
+                        } else if (buscmd == 0x06) {
+                        } else if (buscmd == 0x0A) {
+                        } else
+                                dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) value = %08X\n",
+                                        buscmd, data);
+                        goto have;
+                } else {
+                        if ((ftdi->response[0] & 0x80) == 0x00) {
+                                ftdi->expected = 8;
+                                goto have;
+                        } else {
+                                int ed_number = (ftdi->response[0] >> 5) & 0x03;
+                                int ed_type = (ftdi->response[0] >> 0) & 0x03;
+                                u16 ed_length = (ftdi->response[2] << 8) |
+                                        ftdi->response[1];
+                                struct u132_target *target = &ftdi->target[
+                                        ed_number];
+                                target->halted = (ftdi->response[0] >> 3) &
+                                        0x01;
+                                target->skipped = (ftdi->response[0] >> 2) &
+                                        0x01;
+                                target->toggle_bits = (ftdi->response[3] >> 6)
+                                        & 0x03;
+                                target->error_count = (ftdi->response[3] >> 4)
+                                        & 0x03;
+                                target->condition_code = (ftdi->response[
+                                                                  3] >> 0) & 0x0F;
+                                if ((ftdi->response[0] & 0x10) == 0x00) {
+                                        b = have_ed_set_response(ftdi, target,
+                                                                 ed_length, ed_number, ed_type,
+                                                                 b);
+                                        goto have;
+                                } else {
+                                        b = have_ed_get_response(ftdi, target,
+                                                                 ed_length, ed_number, ed_type,
+                                                                 b);
+                                        goto have;
+                                }
+                        }
+                }
+        } else
+                goto more;
 }
 
 
 /*
-* create a urb, and a buffer for it, and copy the data to the urb
-*
-*/
+ * create a urb, and a buffer for it, and copy the data to the urb
+ *
+ */
 static ssize_t ftdi_elan_write(struct file *file,
                                const char __user *user_buffer, size_t count,
                                loff_t *ppos)
 {
-        int retval = 0;
-        struct urb *urb;
-        char *buf;
-        struct usb_ftdi *ftdi = file->private_data;
-
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        }
-        if (count == 0) {
-                goto exit;
-        }
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                retval = -ENOMEM;
-                goto error_1;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
-                &urb->transfer_dma);
-        if (!buf) {
-                retval = -ENOMEM;
-                goto error_2;
-        }
-        if (copy_from_user(buf, user_buffer, count)) {
-                retval = -EFAULT;
-                goto error_3;
-        }
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, count,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed submitting write urb, error %"
-                        "d\n", retval);
-                goto error_3;
-        }
-        usb_free_urb(urb);
+        int retval = 0;
+        struct urb *urb;
+        char *buf;
+        struct usb_ftdi *ftdi = file->private_data;
+
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        }
+        if (count == 0) {
+                goto exit;
+        }
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                retval = -ENOMEM;
+                goto error_1;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
+                                 &urb->transfer_dma);
+        if (!buf) {
+                retval = -ENOMEM;
+                goto error_2;
+        }
+        if (copy_from_user(buf, user_buffer, count)) {
+                retval = -EFAULT;
+                goto error_3;
+        }
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, count,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev,
+                        "failed submitting write urb, error %d\n", retval);
+                goto error_3;
+        }
+        usb_free_urb(urb);
 
 exit:
-        return count;
+        return count;
 error_3:
         usb_free_coherent(ftdi->udev, count, buf, urb->transfer_dma);
 error_2:
@@ -1198,29 +1189,29 @@ error_1:
 }
 
 static const struct file_operations ftdi_elan_fops = {
-        .owner = THIS_MODULE,
-        .llseek = no_llseek,
-        .read = ftdi_elan_read,
-        .write = ftdi_elan_write,
-        .open = ftdi_elan_open,
-        .release = ftdi_elan_release,
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .read = ftdi_elan_read,
+        .write = ftdi_elan_write,
+        .open = ftdi_elan_open,
+        .release = ftdi_elan_release,
 };
 
 /*
-* usb class driver info in order to get a minor number from the usb core,
-* and to have the device registered with the driver core
-*/
+ * usb class driver info in order to get a minor number from the usb core,
+ * and to have the device registered with the driver core
+ */
 static struct usb_class_driver ftdi_elan_jtag_class = {
-        .name = "ftdi-%d-jtag",
-        .fops = &ftdi_elan_fops,
-        .minor_base = USB_FTDI_ELAN_MINOR_BASE,
+        .name = "ftdi-%d-jtag",
+        .fops = &ftdi_elan_fops,
+        .minor_base = USB_FTDI_ELAN_MINOR_BASE,
 };
 
 /*
-* the following definitions are for the
-* ELAN FPGA state machgine processor that
-* lies on the other side of the FTDI chip
-*/
+ * the following definitions are for the
+ * ELAN FPGA state machgine processor that
+ * lies on the other side of the FTDI chip
+ */
 #define cPCIu132rd 0x0
 #define cPCIu132wr 0x1
 #define cPCIiord 0x2
@@ -1251,1694 +1242,1663 @@ static struct usb_class_driver ftdi_elan_jtag_class = {
 #define cCCnotaccessed 0xF
 static int ftdi_elan_write_reg(struct usb_ftdi *ftdi, u32 data)
 {
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | cPCIu132wr;
-                        command->length = 0x04;
-                        command->address = 0x00;
-                        command->width = 0x00;
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | cPCIu132wr;
+                        command->length = 0x04;
+                        command->address = 0x00;
+                        command->width = 0x00;
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_write_config(struct usb_ftdi *ftdi, int config_offset,
-        u8 width, u32 data)
-{
-        u8 addressofs = config_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | (cPCIcfgwr & 0x0F);
-                        command->length = 0x04;
-                        command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  u8 width, u32 data)
+{
+        u8 addressofs = config_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | (cPCIcfgwr & 0x0F);
+                        command->length = 0x04;
+                        command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_write_pcimem(struct usb_ftdi *ftdi, int mem_offset,
-        u8 width, u32 data)
-{
-        u8 addressofs = mem_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | (cPCImemwr & 0x0F);
-                        command->length = 0x04;
-                        command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  u8 width, u32 data)
+{
+        u8 addressofs = mem_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | (cPCImemwr & 0x0F);
+                        command->length = 0x04;
+                        command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_write_pcimem(struct platform_device *pdev, int mem_offset,
-        u8 width, u32 data)
+                               u8 width, u32 data)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_write_pcimem);
 static int ftdi_elan_read_reg(struct usb_ftdi *ftdi, u32 *data)
 {
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | cPCIu132rd;
-                        command->length = 0x04;
-                        respond->address = command->address = cU132cmd_status;
-                        command->width = 0x00;
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | cPCIu132rd;
+                        command->length = 0x04;
+                        respond->address = command->address = cU132cmd_status;
+                        command->width = 0x00;
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_read_config(struct usb_ftdi *ftdi, int config_offset,
-        u8 width, u32 *data)
-{
-        u8 addressofs = config_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | (cPCIcfgrd &
-                                0x0F);
-                        command->length = 0x04;
-                        respond->address = command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 u8 width, u32 *data)
+{
+        u8 addressofs = config_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | (cPCIcfgrd &
+                                                                    0x0F);
+                        command->length = 0x04;
+                        respond->address = command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_read_pcimem(struct usb_ftdi *ftdi, int mem_offset,
-        u8 width, u32 *data)
-{
-        u8 addressofs = mem_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | (cPCImemrd &
-                                0x0F);
-                        command->length = 0x04;
-                        respond->address = command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 u8 width, u32 *data)
+{
+        u8 addressofs = mem_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | (cPCImemrd &
+                                                                    0x0F);
+                        command->length = 0x04;
+                        respond->address = command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_read_pcimem(struct platform_device *pdev, int mem_offset,
-        u8 width, u32 *data)
+                              u8 width, u32 *data)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else
-                return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else
+                return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_read_pcimem);
 static int ftdi_elan_edset_setup(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x80 | (ed << 5);
-                        command->length = 0x8007;
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 8;
-                        command->value = 0;
-                        command->buffer = urb->setup_packet;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x80 | (ed << 5);
+                        command->length = 0x8007;
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 8;
+                        command->value = 0;
+                        command->buffer = urb->setup_packet;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_setup(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_setup);
 static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        u32 remaining_length = urb->transfer_buffer_length -
-                                urb->actual_length;
-                        command->header = 0x82 | (ed << 5);
-                        if (remaining_length == 0) {
-                                command->length = 0x0000;
-                        } else if (remaining_length > 1024) {
-                                command->length = 0x8000 | 1023;
-                        } else
-                                command->length = 0x8000 | (remaining_length -
-                                        1);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        u32 remaining_length = urb->transfer_buffer_length -
+                                urb->actual_length;
+                        command->header = 0x82 | (ed << 5);
+                        if (remaining_length == 0) {
+                                command->length = 0x0000;
+                        } else if (remaining_length > 1024) {
+                                command->length = 0x8000 | 1023;
+                        } else
+                                command->length = 0x8000 | (remaining_length -
+                                                            1);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_input(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_input);
 static int ftdi_elan_edset_empty(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x81 | (ed << 5);
-                        command->length = 0x0000;
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x81 | (ed << 5);
+                        command->length = 0x0000;
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_empty(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_empty);
 static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        u8 *b;
-                        u16 urb_size;
-                        int i = 0;
-                        char data[30 *3 + 4];
-                        char *d = data;
-                        int m = (sizeof(data) - 1) / 3;
-                        int l = 0;
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x81 | (ed << 5);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = min_t(u32, 1024,
-                                urb->transfer_buffer_length -
-                                urb->actual_length);
-                        command->value = 0;
-                        command->buffer = urb->transfer_buffer +
-                                urb->actual_length;
-                        command->length = 0x8000 | (command->follows - 1);
-                        b = command->buffer;
-                        urb_size = command->follows;
-                        data[0] = 0;
-                        while (urb_size-- > 0) {
-                                if (i > m) {
-                                } else if (i++ < m) {
-                                        int w = sprintf(d, " %02X", *b++);
-                                        d += w;
-                                        l += w;
-                                } else
-                                        d += sprintf(d, " ..");
-                        }
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                  void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                    int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                    int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        u8 *b;
+                        u16 urb_size;
+                        int i = 0;
+                        char data[30 *3 + 4];
+                        char *d = data;
+                        int m = (sizeof(data) - 1) / 3;
+                        int l = 0;
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x81 | (ed << 5);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = min_t(u32, 1024,
+                                                 urb->transfer_buffer_length -
+                                                 urb->actual_length);
+                        command->value = 0;
+                        command->buffer = urb->transfer_buffer +
+                                urb->actual_length;
+                        command->length = 0x8000 | (command->follows - 1);
+                        b = command->buffer;
+                        urb_size = command->follows;
+                        data[0] = 0;
+                        while (urb_size-- > 0) {
+                                if (i > m) {
+                                } else if (i++ < m) {
+                                        int w = sprintf(d, " %02X", *b++);
+                                        d += w;
+                                        l += w;
+                                } else
+                                        d += sprintf(d, " ..");
+                        }
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_output(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                               void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                               void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                 int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                 int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
+                                      ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_output);
 static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        u32 remaining_length = urb->transfer_buffer_length -
-                                urb->actual_length;
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x83 | (ed << 5);
-                        if (remaining_length == 0) {
-                                command->length = 0x0000;
-                        } else if (remaining_length > 1024) {
-                                command->length = 0x8000 | 1023;
-                        } else
-                                command->length = 0x8000 | (remaining_length -
-                                        1);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                  void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                    int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                    int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        u32 remaining_length = urb->transfer_buffer_length -
+                                urb->actual_length;
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x83 | (ed << 5);
+                        if (remaining_length == 0) {
+                                command->length = 0x0000;
+                        } else if (remaining_length > 1024) {
+                                command->length = 0x8000 | 1023;
+                        } else
+                                command->length = 0x8000 | (remaining_length -
+                                                            1);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_single(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                               void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                               void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                 int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                 int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
+                                      ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_single);
 static int ftdi_elan_edset_flush(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp)
-{
-        u8 ed = ed_number - 1;
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                struct u132_target *target = &ftdi->target[ed];
-                mutex_lock(&ftdi->u132_lock);
-                if (target->abandoning > 0) {
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        target->abandoning = 1;
-                      wait_1:if (target->active == 1) {
-                                int command_size = ftdi->command_next -
-                                        ftdi->command_head;
-                                if (command_size < COMMAND_SIZE) {
-                                        struct u132_command *command =
-                                                &ftdi->command[COMMAND_MASK &
-                                                ftdi->command_next];
-                                        command->header = 0x80 | (ed << 5) |
-                                                0x4;
-                                        command->length = 0x00;
-                                        command->address = 0x00;
-                                        command->width = 0x00;
-                                        command->follows = 0;
-                                        command->value = 0;
-                                        command->buffer = &command->value;
-                                        ftdi->command_next += 1;
-                                        ftdi_elan_kick_command_queue(ftdi);
-                                } else {
-                                        mutex_unlock(&ftdi->u132_lock);
-                                        msleep(100);
-                                        mutex_lock(&ftdi->u132_lock);
-                                        goto wait_1;
-                                }
-                        }
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                }
-        }
+                                 void *endp)
+{
+        u8 ed = ed_number - 1;
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                struct u132_target *target = &ftdi->target[ed];
+                mutex_lock(&ftdi->u132_lock);
+                if (target->abandoning > 0) {
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        target->abandoning = 1;
+                wait_1:if (target->active == 1) {
+                                int command_size = ftdi->command_next -
+                                        ftdi->command_head;
+                                if (command_size < COMMAND_SIZE) {
+                                        struct u132_command *command =
+                                                &ftdi->command[COMMAND_MASK &
+                                                               ftdi->command_next];
+                                        command->header = 0x80 | (ed << 5) |
+                                                0x4;
+                                        command->length = 0x00;
+                                        command->address = 0x00;
+                                        command->width = 0x00;
+                                        command->follows = 0;
+                                        command->value = 0;
+                                        command->buffer = &command->value;
+                                        ftdi->command_next += 1;
+                                        ftdi_elan_kick_command_queue(ftdi);
+                                } else {
+                                        mutex_unlock(&ftdi->u132_lock);
+                                        msleep(100);
+                                        mutex_lock(&ftdi->u132_lock);
+                                        goto wait_1;
+                                }
+                        }
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_flush(struct platform_device *pdev, u8 ed_number,
-        void *endp)
+                              void *endp)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_flush(ftdi, ed_number, endp);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_flush(ftdi, ed_number, endp);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_flush);
 static int ftdi_elan_flush_input_fifo(struct usb_ftdi *ftdi)
 {
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        int retry_on_status = 20;
-      more:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 100);
-                if (packet_bytes > 2) {
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = (sizeof(diag) - 1) / 3;
-                        char *b = ftdi->bulk_in_buffer;
-                        int bytes_read = 0;
-                        diag[0] = 0;
-                        while (packet_bytes-- > 0) {
-                                char c = *b++;
-                                if (bytes_read < m) {
-                                        d += sprintf(d, " %02X",
-                                                0x000000FF & c);
-                                } else if (bytes_read > m) {
-                                } else
-                                        d += sprintf(d, " ..");
-                                bytes_read += 1;
-                                continue;
-                        }
-                        goto more;
-                } else if (packet_bytes > 1) {
-                        char s1 = ftdi->bulk_in_buffer[0];
-                        char s2 = ftdi->bulk_in_buffer[1];
-                        if (s1 == 0x31 && s2 == 0x60) {
-                                return 0;
-                        } else if (retry_on_status-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (packet_bytes > 0) {
-                        char b1 = ftdi->bulk_in_buffer[0];
-                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
-                                "TDI = %02X\n", b1);
-                        if (retry_on_status-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
-                                        "t reached\n");
-                                return -ENOMEM;
-                        }
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "empty packet retry l"
-                                        "imit reached\n");
-                                return -ENOMEM;
-                        }
-                } else {
-                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
-                        return retval;
-                }
-        }
-        return -1;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        int retry_on_status = 20;
+more:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 100);
+                if (packet_bytes > 2) {
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = (sizeof(diag) - 1) / 3;
+                        char *b = ftdi->bulk_in_buffer;
+                        int bytes_read = 0;
+                        diag[0] = 0;
+                        while (packet_bytes-- > 0) {
+                                char c = *b++;
+                                if (bytes_read < m) {
+                                        d += sprintf(d, " %02X",
+                                                     0x000000FF & c);
+                                } else if (bytes_read > m) {
+                                } else
+                                        d += sprintf(d, " ..");
+                                bytes_read += 1;
+                                continue;
+                        }
+                        goto more;
+                } else if (packet_bytes > 1) {
+                        char s1 = ftdi->bulk_in_buffer[0];
+                        char s2 = ftdi->bulk_in_buffer[1];
+                        if (s1 == 0x31 && s2 == 0x60) {
+                                return 0;
+                        } else if (retry_on_status-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (packet_bytes > 0) {
+                        char b1 = ftdi->bulk_in_buffer[0];
+                        dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n",
+                                b1);
+                        if (retry_on_status-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else {
+                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
+                        return retval;
+                }
+        }
+        return -1;
 }
 
 
 /*
-* send the long flush sequence
-*
-*/
+ * send the long flush sequence
+ *
+ */
 static int ftdi_elan_synchronize_flush(struct usb_ftdi *ftdi)
 {
-        int retval;
-        struct urb *urb;
-        char *buf;
-        int I = 257;
-        int i = 0;
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequ"
-                        "ence\n");
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer for flush seq"
-                        "uence\n");
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        while (I-- > 0)
-                buf[i++] = 0x55;
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, i,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
-                        "flush sequence\n");
-                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        usb_free_urb(urb);
-        return 0;
+        int retval;
+        struct urb *urb;
+        char *buf;
+        int I = 257;
+        int i = 0;
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequence\n");
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer for flush sequence\n");
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        while (I-- > 0)
+                buf[i++] = 0x55;
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, i,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed to submit urb containing the flush sequence\n");
+                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        usb_free_urb(urb);
+        return 0;
 }
 
 
 /*
-* send the reset sequence
-*
-*/
+ * send the reset sequence
+ *
+ */
 static int ftdi_elan_synchronize_reset(struct usb_ftdi *ftdi)
 {
-        int retval;
-        struct urb *urb;
-        char *buf;
-        int I = 4;
-        int i = 0;
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not get a urb for the reset se"
-                        "quence\n");
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer for the reset"
-                        " sequence\n");
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        buf[i++] = 0x55;
-        buf[i++] = 0xAA;
-        buf[i++] = 0x5A;
-        buf[i++] = 0xA5;
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, i,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
-                        "reset sequence\n");
-                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        usb_free_urb(urb);
-        return 0;
+        int retval;
+        struct urb *urb;
+        char *buf;
+        int I = 4;
+        int i = 0;
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not get a urb for the reset sequence\n");
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer for the reset sequence\n");
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        buf[i++] = 0x55;
+        buf[i++] = 0xAA;
+        buf[i++] = 0x5A;
+        buf[i++] = 0xA5;
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, i,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed to submit urb containing the reset sequence\n");
+                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        usb_free_urb(urb);
+        return 0;
 }
 
 static int ftdi_elan_synchronize(struct usb_ftdi *ftdi)
 {
-        int retval;
-        int long_stop = 10;
-        int retry_on_timeout = 5;
-        int retry_on_empty = 10;
-        int err_count = 0;
-        retval = ftdi_elan_flush_input_fifo(ftdi);
-        if (retval)
-                return retval;
-        ftdi->bulk_in_left = 0;
-        ftdi->bulk_in_last = -1;
-        while (long_stop-- > 0) {
-                int read_stop;
-                int read_stuck;
-                retval = ftdi_elan_synchronize_flush(ftdi);
-                if (retval)
-                        return retval;
-                retval = ftdi_elan_flush_input_fifo(ftdi);
-                if (retval)
-                        return retval;
-              reset:retval = ftdi_elan_synchronize_reset(ftdi);
-                if (retval)
-                        return retval;
-                read_stop = 100;
-                read_stuck = 10;
-              read:{
-                        int packet_bytes = 0;
-                        retval = usb_bulk_msg(ftdi->udev,
-                                usb_rcvbulkpipe(ftdi->udev,
-                                ftdi->bulk_in_endpointAddr),
-                                ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                                &packet_bytes, 500);
-                        if (packet_bytes > 2) {
-                                char diag[30 *3 + 4];
-                                char *d = diag;
-                                int m = (sizeof(diag) - 1) / 3;
-                                char *b = ftdi->bulk_in_buffer;
-                                int bytes_read = 0;
-                                unsigned char c = 0;
-                                diag[0] = 0;
-                                while (packet_bytes-- > 0) {
-                                        c = *b++;
-                                        if (bytes_read < m) {
-                                                d += sprintf(d, " %02X", c);
-                                        } else if (bytes_read > m) {
-                                        } else
-                                                d += sprintf(d, " ..");
-                                        bytes_read += 1;
-                                        continue;
-                                }
-                                if (c == 0x7E) {
-                                        return 0;
-                                } else {
-                                        if (c == 0x55) {
-                                                goto read;
-                                        } else if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                }
-                        } else if (packet_bytes > 1) {
-                                unsigned char s1 = ftdi->bulk_in_buffer[0];
-                                unsigned char s2 = ftdi->bulk_in_buffer[1];
-                                if (s1 == 0x31 && s2 == 0x00) {
-                                        if (read_stuck-- > 0) {
-                                                goto read;
-                                        } else
-                                                goto reset;
-                                } else if (s1 == 0x31 && s2 == 0x60) {
-                                        if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                } else {
-                                        if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                }
-                        } else if (packet_bytes > 0) {
-                                if (read_stop-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "retry limit "
-                                                "reached\n");
-                                        continue;
-                                }
-                        } else if (retval == -ETIMEDOUT) {
-                                if (retry_on_timeout-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "TIMED OUT re"
-                                                "try limit reached\n");
-                                        continue;
-                                }
-                        } else if (retval == 0) {
-                                if (retry_on_empty-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "empty packet"
-                                                " retry limit reached\n");
-                                        continue;
-                                }
-                        } else {
-                                err_count += 1;
-                                dev_err(&ftdi->udev->dev, "error = %d\n",
-                                        retval);
-                                if (read_stop-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "retry limit "
-                                                "reached\n");
-                                        continue;
-                                }
-                        }
-                }
-        }
-        dev_err(&ftdi->udev->dev, "failed to synchronize\n");
-        return -EFAULT;
+        int retval;
+        int long_stop = 10;
+        int retry_on_timeout = 5;
+        int retry_on_empty = 10;
+        int err_count = 0;
+        retval = ftdi_elan_flush_input_fifo(ftdi);
+        if (retval)
+                return retval;
+        ftdi->bulk_in_left = 0;
+        ftdi->bulk_in_last = -1;
+        while (long_stop-- > 0) {
+                int read_stop;
+                int read_stuck;
+                retval = ftdi_elan_synchronize_flush(ftdi);
+                if (retval)
+                        return retval;
+                retval = ftdi_elan_flush_input_fifo(ftdi);
+                if (retval)
+                        return retval;
+        reset:retval = ftdi_elan_synchronize_reset(ftdi);
+                if (retval)
+                        return retval;
+                read_stop = 100;
+                read_stuck = 10;
+        read:{
+                        int packet_bytes = 0;
+                        retval = usb_bulk_msg(ftdi->udev,
+                                              usb_rcvbulkpipe(ftdi->udev,
+                                                              ftdi->bulk_in_endpointAddr),
+                                              ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                              &packet_bytes, 500);
+                        if (packet_bytes > 2) {
+                                char diag[30 *3 + 4];
+                                char *d = diag;
+                                int m = (sizeof(diag) - 1) / 3;
+                                char *b = ftdi->bulk_in_buffer;
+                                int bytes_read = 0;
+                                unsigned char c = 0;
+                                diag[0] = 0;
+                                while (packet_bytes-- > 0) {
+                                        c = *b++;
+                                        if (bytes_read < m) {
+                                                d += sprintf(d, " %02X", c);
+                                        } else if (bytes_read > m) {
+                                        } else
+                                                d += sprintf(d, " ..");
+                                        bytes_read += 1;
+                                        continue;
+                                }
+                                if (c == 0x7E) {
+                                        return 0;
+                                } else {
+                                        if (c == 0x55) {
+                                                goto read;
+                                        } else if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                }
+                        } else if (packet_bytes > 1) {
+                                unsigned char s1 = ftdi->bulk_in_buffer[0];
+                                unsigned char s2 = ftdi->bulk_in_buffer[1];
+                                if (s1 == 0x31 && s2 == 0x00) {
+                                        if (read_stuck-- > 0) {
+                                                goto read;
+                                        } else
+                                                goto reset;
+                                } else if (s1 == 0x31 && s2 == 0x60) {
+                                        if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                } else {
+                                        if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                }
+                        } else if (packet_bytes > 0) {
+                                if (read_stop-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                        continue;
+                                }
+                        } else if (retval == -ETIMEDOUT) {
+                                if (retry_on_timeout-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                        continue;
+                                }
+                        } else if (retval == 0) {
+                                if (retry_on_empty-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                        continue;
+                                }
+                        } else {
+                                err_count += 1;
+                                dev_err(&ftdi->udev->dev, "error = %d\n",
+                                        retval);
+                                if (read_stop-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                        continue;
+                                }
+                        }
+                }
+        }
+        dev_err(&ftdi->udev->dev, "failed to synchronize\n");
+        return -EFAULT;
 }
 
 static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi)
 {
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        int retry_on_status = 50;
-      more:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 1000);
-                if (packet_bytes > 2) {
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = (sizeof(diag) - 1) / 3;
-                        char *b = ftdi->bulk_in_buffer;
-                        int bytes_read = 0;
-                        diag[0] = 0;
-                        while (packet_bytes-- > 0) {
-                                char c = *b++;
-                                if (bytes_read < m) {
-                                        d += sprintf(d, " %02X",
-                                                0x000000FF & c);
-                                } else if (bytes_read > m) {
-                                } else
-                                        d += sprintf(d, " ..");
-                                bytes_read += 1;
-                                continue;
-                        }
-                        goto more;
-                } else if (packet_bytes > 1) {
-                        char s1 = ftdi->bulk_in_buffer[0];
-                        char s2 = ftdi->bulk_in_buffer[1];
-                        if (s1 == 0x31 && s2 == 0x60) {
-                                return 0;
-                        } else if (retry_on_status-- > 0) {
-                                msleep(5);
-                                goto more;
-                        } else
-                                return -EFAULT;
-                } else if (packet_bytes > 0) {
-                        char b1 = ftdi->bulk_in_buffer[0];
-                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
-                                "TDI = %02X\n", b1);
-                        if (retry_on_status-- > 0) {
-                                msleep(5);
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
-                                        "t reached\n");
-                                return -ENOMEM;
-                        }
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "empty packet retry l"
-                                        "imit reached\n");
-                                return -ENOMEM;
-                        }
-                } else {
-                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
-                        return -ENOMEM;
-                }
-        }
-        return -1;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        int retry_on_status = 50;
+more:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 1000);
+                if (packet_bytes > 2) {
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = (sizeof(diag) - 1) / 3;
+                        char *b = ftdi->bulk_in_buffer;
+                        int bytes_read = 0;
+                        diag[0] = 0;
+                        while (packet_bytes-- > 0) {
+                                char c = *b++;
+                                if (bytes_read < m) {
+                                        d += sprintf(d, " %02X",
+                                                     0x000000FF & c);
+                                } else if (bytes_read > m) {
+                                } else
+                                        d += sprintf(d, " ..");
+                                bytes_read += 1;
+                                continue;
+                        }
+                        goto more;
+                } else if (packet_bytes > 1) {
+                        char s1 = ftdi->bulk_in_buffer[0];
+                        char s2 = ftdi->bulk_in_buffer[1];
+                        if (s1 == 0x31 && s2 == 0x60) {
+                                return 0;
+                        } else if (retry_on_status-- > 0) {
+                                msleep(5);
+                                goto more;
+                        } else
+                                return -EFAULT;
+                } else if (packet_bytes > 0) {
+                        char b1 = ftdi->bulk_in_buffer[0];
+                        dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n", b1);
+                        if (retry_on_status-- > 0) {
+                                msleep(5);
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else {
+                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
+                        return -ENOMEM;
+                }
+        }
+        return -1;
 }
 
 static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi)
 {
-        int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        if (ftdi->controlreg & 0x00400000) {
-                if (ftdi->card_ejected) {
-                } else {
-                        ftdi->card_ejected = 1;
-                        dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = "
-                                "%08X\n", ftdi->controlreg);
-                }
-                return -ENODEV;
-        } else {
-                u8 fn = ftdi->function - 1;
-                int activePCIfn = fn << 8;
-                u32 pcidata;
-                u32 pciVID;
-                u32 pciPID;
-                int reg = 0;
-                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                        &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                pciVID = pcidata & 0xFFFF;
-                pciPID = (pcidata >> 16) & 0xFFFF;
-                if (pciVID == ftdi->platform_data.vendor && pciPID ==
-                        ftdi->platform_data.device) {
-                        return 0;
-                } else {
-                        dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X devi"
-                                "ce=%04X pciPID=%04X\n",
-                                ftdi->platform_data.vendor, pciVID,
-                                ftdi->platform_data.device, pciPID);
-                        return -ENODEV;
-                }
-        }
+        int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        if (ftdi->controlreg & 0x00400000) {
+                if (ftdi->card_ejected) {
+                } else {
+                        ftdi->card_ejected = 1;
+                        dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = %08X\n",
+                                ftdi->controlreg);
+                }
+                return -ENODEV;
+        } else {
+                u8 fn = ftdi->function - 1;
+                int activePCIfn = fn << 8;
+                u32 pcidata;
+                u32 pciVID;
+                u32 pciPID;
+                int reg = 0;
+                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                                   &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                pciVID = pcidata & 0xFFFF;
+                pciPID = (pcidata >> 16) & 0xFFFF;
+                if (pciVID == ftdi->platform_data.vendor && pciPID ==
+                    ftdi->platform_data.device) {
+                        return 0;
+                } else {
+                        dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X device=%04X pciPID=%04X\n",
+                                ftdi->platform_data.vendor, pciVID,
+                                ftdi->platform_data.device, pciPID);
+                        return -ENODEV;
+                }
+        }
 }
 
 
 #define ftdi_read_pcimem(ftdi, member, data) ftdi_elan_read_pcimem(ftdi, \
-        offsetof(struct ohci_regs, member), 0, data);
+                                                                   offsetof(struct ohci_regs, member), 0, data);
 #define ftdi_write_pcimem(ftdi, member, data) ftdi_elan_write_pcimem(ftdi, \
-        offsetof(struct ohci_regs, member), 0, data);
+                                                                     offsetof(struct ohci_regs, member), 0, data);
 
 #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
-#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
-        OHCI_INTR_WDH)
+#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD |   \
+                        OHCI_INTR_WDH)
 static int ftdi_elan_check_controller(struct usb_ftdi *ftdi, int quirk)
 {
-        int devices = 0;
-        int retval;
-        u32 hc_control;
-        int num_ports;
-        u32 control;
-        u32 rh_a = -1;
-        u32 status;
-        u32 fminterval;
-        u32 hc_fminterval;
-        u32 periodicstart;
-        u32 cmdstatus;
-        u32 roothub_a;
-        int mask = OHCI_INTR_INIT;
-        int sleep_time = 0;
-        int reset_timeout = 30;        /* ... allow extra time */
-        int temp;
-        retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
-        if (retval)
-                return retval;
-        num_ports = rh_a & RH_A_NDP;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
-        if (retval)
-                return retval;
-        hc_fminterval &= 0x3fff;
-        if (hc_fminterval != FI) {
-        }
-        hc_fminterval |= FSMP(hc_fminterval) << 16;
-        retval = ftdi_read_pcimem(ftdi, control, &hc_control);
-        if (retval)
-                return retval;
-        switch (hc_control & OHCI_CTRL_HCFS) {
-        case OHCI_USB_OPER:
-                sleep_time = 0;
-                break;
-        case OHCI_USB_SUSPEND:
-        case OHCI_USB_RESUME:
-                hc_control &= OHCI_CTRL_RWC;
-                hc_control |= OHCI_USB_RESUME;
-                sleep_time = 10;
-                break;
-        default:
-                hc_control &= OHCI_CTRL_RWC;
-                hc_control |= OHCI_USB_RESET;
-                sleep_time = 50;
-                break;
-        }
-        retval = ftdi_write_pcimem(ftdi, control, hc_control);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        msleep(sleep_time);
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
-        if (retval)
-                return retval;
-        if (!(roothub_a & RH_A_NPS)) {        /* power down each port */
-                for (temp = 0; temp < num_ports; temp++) {
-                        retval = ftdi_write_pcimem(ftdi,
-                                roothub.portstatus[temp], RH_PS_LSDA);
-                        if (retval)
-                                return retval;
-                }
-        }
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-      retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
-        if (retval)
-                return retval;
-      extra:{
-                retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
-                if (retval)
-                        return retval;
-                if (0 != (status & OHCI_HCR)) {
-                        if (--reset_timeout == 0) {
-                                dev_err(&ftdi->udev->dev, "USB HC reset timed o"
-                                        "ut!\n");
-                                return -ENODEV;
-                        } else {
-                                msleep(5);
-                                goto extra;
-                        }
-                }
-        }
-        if (quirk & OHCI_QUIRK_INITRESET) {
-                retval = ftdi_write_pcimem(ftdi, control, hc_control);
-                if (retval)
-                        return retval;
-                retval = ftdi_read_pcimem(ftdi, control, &control);
-                if (retval)
-                        return retval;
-        }
-        retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, fminterval,
-                ((fminterval & FIT) ^ FIT) | hc_fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, periodicstart,
-                ((9 *hc_fminterval) / 10) & 0x3fff);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
-        if (retval)
-                return retval;
-        if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
-                if (!(quirk & OHCI_QUIRK_INITRESET)) {
-                        quirk |= OHCI_QUIRK_INITRESET;
-                        goto retry;
-                } else
-                        dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
-                                fminterval, periodicstart);
-        }                        /* start controller operations */
-        hc_control &= OHCI_CTRL_RWC;
-        hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
-        retval = ftdi_write_pcimem(ftdi, control, hc_control);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, intrdisable,
-                OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
-                OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
-                OHCI_INTR_SO);
-        if (retval)
-                return retval;        /* handle root hub init quirks ... */
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
-        if (retval)
-                return retval;
-        roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
-        if (quirk & OHCI_QUIRK_SUPERIO) {
-                roothub_a |= RH_A_NOCP;
-                roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
-                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
-                if (retval)
-                        return retval;
-        } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) {
-                roothub_a |= RH_A_NPS;
-                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
-                if (retval)
-                        return retval;
-        }
-        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, roothub.b,
-                (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        mdelay((roothub_a >> 23) & 0x1fe);
-        for (temp = 0; temp < num_ports; temp++) {
-                u32 portstatus;
-                retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
-                        &portstatus);
-                if (retval)
-                        return retval;
-                if (1 & portstatus)
-                        devices += 1;
-        }
-        return devices;
+        int devices = 0;
+        int retval;
+        u32 hc_control;
+        int num_ports;
+        u32 control;
+        u32 rh_a = -1;
+        u32 status;
+        u32 fminterval;
+        u32 hc_fminterval;
+        u32 periodicstart;
+        u32 cmdstatus;
+        u32 roothub_a;
+        int mask = OHCI_INTR_INIT;
+        int sleep_time = 0;
+        int reset_timeout = 30;        /* ... allow extra time */
+        int temp;
+        retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
+        if (retval)
+                return retval;
+        num_ports = rh_a & RH_A_NDP;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
+        if (retval)
+                return retval;
+        hc_fminterval &= 0x3fff;
+        if (hc_fminterval != FI) {
+        }
+        hc_fminterval |= FSMP(hc_fminterval) << 16;
+        retval = ftdi_read_pcimem(ftdi, control, &hc_control);
+        if (retval)
+                return retval;
+        switch (hc_control & OHCI_CTRL_HCFS) {
+        case OHCI_USB_OPER:
+                sleep_time = 0;
+                break;
+        case OHCI_USB_SUSPEND:
+        case OHCI_USB_RESUME:
+                hc_control &= OHCI_CTRL_RWC;
+                hc_control |= OHCI_USB_RESUME;
+                sleep_time = 10;
+                break;
+        default:
+                hc_control &= OHCI_CTRL_RWC;
+                hc_control |= OHCI_USB_RESET;
+                sleep_time = 50;
+                break;
+        }
+        retval = ftdi_write_pcimem(ftdi, control, hc_control);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        msleep(sleep_time);
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
+        if (retval)
+                return retval;
+        if (!(roothub_a & RH_A_NPS)) {        /* power down each port */
+                for (temp = 0; temp < num_ports; temp++) {
+                        retval = ftdi_write_pcimem(ftdi,
+                                                   roothub.portstatus[temp], RH_PS_LSDA);
+                        if (retval)
+                                return retval;
+                }
+        }
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
+        if (retval)
+                return retval;
+extra:{
+                retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
+                if (retval)
+                        return retval;
+                if (0 != (status & OHCI_HCR)) {
+                        if (--reset_timeout == 0) {
+                                dev_err(&ftdi->udev->dev, "USB HC reset timed out!\n");
+                                return -ENODEV;
+                        } else {
+                                msleep(5);
+                                goto extra;
+                        }
+                }
+        }
+        if (quirk & OHCI_QUIRK_INITRESET) {
+                retval = ftdi_write_pcimem(ftdi, control, hc_control);
+                if (retval)
+                        return retval;
+                retval = ftdi_read_pcimem(ftdi, control, &control);
+                if (retval)
+                        return retval;
+        }
+        retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, fminterval,
+                                   ((fminterval & FIT) ^ FIT) | hc_fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, periodicstart,
+                                   ((9 *hc_fminterval) / 10) & 0x3fff);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
+        if (retval)
+                return retval;
+        if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
+                if (!(quirk & OHCI_QUIRK_INITRESET)) {
+                        quirk |= OHCI_QUIRK_INITRESET;
+                        goto retry;
+                } else
+                        dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
+                                fminterval, periodicstart);
+        }                        /* start controller operations */
+        hc_control &= OHCI_CTRL_RWC;
+        hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
+        retval = ftdi_write_pcimem(ftdi, control, hc_control);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, intrdisable,
+                                   OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
+                                   OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
+                                   OHCI_INTR_SO);
+        if (retval)
+                return retval;        /* handle root hub init quirks ... */
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
+        if (retval)
+                return retval;
+        roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
+        if (quirk & OHCI_QUIRK_SUPERIO) {
+                roothub_a |= RH_A_NOCP;
+                roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
+                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
+                if (retval)
+                        return retval;
+        } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) {
+                roothub_a |= RH_A_NPS;
+                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
+                if (retval)
+                        return retval;
+        }
+        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, roothub.b,
+                                   (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        mdelay((roothub_a >> 23) & 0x1fe);
+        for (temp = 0; temp < num_ports; temp++) {
+                u32 portstatus;
+                retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
+                                          &portstatus);
+                if (retval)
+                        return retval;
+                if (1 & portstatus)
+                        devices += 1;
+        }
+        return devices;
 }
 
 static int ftdi_elan_setup_controller(struct usb_ftdi *ftdi, int fn)
 {
-        u32 latence_timer;
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        int activePCIfn = fn << 8;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 16;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xFFFFFFFF);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xF0000000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 12;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        latence_timer &= 0xFFFF00FF;
-        latence_timer |= 0x00001600;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 4;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                0x06);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        for (reg = 0; reg <= 0x54; reg += 4) {
-                UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-        }
-        return 0;
+        u32 latence_timer;
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        int activePCIfn = fn << 8;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 16;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xFFFFFFFF);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xF0000000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 12;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        latence_timer &= 0xFFFF00FF;
+        latence_timer |= 0x00001600;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 4;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            0x06);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        for (reg = 0; reg <= 0x54; reg += 4) {
+                UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+        }
+        return 0;
 }
 
 static int ftdi_elan_close_controller(struct usb_ftdi *ftdi, int fn)
 {
-        u32 latence_timer;
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        int activePCIfn = fn << 8;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 16;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xFFFFFFFF);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0x00000000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 12;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        latence_timer &= 0xFFFF00FF;
-        latence_timer |= 0x00001600;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 4;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                0x00);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        return 0;
+        u32 latence_timer;
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        int activePCIfn = fn << 8;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 16;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xFFFFFFFF);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0x00000000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 12;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        latence_timer &= 0xFFFF00FF;
+        latence_timer |= 0x00001600;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 4;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            0x00);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        return 0;
 }
 
 static int ftdi_elan_found_controller(struct usb_ftdi *ftdi, int fn, int quirk)
 {
-        int result;
-        int UxxxStatus;
-        UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
-        if (UxxxStatus)
-                return UxxxStatus;
-        result = ftdi_elan_check_controller(ftdi, quirk);
-        UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
-        if (UxxxStatus)
-                return UxxxStatus;
-        return result;
+        int result;
+        int UxxxStatus;
+        UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
+        if (UxxxStatus)
+                return UxxxStatus;
+        result = ftdi_elan_check_controller(ftdi, quirk);
+        UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
+        if (UxxxStatus)
+                return UxxxStatus;
+        return result;
 }
 
 static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi)
 {
-        u32 controlreg;
-        u8 sensebits;
-        int UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(750);
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(250);
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(1000);
-        sensebits = (controlreg >> 16) & 0x000F;
-        if (0x0D == sensebits)
-                return 0;
-        else
+        u32 controlreg;
+        u8 sensebits;
+        int UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(750);
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(250);
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(1000);
+        sensebits = (controlreg >> 16) & 0x000F;
+        if (0x0D == sensebits)
+                return 0;
+        else
                 return - ENXIO;
 }
 
 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi)
 {
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        u8 fn;
-        int activePCIfn = 0;
-        int max_devices = 0;
-        int controllers = 0;
-        int unrecognized = 0;
-        ftdi->function = 0;
-        for (fn = 0; (fn < 4); fn++) {
-                u32 pciVID = 0;
-                u32 pciPID = 0;
-                int devices = 0;
-                activePCIfn = fn << 8;
-                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                        &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                pciVID = pcidata & 0xFFFF;
-                pciPID = (pcidata >> 16) & 0xFFFF;
-                if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035))
-                        {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802))
-                        {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) {
-                        devices = ftdi_elan_found_controller(ftdi, fn,
-                                OHCI_QUIRK_AMD756);
-                        controllers += 1;
-                } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) {
-                        devices = ftdi_elan_found_controller(ftdi, fn,
-                                OHCI_QUIRK_ZFMICRO);
-                        controllers += 1;
-                } else if (0 == pcidata) {
-                } else
-                        unrecognized += 1;
-                if (devices > max_devices) {
-                        max_devices = devices;
-                        ftdi->function = fn + 1;
-                        ftdi->platform_data.vendor = pciVID;
-                        ftdi->platform_data.device = pciPID;
-                }
-        }
-        if (ftdi->function > 0) {
-                UxxxStatus = ftdi_elan_setup_controller(ftdi,
-                        ftdi->function - 1);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                return 0;
-        } else if (controllers > 0) {
-                return -ENXIO;
-        } else if (unrecognized > 0) {
-                return -ENXIO;
-        } else {
-                ftdi->enumerated = 0;
-                return -ENXIO;
-        }
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        u8 fn;
+        int activePCIfn = 0;
+        int max_devices = 0;
+        int controllers = 0;
+        int unrecognized = 0;
+        ftdi->function = 0;
+        for (fn = 0; (fn < 4); fn++) {
+                u32 pciVID = 0;
+                u32 pciPID = 0;
+                int devices = 0;
+                activePCIfn = fn << 8;
+                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                                   &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                pciVID = pcidata & 0xFFFF;
+                pciPID = (pcidata >> 16) & 0xFFFF;
+                if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035))
+                {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802))
+                {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) {
+                        devices = ftdi_elan_found_controller(ftdi, fn,
+                                                             OHCI_QUIRK_AMD756);
+                        controllers += 1;
+                } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) {
+                        devices = ftdi_elan_found_controller(ftdi, fn,
+                                                             OHCI_QUIRK_ZFMICRO);
+                        controllers += 1;
+                } else if (0 == pcidata) {
+                } else
+                        unrecognized += 1;
+                if (devices > max_devices) {
+                        max_devices = devices;
+                        ftdi->function = fn + 1;
+                        ftdi->platform_data.vendor = pciVID;
+                        ftdi->platform_data.device = pciPID;
+                }
+        }
+        if (ftdi->function > 0) {
+                UxxxStatus = ftdi_elan_setup_controller(ftdi,
+                                                        ftdi->function - 1);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                return 0;
+        } else if (controllers > 0) {
+                return -ENXIO;
+        } else if (unrecognized > 0) {
+                return -ENXIO;
+        } else {
+                ftdi->enumerated = 0;
+                return -ENXIO;
+        }
 }
 
 
 /*
-* we use only the first bulk-in and bulk-out endpoints
-*/
+ * we use only the first bulk-in and bulk-out endpoints
+ */
 static int ftdi_elan_probe(struct usb_interface *interface,
-        const struct usb_device_id *id)
+                           const struct usb_device_id *id)
 {
-        struct usb_host_interface *iface_desc;
-        struct usb_endpoint_descriptor *endpoint;
-        size_t buffer_size;
-        int i;
-        int retval = -ENOMEM;
-        struct usb_ftdi *ftdi;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint;
+        size_t buffer_size;
+        int i;
+        int retval = -ENOMEM;
+        struct usb_ftdi *ftdi;
 
         ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
-        if (!ftdi) {
-                printk(KERN_ERR "Out of memory\n");
-                return -ENOMEM;
-        }
-
-        mutex_lock(&ftdi_module_lock);
-        list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
-        ftdi->sequence_num = ++ftdi_instances;
-        mutex_unlock(&ftdi_module_lock);
-        ftdi_elan_init_kref(ftdi);
+        if (!ftdi)
+                return -ENOMEM;
+
+        mutex_lock(&ftdi_module_lock);
+        list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
+        ftdi->sequence_num = ++ftdi_instances;
+        mutex_unlock(&ftdi_module_lock);
+        ftdi_elan_init_kref(ftdi);
         sema_init(&ftdi->sw_lock, 1);
-        ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
-        ftdi->interface = interface;
-        mutex_init(&ftdi->u132_lock);
-        ftdi->expected = 4;
-        iface_desc = interface->cur_altsetting;
-        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
-                endpoint = &iface_desc->endpoint[i].desc;
-                if (!ftdi->bulk_in_endpointAddr &&
+        ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
+        ftdi->interface = interface;
+        mutex_init(&ftdi->u132_lock);
+        ftdi->expected = 4;
+        iface_desc = interface->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+                endpoint = &iface_desc->endpoint[i].desc;
+                if (!ftdi->bulk_in_endpointAddr &&
                     usb_endpoint_is_bulk_in(endpoint)) {
-                        buffer_size = usb_endpoint_maxp(endpoint);
-                        ftdi->bulk_in_size = buffer_size;
-                        ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress;
-                        ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
-                        if (!ftdi->bulk_in_buffer) {
-                                dev_err(&ftdi->udev->dev, "Could not allocate b"
-                                        "ulk_in_buffer\n");
-                                retval = -ENOMEM;
-                                goto error;
-                        }
-                }
-                if (!ftdi->bulk_out_endpointAddr &&
+                        buffer_size = usb_endpoint_maxp(endpoint);
+                        ftdi->bulk_in_size = buffer_size;
+                        ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress;
+                        ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
+                        if (!ftdi->bulk_in_buffer) {
+                                dev_err(&ftdi->udev->dev, "Could not allocate bulk_in_buffer\n");
+                                retval = -ENOMEM;
+                                goto error;
+                        }
+                }
+                if (!ftdi->bulk_out_endpointAddr &&
                     usb_endpoint_is_bulk_out(endpoint)) {
-                        ftdi->bulk_out_endpointAddr =
-                                endpoint->bEndpointAddress;
-                }
-        }
-        if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) {
-                dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk"
-                        "-out endpoints\n");
-                retval = -ENODEV;
-                goto error;
-        }
-        dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
-                iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
-                ftdi->bulk_out_endpointAddr);
-        usb_set_intfdata(interface, ftdi);
-        if (iface_desc->desc.bInterfaceNumber == 0 &&
-                ftdi->bulk_in_endpointAddr == 0x81 &&
-                ftdi->bulk_out_endpointAddr == 0x02) {
-                retval = usb_register_dev(interface, &ftdi_elan_jtag_class);
-                if (retval) {
-                        dev_err(&ftdi->udev->dev, "Not able to get a minor for "
-                                "this device.\n");
-                        usb_set_intfdata(interface, NULL);
-                        retval = -ENOMEM;
-                        goto error;
-                } else {
-                        ftdi->class = &ftdi_elan_jtag_class;
-                        dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface "
-                                "%d now attached to ftdi%d\n", ftdi,
-                                iface_desc->desc.bInterfaceNumber,
-                                interface->minor);
-                        return 0;
-                }
-        } else if (iface_desc->desc.bInterfaceNumber == 1 &&
-                ftdi->bulk_in_endpointAddr == 0x83 &&
-                ftdi->bulk_out_endpointAddr == 0x04) {
-                ftdi->class = NULL;
-                dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now a"
-                        "ctivated\n", ftdi, iface_desc->desc.bInterfaceNumber);
-                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
-                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
-                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
-                ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
-                return 0;
-        } else {
-                dev_err(&ftdi->udev->dev,
-                        "Could not find ELAN's U132 device\n");
-                retval = -ENODEV;
-                goto error;
-        }
-      error:if (ftdi) {
-                ftdi_elan_put_kref(ftdi);
-        }
-        return retval;
+                        ftdi->bulk_out_endpointAddr =
+                                endpoint->bEndpointAddress;
+                }
+        }
+        if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) {
+                dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk-out endpoints\n");
+                retval = -ENODEV;
+                goto error;
+        }
+        dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
+                 iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
+                 ftdi->bulk_out_endpointAddr);
+        usb_set_intfdata(interface, ftdi);
+        if (iface_desc->desc.bInterfaceNumber == 0 &&
+            ftdi->bulk_in_endpointAddr == 0x81 &&
+            ftdi->bulk_out_endpointAddr == 0x02) {
+                retval = usb_register_dev(interface, &ftdi_elan_jtag_class);
+                if (retval) {
+                        dev_err(&ftdi->udev->dev, "Not able to get a minor for this device\n");
+                        usb_set_intfdata(interface, NULL);
+                        retval = -ENOMEM;
+                        goto error;
+                } else {
+                        ftdi->class = &ftdi_elan_jtag_class;
+                        dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface %d now attached to ftdi%d\n",
+                                 ftdi, iface_desc->desc.bInterfaceNumber,
+                                 interface->minor);
+                        return 0;
+                }
+        } else if (iface_desc->desc.bInterfaceNumber == 1 &&
+                   ftdi->bulk_in_endpointAddr == 0x83 &&
+                   ftdi->bulk_out_endpointAddr == 0x04) {
+                ftdi->class = NULL;
+                dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now activated\n",
+                         ftdi, iface_desc->desc.bInterfaceNumber);
+                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
+                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
+                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
+                ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
+                return 0;
+        } else {
+                dev_err(&ftdi->udev->dev,
+                        "Could not find ELAN's U132 device\n");
+                retval = -ENODEV;
+                goto error;
+        }
+error:if (ftdi) {
+                ftdi_elan_put_kref(ftdi);
+        }
+        return retval;
 }
 
 static void ftdi_elan_disconnect(struct usb_interface *interface)
 {
-        struct usb_ftdi *ftdi = usb_get_intfdata(interface);
-        ftdi->disconnected += 1;
-        if (ftdi->class) {
-                int minor = interface->minor;
-                struct usb_class_driver *class = ftdi->class;
-                usb_set_intfdata(interface, NULL);
-                usb_deregister_dev(interface, class);
-                dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on min"
-                        "or %d now disconnected\n", minor);
-        } else {
-                ftdi_status_cancel_work(ftdi);
-                ftdi_command_cancel_work(ftdi);
-                ftdi_response_cancel_work(ftdi);
-                ftdi_elan_abandon_completions(ftdi);
-                ftdi_elan_abandon_targets(ftdi);
-                if (ftdi->registered) {
-                        platform_device_unregister(&ftdi->platform_dev);
-                        ftdi->synchronized = 0;
-                        ftdi->enumerated = 0;
-                        ftdi->initialized = 0;
-                        ftdi->registered = 0;
-                }
-                flush_workqueue(status_queue);
-                flush_workqueue(command_queue);
-                flush_workqueue(respond_queue);
-                ftdi->disconnected += 1;
-                usb_set_intfdata(interface, NULL);
-                dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller inter"
-                        "face now disconnected\n");
-        }
-        ftdi_elan_put_kref(ftdi);
+        struct usb_ftdi *ftdi = usb_get_intfdata(interface);
+        ftdi->disconnected += 1;
+        if (ftdi->class) {
+                int minor = interface->minor;
+                struct usb_class_driver *class = ftdi->class;
+                usb_set_intfdata(interface, NULL);
+                usb_deregister_dev(interface, class);
+                dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on minor %d now disconnected\n",
+                         minor);
+        } else {
+                ftdi_status_cancel_work(ftdi);
+                ftdi_command_cancel_work(ftdi);
+                ftdi_response_cancel_work(ftdi);
+                ftdi_elan_abandon_completions(ftdi);
+                ftdi_elan_abandon_targets(ftdi);
+                if (ftdi->registered) {
+                        platform_device_unregister(&ftdi->platform_dev);
+                        ftdi->synchronized = 0;
+                        ftdi->enumerated = 0;
+                        ftdi->initialized = 0;
+                        ftdi->registered = 0;
+                }
+                flush_workqueue(status_queue);
+                flush_workqueue(command_queue);
+                flush_workqueue(respond_queue);
+                ftdi->disconnected += 1;
+                usb_set_intfdata(interface, NULL);
+                dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller interface now disconnected\n");
+        }
+        ftdi_elan_put_kref(ftdi);
 }
 
 static struct usb_driver ftdi_elan_driver = {
-        .name = "ftdi-elan",
-        .probe = ftdi_elan_probe,
-        .disconnect = ftdi_elan_disconnect,
-        .id_table = ftdi_elan_table,
+        .name = "ftdi-elan",
+        .probe = ftdi_elan_probe,
+        .disconnect = ftdi_elan_disconnect,
+        .id_table = ftdi_elan_table,
 };
 static int __init ftdi_elan_init(void)
 {
-        int result;
-        printk(KERN_INFO "driver %s\n", ftdi_elan_driver.name);
-        mutex_init(&ftdi_module_lock);
-        INIT_LIST_HEAD(&ftdi_static_list);
-        status_queue = create_singlethread_workqueue("ftdi-status-control");
+        int result;
+        pr_info("driver %s\n", ftdi_elan_driver.name);
+        mutex_init(&ftdi_module_lock);
+        INIT_LIST_HEAD(&ftdi_static_list);
+        status_queue = create_singlethread_workqueue("ftdi-status-control");
         if (!status_queue)
                 goto err_status_queue;
-        command_queue = create_singlethread_workqueue("ftdi-command-engine");
+        command_queue = create_singlethread_workqueue("ftdi-command-engine");
         if (!command_queue)
                 goto err_command_queue;
-        respond_queue = create_singlethread_workqueue("ftdi-respond-engine");
+        respond_queue = create_singlethread_workqueue("ftdi-respond-engine");
         if (!respond_queue)
                 goto err_respond_queue;
-        result = usb_register(&ftdi_elan_driver);
-        if (result) {
+        result = usb_register(&ftdi_elan_driver);
+        if (result) {
                 destroy_workqueue(status_queue);
                 destroy_workqueue(command_queue);
                 destroy_workqueue(respond_queue);
-                printk(KERN_ERR "usb_register failed. Error number %d\n",
-                       result);
+                pr_err("usb_register failed. Error number %d\n", result);
         }
-        return result;
+        return result;
 
- err_respond_queue:
+err_respond_queue:
         destroy_workqueue(command_queue);
- err_command_queue:
+err_command_queue:
         destroy_workqueue(status_queue);
- err_status_queue:
-        printk(KERN_ERR "%s couldn't create workqueue\n", ftdi_elan_driver.name);
+err_status_queue:
+        pr_err("%s couldn't create workqueue\n", ftdi_elan_driver.name);
         return -ENOMEM;
 }
 
 static void __exit ftdi_elan_exit(void)
 {
-        struct usb_ftdi *ftdi;
-        struct usb_ftdi *temp;
-        usb_deregister(&ftdi_elan_driver);
-        printk(KERN_INFO "ftdi_u132 driver deregistered\n");
-        list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
-                ftdi_status_cancel_work(ftdi);
-                ftdi_command_cancel_work(ftdi);
-                ftdi_response_cancel_work(ftdi);
-        } flush_workqueue(status_queue);
-        destroy_workqueue(status_queue);
-        status_queue = NULL;
-        flush_workqueue(command_queue);
-        destroy_workqueue(command_queue);
-        command_queue = NULL;
-        flush_workqueue(respond_queue);
-        destroy_workqueue(respond_queue);
-        respond_queue = NULL;
+        struct usb_ftdi *ftdi;
+        struct usb_ftdi *temp;
+        usb_deregister(&ftdi_elan_driver);
+        pr_info("ftdi_u132 driver deregistered\n");
+        list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
+                ftdi_status_cancel_work(ftdi);
+                ftdi_command_cancel_work(ftdi);
+                ftdi_response_cancel_work(ftdi);
+        } flush_workqueue(status_queue);
+        destroy_workqueue(status_queue);
+        status_queue = NULL;
+        flush_workqueue(command_queue);
+        destroy_workqueue(command_queue);
+        command_queue = NULL;
+        flush_workqueue(respond_queue);
+        destroy_workqueue(respond_queue);
+        respond_queue = NULL;
 }
 
 
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 20bcfdd7eace..c6bfd13f6c92 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -51,19 +51,12 @@
 */
 #define MAX_WRITES_IN_FLIGHT 4
 
-/* Use our own dbg macro */
-#undef dbg
-#define dbg( format, arg... ) do { if( debug ) printk( KERN_DEBUG __FILE__ ": " format "\n" , ## arg ); } while ( 0 )
-
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 /* Module parameters */
 static DEFINE_MUTEX(iowarrior_mutex);
-static bool debug = 0;
-module_param(debug, bool, 0644);
-MODULE_PARM_DESC(debug, "debug=1 enables debugging messages");
 
 static struct usb_driver iowarrior_driver;
 static DEFINE_MUTEX(iowarrior_open_disc_lock);
@@ -235,8 +228,8 @@ static void iowarrior_write_callback(struct urb *urb)
         if (status &&
             !(status == -ENOENT ||
               status == -ECONNRESET || status == -ESHUTDOWN)) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&dev->interface->dev,
+                        "nonzero write bulk status received: %d\n", status);
         }
         /* free up our allocated buffer */
         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
@@ -251,7 +244,7 @@ static void iowarrior_write_callback(struct urb *urb)
  */
 static inline void iowarrior_delete(struct iowarrior *dev)
 {
-        dbg("%s - minor %d", __func__, dev->minor);
+        dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor);
         kfree(dev->int_in_buffer);
         usb_free_urb(dev->int_in_urb);
         kfree(dev->read_queue);
@@ -288,7 +281,8 @@ static ssize_t iowarrior_read(struct file *file, char __user *buffer,
         if (dev == NULL || !dev->present)
                 return -ENODEV;
 
-        dbg("%s - minor %d, count = %zd", __func__, dev->minor, count);
+        dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n",
+                dev->minor, count);
 
         /* read count must be packet size (+ time stamp) */
         if ((count != dev->report_size)
@@ -356,7 +350,8 @@ static ssize_t iowarrior_write(struct file *file,
                 retval = -ENODEV;
                 goto exit;
         }
-        dbg("%s - minor %d, count = %zd", __func__, dev->minor, count);
+        dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n",
+                dev->minor, count);
         /* if count is 0 we're already done */
         if (count == 0) {
                 retval = 0;
@@ -418,14 +413,16 @@ static ssize_t iowarrior_write(struct file *file,
                 int_out_urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (!int_out_urb) {
                         retval = -ENOMEM;
-                        dbg("%s Unable to allocate urb ", __func__);
+                        dev_dbg(&dev->interface->dev,
+                                "Unable to allocate urb\n");
                         goto error_no_urb;
                 }
                 buf = usb_alloc_coherent(dev->udev, dev->report_size,
                                          GFP_KERNEL, &int_out_urb->transfer_dma);
                 if (!buf) {
                         retval = -ENOMEM;
-                        dbg("%s Unable to allocate buffer ", __func__);
+                        dev_dbg(&dev->interface->dev,
+                                "Unable to allocate buffer\n");
                         goto error_no_buffer;
                 }
                 usb_fill_int_urb(int_out_urb, dev->udev,
@@ -441,8 +438,9 @@ static ssize_t iowarrior_write(struct file *file,
                 }
                 retval = usb_submit_urb(int_out_urb, GFP_KERNEL);
                 if (retval) {
-                        dbg("%s submit error %d for urb nr.%d", __func__,
-                            retval, atomic_read(&dev->write_busy));
+                        dev_dbg(&dev->interface->dev,
+                                "submit error %d for urb nr.%d\n",
+                                retval, atomic_read(&dev->write_busy));
                         goto error;
                 }
                 /* submit was ok */
@@ -502,8 +500,8 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd,
                 goto error_out;
         }
 
-        dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__, dev->minor, cmd,
-            arg);
+        dev_dbg(&dev->interface->dev, "minor %d, cmd 0x%.4x, arg %ld\n",
+                dev->minor, cmd, arg);
 
         retval = 0;
         io_res = 0;
@@ -601,8 +599,6 @@ static int iowarrior_open(struct inode *inode, struct file *file)
         int subminor;
         int retval = 0;
 
-        dbg("%s", __func__);
-
         mutex_lock(&iowarrior_mutex);
         subminor = iminor(inode);
 
@@ -662,7 +658,7 @@ static int iowarrior_release(struct inode *inode, struct file *file)
                 return -ENODEV;
         }
 
-        dbg("%s - minor %d", __func__, dev->minor);
+        dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor);
 
         /* lock our device */
         mutex_lock(&dev->mutex);
diff --git a/drivers/usb/misc/usb3503.c b/drivers/usb/misc/usb3503.c
index a31641e18d19..f43c61989cef 100644
--- a/drivers/usb/misc/usb3503.c
+++ b/drivers/usb/misc/usb3503.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/clk.h>
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/delay.h>
@@ -57,10 +58,12 @@ struct usb3503 {
         enum usb3503_mode       mode;
         struct regmap           *regmap;
         struct device           *dev;
+        struct clk              *clk;
         u8      port_off_mask;
         int     gpio_intn;
         int     gpio_reset;
         int     gpio_connect;
+        bool    secondary_ref_clk;
 };
 
 static int usb3503_reset(struct usb3503 *hub, int state)
@@ -184,8 +187,58 @@ static int usb3503_probe(struct usb3503 *hub)
                 hub->gpio_reset         = pdata->gpio_reset;
                 hub->mode               = pdata->initial_mode;
         } else if (np) {
+                struct clk *clk;
                 hub->port_off_mask = 0;
 
+                clk = devm_clk_get(dev, "refclk");
+                if (IS_ERR(clk) && PTR_ERR(clk) != -ENOENT) {
+                        dev_err(dev, "unable to request refclk (%d)\n", err);
+                        return PTR_ERR(clk);
+                }
+
+                if (!IS_ERR(clk)) {
+                        u32 rate = 0;
+                        hub->clk = clk;
+
+                        if (!of_property_read_u32(np, "refclk-frequency",
+                                                 &rate)) {
+
+                                switch (rate) {
+                                case 38400000:
+                                case 26000000:
+                                case 19200000:
+                                case 12000000:
+                                        hub->secondary_ref_clk = 0;
+                                        break;
+                                case 24000000:
+                                case 27000000:
+                                case 25000000:
+                                case 50000000:
+                                        hub->secondary_ref_clk = 1;
+                                        break;
+                                default:
+                                        dev_err(dev,
+                                                "unsupported reference clock rate (%d)\n",
+                                                (int) rate);
+                                        return -EINVAL;
+                                }
+                                err = clk_set_rate(hub->clk, rate);
+                                if (err) {
+                                        dev_err(dev,
+                                                "unable to set reference clock rate to %d\n",
+                                                (int) rate);
+                                        return err;
+                                }
+                        }
+
+                        err = clk_prepare_enable(hub->clk);
+                        if (err) {
+                                dev_err(dev,
+                                        "unable to enable reference clock\n");
+                                return err;
+                        }
+                }
+
                 property = of_get_property(np, "disabled-ports", &len);
                 if (property && (len / sizeof(u32)) > 0) {
                         int i;
@@ -213,8 +266,10 @@ static int usb3503_probe(struct usb3503 *hub)
                 dev_err(dev, "Ports disabled with no control interface\n");
 
         if (gpio_is_valid(hub->gpio_intn)) {
-                err = devm_gpio_request_one(dev, hub->gpio_intn,
-                                GPIOF_OUT_INIT_HIGH, "usb3503 intn");
+                int val = hub->secondary_ref_clk ? GPIOF_OUT_INIT_LOW :
+                                                   GPIOF_OUT_INIT_HIGH;
+                err = devm_gpio_request_one(dev, hub->gpio_intn, val,
+                                            "usb3503 intn");
                 if (err) {
                         dev_err(dev,
                                 "unable to request GPIO %d as connect pin (%d)\n",
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index f6568b5e9b06..51a6da256772 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -1320,6 +1320,11 @@ static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
         urb->context = &completion;
         urb->complete = unlink1_callback;
 
+        if (usb_pipeout(urb->pipe)) {
+                simple_fill_buf(urb);
+                urb->transfer_flags |= URB_ZERO_PACKET;
+        }
+
         /* keep the endpoint busy.  there are lots of hc/hcd-internal
          * states, and testing should get to all of them over time.
          *
@@ -1340,6 +1345,9 @@ static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
                 while (!completion_done(&completion)) {
                         retval = usb_unlink_urb(urb);
 
+                        if (retval == 0 && usb_pipein(urb->pipe))
+                                retval = simple_check_buf(dev, urb);
+
                         switch (retval) {
                         case -EBUSY:
                         case -EIDRM:
@@ -1450,6 +1458,11 @@ static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
                                 unlink_queued_callback, &ctx);
                 ctx.urbs[i]->transfer_dma = buf_dma;
                 ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+
+                if (usb_pipeout(ctx.urbs[i]->pipe)) {
+                        simple_fill_buf(ctx.urbs[i]);
+                        ctx.urbs[i]->transfer_flags |= URB_ZERO_PACKET;
+                }
         }
 
         /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
index 24278208bf74..1472805083de 100644
--- a/drivers/usb/misc/yurex.c
+++ b/drivers/usb/misc/yurex.c
@@ -296,6 +296,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
 
         /* save our data pointer in this interface device */
         usb_set_intfdata(interface, dev);
+        dev->bbu = -1;
 
         /* we can register the device now, as it is ready */
         retval = usb_register_dev(interface, &yurex_class);
@@ -306,8 +307,6 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
                 goto error;
         }
 
-        dev->bbu = -1;
-
         dev_info(&interface->dev,
                  "USB YUREX device now attached to Yurex #%d\n",
                  interface->minor);
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 8b789792f6fa..06cc5d6ea681 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -76,7 +76,7 @@ config USB_MUSB_TUSB6010
 
 config USB_MUSB_OMAP2PLUS
         tristate "OMAP2430 and onwards"
-        depends on ARCH_OMAP2PLUS
+        depends on ARCH_OMAP2PLUS && USB
         select GENERIC_PHY
 
 config USB_MUSB_AM35X
@@ -141,10 +141,11 @@ config USB_TI_CPPI_DMA
 config USB_TI_CPPI41_DMA
         bool 'TI CPPI 4.1 (AM335x)'
         depends on ARCH_OMAP
+        select TI_CPPI41
 
 config USB_TUSB_OMAP_DMA
         bool 'TUSB 6010'
-        depends on USB_MUSB_TUSB6010
+        depends on USB_MUSB_TUSB6010 = USB_MUSB_HDRC # both built-in or both modules
         depends on ARCH_OMAP
         help
           Enable DMA transfers on TUSB 6010 when OMAP DMA is available.
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index b3aa0184af9a..0a34dd859555 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -32,7 +32,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/platform_data/usb-omap.h>
 
 #include "musb_core.h"
@@ -85,6 +85,7 @@
 struct am35x_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
         struct clk              *phy_clk;
         struct clk              *clk;
 };
@@ -360,7 +361,6 @@ static int am35x_musb_init(struct musb *musb)
         if (!rev)
                 return -ENODEV;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -EPROBE_DEFER;
@@ -402,7 +402,6 @@ static int am35x_musb_exit(struct musb *musb)
                 data->set_phy_power(0);
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -505,6 +504,9 @@ static int am35x_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &am35x_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy))
+                goto err7;
         platform_set_drvdata(pdev, glue);
 
         pinfo = am35x_dev_info;
@@ -518,11 +520,14 @@ static int am35x_probe(struct platform_device *pdev)
         if (IS_ERR(musb)) {
                 ret = PTR_ERR(musb);
                 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
-                goto err7;
+                goto err8;
         }
 
         return 0;
 
+err8:
+        usb_phy_generic_unregister(glue->phy);
+
 err7:
         clk_disable(clk);
 
@@ -547,6 +552,7 @@ static int am35x_remove(struct platform_device *pdev)
         struct am35x_glue       *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         clk_disable(glue->clk);
         clk_disable(glue->phy_clk);
         clk_put(glue->clk);
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 796677fa9a15..d40d5f0b5528 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -18,7 +18,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/prefetch.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <asm/cacheflush.h>
 
@@ -29,6 +29,7 @@
 struct bfin_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
 };
 #define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
@@ -401,7 +402,6 @@ static int bfin_musb_init(struct musb *musb)
         }
         gpio_direction_output(musb->config->gpio_vrsel, 0);
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 gpio_free(musb->config->gpio_vrsel);
@@ -424,9 +424,8 @@ static int bfin_musb_init(struct musb *musb)
 static int bfin_musb_exit(struct musb *musb)
 {
         gpio_free(musb->config->gpio_vrsel);
-
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
+
         return 0;
 }
 
@@ -477,6 +476,9 @@ static int bfin_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &bfin_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy))
+                goto err2;
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -514,6 +516,9 @@ static int bfin_probe(struct platform_device *pdev)
         return 0;
 
 err3:
+        usb_phy_generic_unregister(glue->phy);
+
+err2:
         platform_device_put(musb);
 
 err1:
@@ -528,6 +533,7 @@ static int bfin_remove(struct platform_device *pdev)
         struct bfin_glue                *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         kfree(glue);
 
         return 0;
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index e3486de71995..058775e647ad 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -32,7 +32,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <mach/da8xx.h>
 #include <linux/platform_data/usb-davinci.h>
@@ -85,6 +85,7 @@
 struct da8xx_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
         struct clk              *clk;
 };
 
@@ -418,7 +419,6 @@ static int da8xx_musb_init(struct musb *musb)
         if (!rev)
                 goto fail;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 ret = -EPROBE_DEFER;
@@ -453,7 +453,6 @@ static int da8xx_musb_exit(struct musb *musb)
         phy_off();
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -512,6 +511,11 @@ static int da8xx_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &da8xx_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy)) {
+                ret = PTR_ERR(glue->phy);
+                goto err5;
+        }
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -538,11 +542,14 @@ static int da8xx_probe(struct platform_device *pdev)
         if (IS_ERR(musb)) {
                 ret = PTR_ERR(musb);
                 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
-                goto err5;
+                goto err6;
         }
 
         return 0;
 
+err6:
+        usb_phy_generic_unregister(glue->phy);
+
 err5:
         clk_disable(clk);
 
@@ -561,6 +568,7 @@ static int da8xx_remove(struct platform_device *pdev)
         struct da8xx_glue               *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         clk_disable(glue->clk);
         clk_put(glue->clk);
         kfree(glue);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index c259dac9d056..de8492b06e46 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -32,7 +32,7 @@
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <mach/cputype.h>
 #include <mach/hardware.h>
@@ -381,7 +381,6 @@ static int davinci_musb_init(struct musb *musb)
         u32             revision;
         int             ret = -ENODEV;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 ret = -EPROBE_DEFER;
@@ -439,7 +438,7 @@ static int davinci_musb_init(struct musb *musb)
 fail:
         usb_put_phy(musb->xceiv);
 unregister:
-        usb_nop_xceiv_unregister();
+        usb_phy_generic_unregister();
         return ret;
 }
 
@@ -487,7 +486,6 @@ static int davinci_musb_exit(struct musb *musb)
         phy_off();
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -545,6 +543,7 @@ static int davinci_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &davinci_ops;
 
+        usb_phy_generic_register();
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -603,6 +602,7 @@ static int davinci_remove(struct platform_device *pdev)
         struct davinci_glue             *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister();
         clk_disable(glue->clk);
         clk_put(glue->clk);
         kfree(glue);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 07576907e2c6..61da471b7aed 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -848,6 +848,10 @@ b_host:
                 }
         }
 
+        /* handle babble condition */
+        if (int_usb & MUSB_INTR_BABBLE)
+                schedule_work(&musb->recover_work);
+
 #if 0
 /* REVISIT ... this would be for multiplexing periodic endpoints, or
  * supporting transfer phasing to prevent exceeding ISO bandwidth
@@ -1746,6 +1750,34 @@ static void musb_irq_work(struct work_struct *data)
         }
 }
 
+/* Recover from babble interrupt conditions */
+static void musb_recover_work(struct work_struct *data)
+{
+        struct musb *musb = container_of(data, struct musb, recover_work);
+        int status;
+
+        musb_platform_reset(musb);
+
+        usb_phy_vbus_off(musb->xceiv);
+        udelay(100);
+
+        usb_phy_vbus_on(musb->xceiv);
+        udelay(100);
+
+        /*
+         * When a babble condition occurs, the musb controller removes the
+         * session bit and the endpoint config is lost.
+         */
+        if (musb->dyn_fifo)
+                status = ep_config_from_table(musb);
+        else
+                status = ep_config_from_hw(musb);
+
+        /* start the session again */
+        if (status == 0)
+                musb_start(musb);
+}
+
 /* --------------------------------------------------------------------------
  * Init support
  */
@@ -1913,6 +1945,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
         /* Init IRQ workqueue before request_irq */
         INIT_WORK(&musb->irq_work, musb_irq_work);
+        INIT_WORK(&musb->recover_work, musb_recover_work);
         INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);
         INIT_DELAYED_WORK(&musb->finish_resume_work, musb_host_finish_resume);
 
@@ -2008,6 +2041,7 @@ fail4:
 
 fail3:
         cancel_work_sync(&musb->irq_work);
+        cancel_work_sync(&musb->recover_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         if (musb->dma_controller)
@@ -2073,6 +2107,7 @@ static int musb_remove(struct platform_device *pdev)
                 dma_controller_destroy(musb->dma_controller);
 
         cancel_work_sync(&musb->irq_work);
+        cancel_work_sync(&musb->recover_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         musb_free(musb);
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 7083e82776ff..d155a156f240 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -192,6 +192,7 @@ struct musb_platform_ops {
 
         int     (*set_mode)(struct musb *musb, u8 mode);
         void    (*try_idle)(struct musb *musb, unsigned long timeout);
+        void    (*reset)(struct musb *musb);
 
         int     (*vbus_status)(struct musb *musb);
         void    (*set_vbus)(struct musb *musb, int on);
@@ -296,6 +297,7 @@ struct musb {
 
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
+        struct work_struct      recover_work;
         struct delayed_work     deassert_reset_work;
         struct delayed_work     finish_resume_work;
         u16                     hwvers;
@@ -337,6 +339,7 @@ struct musb {
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
+        u8                      tusb_revision;
 #endif
 
         /* passed down from chip/board specific irq handlers */
@@ -552,6 +555,12 @@ static inline void musb_platform_try_idle(struct musb *musb,
                 musb->ops->try_idle(musb, timeout);
 }
 
+static inline void musb_platform_reset(struct musb *musb)
+{
+        if (musb->ops->reset)
+                musb->ops->reset(musb);
+}
+
 static inline int musb_platform_get_vbus_status(struct musb *musb)
 {
         if (!musb->ops->vbus_status)
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index e2fd263585de..51beb13c7e1a 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -35,7 +35,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/pm_runtime.h>
 #include <linux/module.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/platform_data/usb-omap.h>
 #include <linux/sizes.h>
 
@@ -329,9 +329,21 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
          * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
          * Also, DRVVBUS pulses for SRP (but not at 5V) ...
          */
-        if (is_host_active(musb) && usbintr & MUSB_INTR_BABBLE)
+        if (is_host_active(musb) && usbintr & MUSB_INTR_BABBLE) {
                 pr_info("CAUTION: musb: Babble Interrupt Occurred\n");
 
+                /*
+                 * When a babble condition occurs, the musb controller removes
+                 * the session and is no longer in host mode. Hence, all
+                 * devices connected to its root hub get disconnected.
+                 *
+                 * Hand this error down to the musb core isr, so it can
+                 * recover.
+                 */
+                musb->int_usb = MUSB_INTR_BABBLE | MUSB_INTR_DISCONNECT;
+                musb->int_tx = musb->int_rx = 0;
+        }
+
         if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) {
                 int drvvbus = dsps_readl(reg_base, wrp->status);
                 void __iomem *mregs = musb->mregs;
@@ -524,6 +536,16 @@ static int dsps_musb_set_mode(struct musb *musb, u8 mode)
         return 0;
 }
 
+static void dsps_musb_reset(struct musb *musb)
+{
+        struct device *dev = musb->controller;
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+
+        dsps_writel(musb->ctrl_base, wrp->control, (1 << wrp->reset));
+        udelay(100);
+}
+
 static struct musb_platform_ops dsps_ops = {
         .init           = dsps_musb_init,
         .exit           = dsps_musb_exit,
@@ -533,6 +555,7 @@ static struct musb_platform_ops dsps_ops = {
 
         .try_idle       = dsps_musb_try_idle,
         .set_mode       = dsps_musb_set_mode,
+        .reset          = dsps_musb_reset,
 };
 
 static u64 musb_dmamask = DMA_BIT_MASK(32);
@@ -750,7 +773,7 @@ static const struct of_device_id musb_dsps_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, musb_dsps_of_match);
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int dsps_suspend(struct device *dev)
 {
         struct dsps_glue *glue = dev_get_drvdata(dev);
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 4e9fb1d08698..159ef4be1ef2 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -24,13 +24,14 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include "musb_core.h"
 
 struct tusb6010_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
 };
 
 static void tusb_musb_set_vbus(struct musb *musb, int is_on);
@@ -42,7 +43,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on);
  * Checks the revision. We need to use the DMA register as 3.0 does not
  * have correct versions for TUSB_PRCM_REV or TUSB_INT_CTRL_REV.
  */
-u8 tusb_get_revision(struct musb *musb)
+static u8 tusb_get_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             die_id;
@@ -58,14 +59,13 @@ u8 tusb_get_revision(struct musb *musb)
 
         return rev;
 }
-EXPORT_SYMBOL_GPL(tusb_get_revision);
 
-static int tusb_print_revision(struct musb *musb)
+static void tusb_print_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u8              rev;
 
-        rev = tusb_get_revision(musb);
+        rev = musb->tusb_revision;
 
         pr_info("tusb: %s%i.%i %s%i.%i %s%i.%i %s%i.%i %s%i %s%i.%i\n",
                 "prcm",
@@ -84,8 +84,6 @@ static int tusb_print_revision(struct musb *musb)
                 TUSB_DIDR1_HI_CHIP_REV(musb_readl(tbase, TUSB_DIDR1_HI)),
                 "rev",
                 TUSB_REV_MAJOR(rev), TUSB_REV_MINOR(rev));
-
-        return tusb_get_revision(musb);
 }
 
 #define WBUS_QUIRK_MASK (TUSB_PHY_OTG_CTRL_TESTM2 | TUSB_PHY_OTG_CTRL_TESTM1 \
@@ -349,7 +347,7 @@ static void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
         u32             reg;
 
         if ((wakeup_enables & TUSB_PRCM_WBUS)
-                        && (tusb_get_revision(musb) == TUSB_REV_30))
+                        && (musb->tusb_revision == TUSB_REV_30))
                 tusb_wbus_quirk(musb, 1);
 
         tusb_set_clock_source(musb, 0);
@@ -797,7 +795,7 @@ static irqreturn_t tusb_musb_interrupt(int irq, void *__hci)
                 u32     reg;
                 u32     i;
 
-                if (tusb_get_revision(musb) == TUSB_REV_30)
+                if (musb->tusb_revision == TUSB_REV_30)
                         tusb_wbus_quirk(musb, 0);
 
                 /* there are issues re-locking the PLL on wakeup ... */
@@ -1011,10 +1009,11 @@ static int tusb_musb_start(struct musb *musb)
                 goto err;
         }
 
-        ret = tusb_print_revision(musb);
-        if (ret < 2) {
+        musb->tusb_revision = tusb_get_revision(musb);
+        tusb_print_revision(musb);
+        if (musb->tusb_revision < 2) {
                 printk(KERN_ERR "tusb: Unsupported TUSB6010 revision %i\n",
-                                ret);
+                                musb->tusb_revision);
                 goto err;
         }
 
@@ -1065,7 +1064,6 @@ static int tusb_musb_init(struct musb *musb)
         void __iomem            *sync = NULL;
         int                     ret;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -EPROBE_DEFER;
@@ -1117,7 +1115,6 @@ done:
                         iounmap(sync);
 
                 usb_put_phy(musb->xceiv);
-                usb_nop_xceiv_unregister();
         }
         return ret;
 }
@@ -1133,7 +1130,6 @@ static int tusb_musb_exit(struct musb *musb)
         iounmap(musb->sync_va);
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
         return 0;
 }
 
@@ -1176,6 +1172,7 @@ static int tusb_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &tusb_ops;
 
+        usb_phy_generic_register();
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -1224,6 +1221,7 @@ static int tusb_remove(struct platform_device *pdev)
         struct tusb6010_glue            *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         kfree(glue);
 
         return 0;
diff --git a/drivers/usb/musb/tusb6010.h b/drivers/usb/musb/tusb6010.h
index 35c933a5d991..aec86c86ce32 100644
--- a/drivers/usb/musb/tusb6010.h
+++ b/drivers/usb/musb/tusb6010.h
@@ -12,14 +12,6 @@
 #ifndef __TUSB6010_H__
 #define __TUSB6010_H__
 
-extern u8 tusb_get_revision(struct musb *musb);
-
-#ifdef CONFIG_USB_TUSB6010
-#define musb_in_tusb()                  1
-#else
-#define musb_in_tusb()                  0
-#endif
-
 #ifdef CONFIG_USB_TUSB_OMAP_DMA
 #define tusb_dma_omap()                 1
 #else
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index e33b6b2c44c2..3ce152c0408e 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -677,7 +677,7 @@ struct dma_controller *dma_controller_create(struct musb *musb, void __iomem *ba
         tusb_dma->controller.channel_program = tusb_omap_dma_program;
         tusb_dma->controller.channel_abort = tusb_omap_dma_abort;
 
-        if (tusb_get_revision(musb) >= TUSB_REV_30)
+        if (musb->tusb_revision >= TUSB_REV_30)
                 tusb_dma->multichannel = 1;
 
         for (i = 0; i < MAX_DMAREQ; i++) {
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index 416e0c8cf6ff..e253fa05be68 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -6,15 +6,6 @@ menu "USB Physical Layer drivers"
 config USB_PHY
         def_bool n
 
-config USB_OTG_FSM
-        tristate "USB 2.0 OTG FSM implementation"
-        depends on USB
-        select USB_OTG
-        select USB_PHY
-        help
-          Implements OTG Final State Machine as specified in On-The-Go
-          and Embedded Host Supplement to the USB Revision 2.0 Specification.
-
 #
 # USB Transceiver Drivers
 #
@@ -59,14 +50,6 @@ config KEYSTONE_USB_PHY
           interface to interact with USB 2.0 and USB 3.0 PHY that is part
           of the Keystone SOC.
 
-config MV_U3D_PHY
-        bool "Marvell USB 3.0 PHY controller Driver"
-        depends on CPU_MMP3
-        select USB_PHY
-        help
-          Enable this to support Marvell USB 3.0 phy controller for Marvell
-          SoC.
-
 config NOP_USB_XCEIV
         tristate "NOP USB Transceiver Driver"
         select USB_PHY
@@ -171,11 +154,12 @@ config USB_ISP1301
           module will be called phy-isp1301.
 
 config USB_MSM_OTG
-        tristate "OTG support for Qualcomm on-chip USB controller"
-        depends on (USB || USB_GADGET) && ARCH_MSM
+        tristate "Qualcomm on-chip USB OTG controller support"
+        depends on (USB || USB_GADGET) && (ARCH_MSM || ARCH_QCOM || COMPILE_TEST)
+        depends on RESET_CONTROLLER
         select USB_PHY
         help
-          Enable this to support the USB OTG transceiver on MSM chips. It
+          Enable this to support the USB OTG transceiver on Qualcomm chips. It
           handles PHY initialization, clock management, and workarounds
           required after resetting the hardware and power management.
           This driver is required even for peripheral only or host only
@@ -208,6 +192,7 @@ config USB_MXS_PHY
 config USB_RCAR_PHY
         tristate "Renesas R-Car USB PHY support"
         depends on USB || USB_GADGET
+        depends on ARCH_R8A7778 || ARCH_R8A7779 || COMPILE_TEST
         select USB_PHY
         help
           Say Y here to add support for the Renesas R-Car USB common PHY driver.
@@ -232,7 +217,7 @@ config USB_RCAR_GEN2_PHY
 
 config USB_ULPI
         bool "Generic ULPI Transceiver Driver"
-        depends on ARM
+        depends on ARM || ARM64
         help
           Enable this to support ULPI connected USB OTG transceivers which
           are likely found on embedded boards.
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index f8fa719a31b9..24a91332d4ad 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -3,14 +3,12 @@
 #
 obj-$(CONFIG_USB_PHY)                   += phy.o
 obj-$(CONFIG_OF)                        += of.o
-obj-$(CONFIG_USB_OTG_FSM)               += phy-fsm-usb.o
 
 # transceiver drivers, keep the list sorted
 
 obj-$(CONFIG_AB8500_USB)                += phy-ab8500-usb.o
 obj-$(CONFIG_FSL_USB2_OTG)              += phy-fsl-usb.o
 obj-$(CONFIG_ISP1301_OMAP)              += phy-isp1301-omap.o
-obj-$(CONFIG_MV_U3D_PHY)                += phy-mv-u3d-usb.o
 obj-$(CONFIG_NOP_USB_XCEIV)             += phy-generic.o
 obj-$(CONFIG_TAHVO_USB)                 += phy-tahvo.o
 obj-$(CONFIG_AM335X_CONTROL_USB)        += phy-am335x-control.o
diff --git a/drivers/usb/phy/phy-am335x.c b/drivers/usb/phy/phy-am335x.c
index 12fc3468a01e..585e50cb1980 100644
--- a/drivers/usb/phy/phy-am335x.c
+++ b/drivers/usb/phy/phy-am335x.c
@@ -2,7 +2,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
@@ -13,7 +13,7 @@
 #include "phy-generic.h"
 
 struct am335x_phy {
-        struct usb_phy_gen_xceiv usb_phy_gen;
+        struct usb_phy_generic usb_phy_gen;
         struct phy_control *phy_ctrl;
         int id;
 };
diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c
index bb394980532b..7594e5069ae5 100644
--- a/drivers/usb/phy/phy-generic.c
+++ b/drivers/usb/phy/phy-generic.c
@@ -30,7 +30,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
@@ -41,34 +41,25 @@
 
 #include "phy-generic.h"
 
-static struct platform_device *pd;
-
-void usb_nop_xceiv_register(void)
+struct platform_device *usb_phy_generic_register(void)
 {
-        if (pd)
-                return;
-        pd = platform_device_register_simple("usb_phy_gen_xceiv", -1, NULL, 0);
-        if (IS_ERR(pd)) {
-                pr_err("Unable to register generic usb transceiver\n");
-                pd = NULL;
-                return;
-        }
+        return platform_device_register_simple("usb_phy_generic",
+                        PLATFORM_DEVID_AUTO, NULL, 0);
 }
-EXPORT_SYMBOL(usb_nop_xceiv_register);
+EXPORT_SYMBOL_GPL(usb_phy_generic_register);
 
-void usb_nop_xceiv_unregister(void)
+void usb_phy_generic_unregister(struct platform_device *pdev)
 {
-        platform_device_unregister(pd);
-        pd = NULL;
+        platform_device_unregister(pdev);
 }
-EXPORT_SYMBOL(usb_nop_xceiv_unregister);
+EXPORT_SYMBOL_GPL(usb_phy_generic_unregister);
 
 static int nop_set_suspend(struct usb_phy *x, int suspend)
 {
         return 0;
 }
 
-static void nop_reset_set(struct usb_phy_gen_xceiv *nop, int asserted)
+static void nop_reset_set(struct usb_phy_generic *nop, int asserted)
 {
         int value;
 
@@ -87,7 +78,7 @@ static void nop_reset_set(struct usb_phy_gen_xceiv *nop, int asserted)
 
 int usb_gen_phy_init(struct usb_phy *phy)
 {
-        struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
+        struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 
         if (!IS_ERR(nop->vcc)) {
                 if (regulator_enable(nop->vcc))
@@ -106,7 +97,7 @@ EXPORT_SYMBOL_GPL(usb_gen_phy_init);
 
 void usb_gen_phy_shutdown(struct usb_phy *phy)
 {
-        struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
+        struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 
         /* Assert RESET */
         nop_reset_set(nop, 1);
@@ -150,8 +141,8 @@ static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
         return 0;
 }
 
-int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                struct usb_phy_gen_xceiv_platform_data *pdata)
+int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
+                struct usb_phy_generic_platform_data *pdata)
 {
         enum usb_phy_type type = USB_PHY_TYPE_USB2;
         int err;
@@ -245,10 +236,10 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
 }
 EXPORT_SYMBOL_GPL(usb_phy_gen_create_phy);
 
-static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
+static int usb_phy_generic_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
-        struct usb_phy_gen_xceiv        *nop;
+        struct usb_phy_generic  *nop;
         int err;
 
         nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
@@ -274,9 +265,9 @@ static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int usb_phy_gen_xceiv_remove(struct platform_device *pdev)
+static int usb_phy_generic_remove(struct platform_device *pdev)
 {
-        struct usb_phy_gen_xceiv *nop = platform_get_drvdata(pdev);
+        struct usb_phy_generic *nop = platform_get_drvdata(pdev);
 
         usb_remove_phy(&nop->phy);
 
@@ -290,29 +281,29 @@ static const struct of_device_id nop_xceiv_dt_ids[] = {
 
 MODULE_DEVICE_TABLE(of, nop_xceiv_dt_ids);
 
-static struct platform_driver usb_phy_gen_xceiv_driver = {
-        .probe          = usb_phy_gen_xceiv_probe,
-        .remove         = usb_phy_gen_xceiv_remove,
+static struct platform_driver usb_phy_generic_driver = {
+        .probe          = usb_phy_generic_probe,
+        .remove         = usb_phy_generic_remove,
         .driver         = {
-                .name   = "usb_phy_gen_xceiv",
+                .name   = "usb_phy_generic",
                 .owner  = THIS_MODULE,
                 .of_match_table = nop_xceiv_dt_ids,
         },
 };
 
-static int __init usb_phy_gen_xceiv_init(void)
+static int __init usb_phy_generic_init(void)
 {
-        return platform_driver_register(&usb_phy_gen_xceiv_driver);
+        return platform_driver_register(&usb_phy_generic_driver);
 }
-subsys_initcall(usb_phy_gen_xceiv_init);
+subsys_initcall(usb_phy_generic_init);
 
-static void __exit usb_phy_gen_xceiv_exit(void)
+static void __exit usb_phy_generic_exit(void)
 {
-        platform_driver_unregister(&usb_phy_gen_xceiv_driver);
+        platform_driver_unregister(&usb_phy_generic_driver);
 }
-module_exit(usb_phy_gen_xceiv_exit);
+module_exit(usb_phy_generic_exit);
 
-MODULE_ALIAS("platform:usb_phy_gen_xceiv");
+MODULE_ALIAS("platform:usb_phy_generic");
 MODULE_AUTHOR("Texas Instruments Inc");
 MODULE_DESCRIPTION("NOP USB Transceiver driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/phy/phy-generic.h b/drivers/usb/phy/phy-generic.h
index 38a81f307b82..d8feacc0b7fb 100644
--- a/drivers/usb/phy/phy-generic.h
+++ b/drivers/usb/phy/phy-generic.h
@@ -1,9 +1,9 @@
 #ifndef _PHY_GENERIC_H_
 #define _PHY_GENERIC_H_
 
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
-struct usb_phy_gen_xceiv {
+struct usb_phy_generic {
         struct usb_phy phy;
         struct device *dev;
         struct clk *clk;
@@ -15,7 +15,7 @@ struct usb_phy_gen_xceiv {
 int usb_gen_phy_init(struct usb_phy *phy);
 void usb_gen_phy_shutdown(struct usb_phy *phy);
 
-int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                struct usb_phy_gen_xceiv_platform_data *pdata);
+int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
+                struct usb_phy_generic_platform_data *pdata);
 
 #endif
diff --git a/drivers/usb/phy/phy-isp1301-omap.c b/drivers/usb/phy/phy-isp1301-omap.c
index 6e146d723b37..69e49be8866b 100644
--- a/drivers/usb/phy/phy-isp1301-omap.c
+++ b/drivers/usb/phy/phy-isp1301-omap.c
@@ -1295,7 +1295,7 @@ isp1301_set_host(struct usb_otg *otg, struct usb_bus *host)
                 return isp1301_otg_enable(isp);
         return 0;
 
-#elif   !defined(CONFIG_USB_GADGET_OMAP)
+#elif !IS_ENABLED(CONFIG_USB_OMAP)
         // FIXME update its refcount
         otg->host = host;
 
diff --git a/drivers/usb/phy/phy-keystone.c b/drivers/usb/phy/phy-keystone.c
index d762003896c0..f4d722de912b 100644
--- a/drivers/usb/phy/phy-keystone.c
+++ b/drivers/usb/phy/phy-keystone.c
@@ -18,7 +18,7 @@
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/io.h>
 #include <linux/of.h>
 
@@ -35,7 +35,7 @@
 #define PHY_REF_SSP_EN                  BIT(29)
 
 struct keystone_usbphy {
-        struct usb_phy_gen_xceiv        usb_phy_gen;
+        struct usb_phy_generic  usb_phy_gen;
         void __iomem                    *phy_ctrl;
 };
 
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index 5b37b81f2ef6..ced34f39bdd4 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -30,9 +30,13 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/pm_runtime.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/reset.h>
 
 #include <linux/usb.h>
 #include <linux/usb/otg.h>
+#include <linux/usb/of.h>
 #include <linux/usb/ulpi.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/hcd.h>
@@ -44,6 +48,7 @@
 #define DRIVER_NAME     "msm_otg"
 
 #define ULPI_IO_TIMEOUT_USEC    (10 * 1000)
+#define LINK_RESET_TIMEOUT_USEC (250 * 1000)
 
 #define USB_PHY_3P3_VOL_MIN     3050000 /* uV */
 #define USB_PHY_3P3_VOL_MAX     3300000 /* uV */
@@ -57,48 +62,38 @@
 
 #define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
 #define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
+#define USB_PHY_SUSP_DIG_VOL    500000  /* uV */
 
-static struct regulator *hsusb_3p3;
-static struct regulator *hsusb_1p8;
-static struct regulator *hsusb_vddcx;
+enum vdd_levels {
+        VDD_LEVEL_NONE = 0,
+        VDD_LEVEL_MIN,
+        VDD_LEVEL_MAX,
+};
 
 static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
 {
         int ret = 0;
 
         if (init) {
-                hsusb_vddcx = regulator_get(motg->phy.dev, "HSUSB_VDDCX");
-                if (IS_ERR(hsusb_vddcx)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb vddcx\n");
-                        return PTR_ERR(hsusb_vddcx);
-                }
-
-                ret = regulator_set_voltage(hsusb_vddcx,
-                                USB_PHY_VDD_DIG_VOL_MIN,
-                                USB_PHY_VDD_DIG_VOL_MAX);
+                ret = regulator_set_voltage(motg->vddcx,
+                                motg->vdd_levels[VDD_LEVEL_MIN],
+                                motg->vdd_levels[VDD_LEVEL_MAX]);
                 if (ret) {
-                        dev_err(motg->phy.dev, "unable to set the voltage "
-                                        "for hsusb vddcx\n");
-                        regulator_put(hsusb_vddcx);
+                        dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
                         return ret;
                 }
 
-                ret = regulator_enable(hsusb_vddcx);
-                if (ret) {
+                ret = regulator_enable(motg->vddcx);
+                if (ret)
                         dev_err(motg->phy.dev, "unable to enable hsusb vddcx\n");
-                        regulator_put(hsusb_vddcx);
-                }
         } else {
-                ret = regulator_set_voltage(hsusb_vddcx, 0,
-                        USB_PHY_VDD_DIG_VOL_MAX);
+                ret = regulator_set_voltage(motg->vddcx, 0,
+                                motg->vdd_levels[VDD_LEVEL_MAX]);
                 if (ret)
-                        dev_err(motg->phy.dev, "unable to set the voltage "
-                                        "for hsusb vddcx\n");
-                ret = regulator_disable(hsusb_vddcx);
+                        dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
+                ret = regulator_disable(motg->vddcx);
                 if (ret)
                         dev_err(motg->phy.dev, "unable to disable hsusb vddcx\n");
-
-                regulator_put(hsusb_vddcx);
         }
 
         return ret;
@@ -109,98 +104,67 @@ static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
         int rc = 0;
 
         if (init) {
-                hsusb_3p3 = regulator_get(motg->phy.dev, "HSUSB_3p3");
-                if (IS_ERR(hsusb_3p3)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb 3p3\n");
-                        return PTR_ERR(hsusb_3p3);
-                }
-
-                rc = regulator_set_voltage(hsusb_3p3, USB_PHY_3P3_VOL_MIN,
+                rc = regulator_set_voltage(motg->v3p3, USB_PHY_3P3_VOL_MIN,
                                 USB_PHY_3P3_VOL_MAX);
                 if (rc) {
-                        dev_err(motg->phy.dev, "unable to set voltage level "
-                                        "for hsusb 3p3\n");
-                        goto put_3p3;
+                        dev_err(motg->phy.dev, "Cannot set v3p3 voltage\n");
+                        goto exit;
                 }
-                rc = regulator_enable(hsusb_3p3);
+                rc = regulator_enable(motg->v3p3);
                 if (rc) {
                         dev_err(motg->phy.dev, "unable to enable the hsusb 3p3\n");
-                        goto put_3p3;
+                        goto exit;
                 }
-                hsusb_1p8 = regulator_get(motg->phy.dev, "HSUSB_1p8");
-                if (IS_ERR(hsusb_1p8)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb 1p8\n");
-                        rc = PTR_ERR(hsusb_1p8);
-                        goto disable_3p3;
-                }
-                rc = regulator_set_voltage(hsusb_1p8, USB_PHY_1P8_VOL_MIN,
+                rc = regulator_set_voltage(motg->v1p8, USB_PHY_1P8_VOL_MIN,
                                 USB_PHY_1P8_VOL_MAX);
                 if (rc) {
-                        dev_err(motg->phy.dev, "unable to set voltage level "
-                                        "for hsusb 1p8\n");
-                        goto put_1p8;
+                        dev_err(motg->phy.dev, "Cannot set v1p8 voltage\n");
+                        goto disable_3p3;
                 }
-                rc = regulator_enable(hsusb_1p8);
+                rc = regulator_enable(motg->v1p8);
                 if (rc) {
                         dev_err(motg->phy.dev, "unable to enable the hsusb 1p8\n");
-                        goto put_1p8;
+                        goto disable_3p3;
                 }
 
                 return 0;
         }
 
-        regulator_disable(hsusb_1p8);
-put_1p8:
-        regulator_put(hsusb_1p8);
+        regulator_disable(motg->v1p8);
 disable_3p3:
-        regulator_disable(hsusb_3p3);
-put_3p3:
-        regulator_put(hsusb_3p3);
+        regulator_disable(motg->v3p3);
+exit:
         return rc;
 }
 
-static int msm_hsusb_ldo_set_mode(int on)
+static int msm_hsusb_ldo_set_mode(struct msm_otg *motg, int on)
 {
         int ret = 0;
 
-        if (!hsusb_1p8 || IS_ERR(hsusb_1p8)) {
-                pr_err("%s: HSUSB_1p8 is not initialized\n", __func__);
-                return -ENODEV;
-        }
-
-        if (!hsusb_3p3 || IS_ERR(hsusb_3p3)) {
-                pr_err("%s: HSUSB_3p3 is not initialized\n", __func__);
-                return -ENODEV;
-        }
-
         if (on) {
-                ret = regulator_set_optimum_mode(hsusb_1p8,
+                ret = regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_HPM_LOAD);
                 if (ret < 0) {
-                        pr_err("%s: Unable to set HPM of the regulator "
-                                "HSUSB_1p8\n", __func__);
+                        pr_err("Could not set HPM for v1p8\n");
                         return ret;
                 }
-                ret = regulator_set_optimum_mode(hsusb_3p3,
+                ret = regulator_set_optimum_mode(motg->v3p3,
                                 USB_PHY_3P3_HPM_LOAD);
                 if (ret < 0) {
-                        pr_err("%s: Unable to set HPM of the regulator "
-                                "HSUSB_3p3\n", __func__);
-                        regulator_set_optimum_mode(hsusb_1p8,
+                        pr_err("Could not set HPM for v3p3\n");
+                        regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_LPM_LOAD);
                         return ret;
                 }
         } else {
-                ret = regulator_set_optimum_mode(hsusb_1p8,
+                ret = regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_LPM_LOAD);
                 if (ret < 0)
-                        pr_err("%s: Unable to set LPM of the regulator "
-                                "HSUSB_1p8\n", __func__);
-                ret = regulator_set_optimum_mode(hsusb_3p3,
+                        pr_err("Could not set LPM for v1p8\n");
+                ret = regulator_set_optimum_mode(motg->v3p3,
                                 USB_PHY_3P3_LPM_LOAD);
                 if (ret < 0)
-                        pr_err("%s: Unable to set LPM of the regulator "
-                                "HSUSB_3p3\n", __func__);
+                        pr_err("Could not set LPM for v3p3\n");
         }
 
         pr_debug("reg (%s)\n", on ? "HPM" : "LPM");
@@ -265,27 +229,47 @@ static struct usb_phy_io_ops msm_otg_io_ops = {
 static void ulpi_init(struct msm_otg *motg)
 {
         struct msm_otg_platform_data *pdata = motg->pdata;
-        int *seq = pdata->phy_init_seq;
+        int *seq = pdata->phy_init_seq, idx;
+        u32 addr = ULPI_EXT_VENDOR_SPECIFIC;
 
-        if (!seq)
-                return;
+        for (idx = 0; idx < pdata->phy_init_sz; idx++) {
+                if (seq[idx] == -1)
+                        continue;
 
-        while (seq[0] >= 0) {
                 dev_vdbg(motg->phy.dev, "ulpi: write 0x%02x to 0x%02x\n",
-                                seq[0], seq[1]);
-                ulpi_write(&motg->phy, seq[0], seq[1]);
-                seq += 2;
+                                seq[idx], addr + idx);
+                ulpi_write(&motg->phy, seq[idx], addr + idx);
         }
 }
 
+static int msm_phy_notify_disconnect(struct usb_phy *phy,
+                                   enum usb_device_speed speed)
+{
+        int val;
+
+        /*
+         * Put the transceiver in non-driving mode. Otherwise host
+         * may not detect soft-disconnection.
+         */
+        val = ulpi_read(phy, ULPI_FUNC_CTRL);
+        val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+        ulpi_write(phy, val, ULPI_FUNC_CTRL);
+
+        return 0;
+}
+
 static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
 {
-        int ret = 0;
+        int ret;
 
-        if (!motg->pdata->link_clk_reset)
-                return ret;
+        if (motg->pdata->link_clk_reset)
+                ret = motg->pdata->link_clk_reset(motg->clk, assert);
+        else if (assert)
+                ret = reset_control_assert(motg->link_rst);
+        else
+                ret = reset_control_deassert(motg->link_rst);
 
-        ret = motg->pdata->link_clk_reset(motg->clk, assert);
         if (ret)
                 dev_err(motg->phy.dev, "usb link clk reset %s failed\n",
                         assert ? "assert" : "deassert");
@@ -295,111 +279,150 @@ static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
 
 static int msm_otg_phy_clk_reset(struct msm_otg *motg)
 {
-        int ret = 0;
+        int ret;
 
-        if (!motg->pdata->phy_clk_reset)
-                return ret;
+        if (motg->pdata->phy_clk_reset)
+                ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
+        else
+                ret = reset_control_reset(motg->phy_rst);
 
-        ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
         if (ret)
                 dev_err(motg->phy.dev, "usb phy clk reset failed\n");
 
         return ret;
 }
 
-static int msm_otg_phy_reset(struct msm_otg *motg)
+static int msm_link_reset(struct msm_otg *motg)
 {
         u32 val;
         int ret;
-        int retries;
 
         ret = msm_otg_link_clk_reset(motg, 1);
         if (ret)
                 return ret;
-        ret = msm_otg_phy_clk_reset(motg);
-        if (ret)
-                return ret;
+
+        /* wait for 1ms delay as suggested in HPG. */
+        usleep_range(1000, 1200);
+
         ret = msm_otg_link_clk_reset(motg, 0);
         if (ret)
                 return ret;
 
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
+
+        /* put transceiver in serial mode as part of reset */
         val = readl(USB_PORTSC) & ~PORTSC_PTS_MASK;
-        writel(val | PORTSC_PTS_ULPI, USB_PORTSC);
+        writel(val | PORTSC_PTS_SERIAL, USB_PORTSC);
 
-        for (retries = 3; retries > 0; retries--) {
-                ret = ulpi_write(&motg->phy, ULPI_FUNC_CTRL_SUSPENDM,
-                                ULPI_CLR(ULPI_FUNC_CTRL));
-                if (!ret)
-                        break;
-                ret = msm_otg_phy_clk_reset(motg);
-                if (ret)
-                        return ret;
-        }
-        if (!retries)
-                return -ETIMEDOUT;
+        return 0;
+}
 
-        /* This reset calibrates the phy, if the above write succeeded */
-        ret = msm_otg_phy_clk_reset(motg);
-        if (ret)
-                return ret;
+static int msm_otg_reset(struct usb_phy *phy)
+{
+        struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
+        int cnt = 0;
 
-        for (retries = 3; retries > 0; retries--) {
-                ret = ulpi_read(&motg->phy, ULPI_DEBUG);
-                if (ret != -ETIMEDOUT)
+        writel(USBCMD_RESET, USB_USBCMD);
+        while (cnt < LINK_RESET_TIMEOUT_USEC) {
+                if (!(readl(USB_USBCMD) & USBCMD_RESET))
                         break;
-                ret = msm_otg_phy_clk_reset(motg);
-                if (ret)
-                        return ret;
+                udelay(1);
+                cnt++;
         }
-        if (!retries)
+        if (cnt >= LINK_RESET_TIMEOUT_USEC)
                 return -ETIMEDOUT;
 
-        dev_info(motg->phy.dev, "phy_reset: success\n");
+        /* select ULPI phy and clear other status/control bits in PORTSC */
+        writel(PORTSC_PTS_ULPI, USB_PORTSC);
+
+        writel(0x0, USB_AHBBURST);
+        writel(0x08, USB_AHBMODE);
+
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
         return 0;
 }
 
-#define LINK_RESET_TIMEOUT_USEC         (250 * 1000)
-static int msm_otg_reset(struct usb_phy *phy)
+static void msm_phy_reset(struct msm_otg *motg)
+{
+        void __iomem *addr;
+
+        if (motg->pdata->phy_type != SNPS_28NM_INTEGRATED_PHY) {
+                msm_otg_phy_clk_reset(motg);
+                return;
+        }
+
+        addr = USB_PHY_CTRL;
+        if (motg->phy_number)
+                addr = USB_PHY_CTRL2;
+
+        /* Assert USB PHY_POR */
+        writel(readl(addr) | PHY_POR_ASSERT, addr);
+
+        /*
+         * wait for minimum 10 microseconds as suggested in HPG.
+         * Use a slightly larger value since the exact value didn't
+         * work 100% of the time.
+         */
+        udelay(12);
+
+        /* Deassert USB PHY_POR */
+        writel(readl(addr) & ~PHY_POR_ASSERT, addr);
+}
+
+static int msm_usb_reset(struct usb_phy *phy)
 {
         struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
-        struct msm_otg_platform_data *pdata = motg->pdata;
-        int cnt = 0;
         int ret;
-        u32 val = 0;
-        u32 ulpi_val = 0;
 
-        ret = msm_otg_phy_reset(motg);
+        if (!IS_ERR(motg->core_clk))
+                clk_prepare_enable(motg->core_clk);
+
+        ret = msm_link_reset(motg);
         if (ret) {
                 dev_err(phy->dev, "phy_reset failed\n");
                 return ret;
         }
 
-        ulpi_init(motg);
-
-        writel(USBCMD_RESET, USB_USBCMD);
-        while (cnt < LINK_RESET_TIMEOUT_USEC) {
-                if (!(readl(USB_USBCMD) & USBCMD_RESET))
-                        break;
-                udelay(1);
-                cnt++;
+        ret = msm_otg_reset(&motg->phy);
+        if (ret) {
+                dev_err(phy->dev, "link reset failed\n");
+                return ret;
         }
-        if (cnt >= LINK_RESET_TIMEOUT_USEC)
-                return -ETIMEDOUT;
-
-        /* select ULPI phy */
-        writel(0x80000000, USB_PORTSC);
 
         msleep(100);
 
-        writel(0x0, USB_AHBBURST);
-        writel(0x00, USB_AHBMODE);
+        /* Reset USB PHY after performing USB Link RESET */
+        msm_phy_reset(motg);
+
+        if (!IS_ERR(motg->core_clk))
+                clk_disable_unprepare(motg->core_clk);
+
+        return 0;
+}
+
+static int msm_phy_init(struct usb_phy *phy)
+{
+        struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        u32 val, ulpi_val = 0;
+
+        /* Program USB PHY Override registers. */
+        ulpi_init(motg);
+
+        /*
+         * It is recommended in HPG to reset USB PHY after programming
+         * USB PHY Override registers.
+         */
+        msm_phy_reset(motg);
 
         if (pdata->otg_control == OTG_PHY_CONTROL) {
                 val = readl(USB_OTGSC);
-                if (pdata->mode == USB_OTG) {
+                if (pdata->mode == USB_DR_MODE_OTG) {
                         ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
                         val |= OTGSC_IDIE | OTGSC_BSVIE;
-                } else if (pdata->mode == USB_PERIPHERAL) {
+                } else if (pdata->mode == USB_DR_MODE_PERIPHERAL) {
                         ulpi_val = ULPI_INT_SESS_VALID;
                         val |= OTGSC_BSVIE;
                 }
@@ -408,6 +431,9 @@ static int msm_otg_reset(struct usb_phy *phy)
                 ulpi_write(phy, ulpi_val, ULPI_USB_INT_EN_FALL);
         }
 
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
+
         return 0;
 }
 
@@ -416,22 +442,20 @@ static int msm_otg_reset(struct usb_phy *phy)
 
 #ifdef CONFIG_PM
 
-#define USB_PHY_SUSP_DIG_VOL  500000
-static int msm_hsusb_config_vddcx(int high)
+static int msm_hsusb_config_vddcx(struct msm_otg *motg, int high)
 {
-        int max_vol = USB_PHY_VDD_DIG_VOL_MAX;
+        int max_vol = motg->vdd_levels[VDD_LEVEL_MAX];
         int min_vol;
         int ret;
 
         if (high)
-                min_vol = USB_PHY_VDD_DIG_VOL_MIN;
+                min_vol = motg->vdd_levels[VDD_LEVEL_MIN];
         else
-                min_vol = USB_PHY_SUSP_DIG_VOL;
+                min_vol = motg->vdd_levels[VDD_LEVEL_NONE];
 
-        ret = regulator_set_voltage(hsusb_vddcx, min_vol, max_vol);
+        ret = regulator_set_voltage(motg->vddcx, min_vol, max_vol);
         if (ret) {
-                pr_err("%s: unable to set the voltage for regulator "
-                        "HSUSB_VDDCX\n", __func__);
+                pr_err("Cannot set vddcx voltage\n");
                 return ret;
         }
 
@@ -445,6 +469,7 @@ static int msm_otg_suspend(struct msm_otg *motg)
         struct usb_phy *phy = &motg->phy;
         struct usb_bus *bus = phy->otg->host;
         struct msm_otg_platform_data *pdata = motg->pdata;
+        void __iomem *addr;
         int cnt = 0;
 
         if (atomic_read(&motg->in_lpm))
@@ -504,22 +529,23 @@ static int msm_otg_suspend(struct msm_otg *motg)
          */
         writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
 
+        addr = USB_PHY_CTRL;
+        if (motg->phy_number)
+                addr = USB_PHY_CTRL2;
+
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL)
-                writel(readl(USB_PHY_CTRL) | PHY_RETEN, USB_PHY_CTRL);
+                writel(readl(addr) | PHY_RETEN, addr);
 
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_disable_unprepare(motg->core_clk);
 
-        if (!IS_ERR(motg->pclk_src))
-                clk_disable_unprepare(motg->pclk_src);
-
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL) {
-                msm_hsusb_ldo_set_mode(0);
-                msm_hsusb_config_vddcx(0);
+                msm_hsusb_ldo_set_mode(motg, 0);
+                msm_hsusb_config_vddcx(motg, 0);
         }
 
         if (device_may_wakeup(phy->dev))
@@ -539,25 +565,28 @@ static int msm_otg_resume(struct msm_otg *motg)
 {
         struct usb_phy *phy = &motg->phy;
         struct usb_bus *bus = phy->otg->host;
+        void __iomem *addr;
         int cnt = 0;
         unsigned temp;
 
         if (!atomic_read(&motg->in_lpm))
                 return 0;
 
-        if (!IS_ERR(motg->pclk_src))
-                clk_prepare_enable(motg->pclk_src);
-
         clk_prepare_enable(motg->pclk);
         clk_prepare_enable(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_prepare_enable(motg->core_clk);
 
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL) {
-                msm_hsusb_ldo_set_mode(1);
-                msm_hsusb_config_vddcx(1);
-                writel(readl(USB_PHY_CTRL) & ~PHY_RETEN, USB_PHY_CTRL);
+
+                addr = USB_PHY_CTRL;
+                if (motg->phy_number)
+                        addr = USB_PHY_CTRL2;
+
+                msm_hsusb_ldo_set_mode(motg, 1);
+                msm_hsusb_config_vddcx(motg, 1);
+                writel(readl(addr) & ~PHY_RETEN, addr);
         }
 
         temp = readl(USB_USBCMD);
@@ -586,8 +615,7 @@ static int msm_otg_resume(struct msm_otg *motg)
                  * PHY. USB state can not be restored. Re-insertion
                  * of USB cable is the only way to get USB working.
                  */
-                dev_err(phy->dev, "Unable to resume USB."
-                                "Re-plugin the cable\n");
+                dev_err(phy->dev, "Unable to resume USB. Re-plugin the cable\n");
                 msm_otg_reset(phy);
         }
 
@@ -687,7 +715,7 @@ static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
          * Fail host registration if this board can support
          * only peripheral configuration.
          */
-        if (motg->pdata->mode == USB_PERIPHERAL) {
+        if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL) {
                 dev_info(otg->phy->dev, "Host mode is not supported\n");
                 return -ENODEV;
         }
@@ -716,7 +744,7 @@ static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
          * Kick the state machine work, if peripheral is not supported
          * or peripheral is already registered with us.
          */
-        if (motg->pdata->mode == USB_HOST || otg->gadget) {
+        if (motg->pdata->mode == USB_DR_MODE_HOST || otg->gadget) {
                 pm_runtime_get_sync(otg->phy->dev);
                 schedule_work(&motg->sm_work);
         }
@@ -760,7 +788,7 @@ static int msm_otg_set_peripheral(struct usb_otg *otg,
          * Fail peripheral registration if this board can support
          * only host configuration.
          */
-        if (motg->pdata->mode == USB_HOST) {
+        if (motg->pdata->mode == USB_DR_MODE_HOST) {
                 dev_info(otg->phy->dev, "Peripheral mode is not supported\n");
                 return -ENODEV;
         }
@@ -785,7 +813,7 @@ static int msm_otg_set_peripheral(struct usb_otg *otg,
          * Kick the state machine work, if host is not supported
          * or host is already registered with us.
          */
-        if (motg->pdata->mode == USB_PERIPHERAL || otg->host) {
+        if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL || otg->host) {
                 pm_runtime_get_sync(otg->phy->dev);
                 schedule_work(&motg->sm_work);
         }
@@ -1106,7 +1134,7 @@ static void msm_otg_init_sm(struct msm_otg *motg)
         u32 otgsc = readl(USB_OTGSC);
 
         switch (pdata->mode) {
-        case USB_OTG:
+        case USB_DR_MODE_OTG:
                 if (pdata->otg_control == OTG_PHY_CONTROL) {
                         if (otgsc & OTGSC_ID)
                                 set_bit(ID, &motg->inputs);
@@ -1118,21 +1146,14 @@ static void msm_otg_init_sm(struct msm_otg *motg)
                         else
                                 clear_bit(B_SESS_VLD, &motg->inputs);
                 } else if (pdata->otg_control == OTG_USER_CONTROL) {
-                        if (pdata->default_mode == USB_HOST) {
-                                clear_bit(ID, &motg->inputs);
-                        } else if (pdata->default_mode == USB_PERIPHERAL) {
-                                set_bit(ID, &motg->inputs);
-                                set_bit(B_SESS_VLD, &motg->inputs);
-                        } else {
                                 set_bit(ID, &motg->inputs);
                                 clear_bit(B_SESS_VLD, &motg->inputs);
-                        }
                 }
                 break;
-        case USB_HOST:
+        case USB_DR_MODE_HOST:
                 clear_bit(ID, &motg->inputs);
                 break;
-        case USB_PERIPHERAL:
+        case USB_DR_MODE_PERIPHERAL:
                 set_bit(ID, &motg->inputs);
                 if (otgsc & OTGSC_BSV)
                         set_bit(B_SESS_VLD, &motg->inputs);
@@ -1282,13 +1303,13 @@ static int msm_otg_mode_show(struct seq_file *s, void *unused)
 
         switch (otg->phy->state) {
         case OTG_STATE_A_HOST:
-                seq_printf(s, "host\n");
+                seq_puts(s, "host\n");
                 break;
         case OTG_STATE_B_PERIPHERAL:
-                seq_printf(s, "peripheral\n");
+                seq_puts(s, "peripheral\n");
                 break;
         default:
-                seq_printf(s, "none\n");
+                seq_puts(s, "none\n");
                 break;
         }
 
@@ -1308,7 +1329,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
         char buf[16];
         struct usb_otg *otg = motg->phy.otg;
         int status = count;
-        enum usb_mode_type req_mode;
+        enum usb_dr_mode req_mode;
 
         memset(buf, 0x00, sizeof(buf));
 
@@ -1318,18 +1339,18 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
         }
 
         if (!strncmp(buf, "host", 4)) {
-                req_mode = USB_HOST;
+                req_mode = USB_DR_MODE_HOST;
         } else if (!strncmp(buf, "peripheral", 10)) {
-                req_mode = USB_PERIPHERAL;
+                req_mode = USB_DR_MODE_PERIPHERAL;
         } else if (!strncmp(buf, "none", 4)) {
-                req_mode = USB_NONE;
+                req_mode = USB_DR_MODE_UNKNOWN;
         } else {
                 status = -EINVAL;
                 goto out;
         }
 
         switch (req_mode) {
-        case USB_NONE:
+        case USB_DR_MODE_UNKNOWN:
                 switch (otg->phy->state) {
                 case OTG_STATE_A_HOST:
                 case OTG_STATE_B_PERIPHERAL:
@@ -1340,7 +1361,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
                         goto out;
                 }
                 break;
-        case USB_PERIPHERAL:
+        case USB_DR_MODE_PERIPHERAL:
                 switch (otg->phy->state) {
                 case OTG_STATE_B_IDLE:
                 case OTG_STATE_A_HOST:
@@ -1351,7 +1372,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
                         goto out;
                 }
                 break;
-        case USB_HOST:
+        case USB_DR_MODE_HOST:
                 switch (otg->phy->state) {
                 case OTG_STATE_B_IDLE:
                 case OTG_STATE_B_PERIPHERAL:
@@ -1406,74 +1427,154 @@ static void msm_otg_debugfs_cleanup(void)
         debugfs_remove(msm_otg_dbg_root);
 }
 
-static int __init msm_otg_probe(struct platform_device *pdev)
+static struct of_device_id msm_otg_dt_match[] = {
+        {
+                .compatible = "qcom,usb-otg-ci",
+                .data = (void *) CI_45NM_INTEGRATED_PHY
+        },
+        {
+                .compatible = "qcom,usb-otg-snps",
+                .data = (void *) SNPS_28NM_INTEGRATED_PHY
+        },
+        { }
+};
+MODULE_DEVICE_TABLE(of, msm_otg_dt_match);
+
+static int msm_otg_read_dt(struct platform_device *pdev, struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata;
+        const struct of_device_id *id;
+        struct device_node *node = pdev->dev.of_node;
+        struct property *prop;
+        int len, ret, words;
+        u32 val, tmp[3];
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        motg->pdata = pdata;
+
+        id = of_match_device(msm_otg_dt_match, &pdev->dev);
+        pdata->phy_type = (enum msm_usb_phy_type) id->data;
+
+        motg->link_rst = devm_reset_control_get(&pdev->dev, "link");
+        if (IS_ERR(motg->link_rst))
+                return PTR_ERR(motg->link_rst);
+
+        motg->phy_rst = devm_reset_control_get(&pdev->dev, "phy");
+        if (IS_ERR(motg->phy_rst))
+                return PTR_ERR(motg->phy_rst);
+
+        pdata->mode = of_usb_get_dr_mode(node);
+        if (pdata->mode == USB_DR_MODE_UNKNOWN)
+                pdata->mode = USB_DR_MODE_OTG;
+
+        pdata->otg_control = OTG_PHY_CONTROL;
+        if (!of_property_read_u32(node, "qcom,otg-control", &val))
+                if (val == OTG_PMIC_CONTROL)
+                        pdata->otg_control = val;
+
+        if (!of_property_read_u32(node, "qcom,phy-num", &val) && val < 2)
+                motg->phy_number = val;
+
+        motg->vdd_levels[VDD_LEVEL_NONE] = USB_PHY_SUSP_DIG_VOL;
+        motg->vdd_levels[VDD_LEVEL_MIN] = USB_PHY_VDD_DIG_VOL_MIN;
+        motg->vdd_levels[VDD_LEVEL_MAX] = USB_PHY_VDD_DIG_VOL_MAX;
+
+        if (of_get_property(node, "qcom,vdd-levels", &len) &&
+            len == sizeof(tmp)) {
+                of_property_read_u32_array(node, "qcom,vdd-levels",
+                                           tmp, len / sizeof(*tmp));
+                motg->vdd_levels[VDD_LEVEL_NONE] = tmp[VDD_LEVEL_NONE];
+                motg->vdd_levels[VDD_LEVEL_MIN] = tmp[VDD_LEVEL_MIN];
+                motg->vdd_levels[VDD_LEVEL_MAX] = tmp[VDD_LEVEL_MAX];
+        }
+
+        prop = of_find_property(node, "qcom,phy-init-sequence", &len);
+        if (!prop || !len)
+                return 0;
+
+        words = len / sizeof(u32);
+
+        if (words >= ULPI_EXT_VENDOR_SPECIFIC) {
+                dev_warn(&pdev->dev, "Too big PHY init sequence %d\n", words);
+                return 0;
+        }
+
+        pdata->phy_init_seq = devm_kzalloc(&pdev->dev, len, GFP_KERNEL);
+        if (!pdata->phy_init_seq) {
+                dev_warn(&pdev->dev, "No space for PHY init sequence\n");
+                return 0;
+        }
+
+        ret = of_property_read_u32_array(node, "qcom,phy-init-sequence",
+                                         pdata->phy_init_seq, words);
+        if (!ret)
+                pdata->phy_init_sz = words;
+
+        return 0;
+}
+
+static int msm_otg_probe(struct platform_device *pdev)
 {
+        struct regulator_bulk_data regs[3];
         int ret = 0;
+        struct device_node *np = pdev->dev.of_node;
+        struct msm_otg_platform_data *pdata;
         struct resource *res;
         struct msm_otg *motg;
         struct usb_phy *phy;
+        void __iomem *phy_select;
 
-        dev_info(&pdev->dev, "msm_otg probe\n");
-        if (!dev_get_platdata(&pdev->dev)) {
-                dev_err(&pdev->dev, "No platform data given. Bailing out\n");
-                return -ENODEV;
-        }
-
-        motg = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);
+        motg = devm_kzalloc(&pdev->dev, sizeof(struct msm_otg), GFP_KERNEL);
         if (!motg) {
                 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
                 return -ENOMEM;
         }
 
-        motg->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
+        pdata = dev_get_platdata(&pdev->dev);
+        if (!pdata) {
+                if (!np)
+                        return -ENXIO;
+                ret = msm_otg_read_dt(pdev, motg);
+                if (ret)
+                        return ret;
+        }
+
+        motg->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg),
+                                     GFP_KERNEL);
         if (!motg->phy.otg) {
                 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
-                ret = -ENOMEM;
-                goto free_motg;
+                return -ENOMEM;
         }
 
-        motg->pdata = dev_get_platdata(&pdev->dev);
         phy = &motg->phy;
         phy->dev = &pdev->dev;
 
-        motg->phy_reset_clk = clk_get(&pdev->dev, "usb_phy_clk");
+        motg->phy_reset_clk = devm_clk_get(&pdev->dev,
+                                           np ? "phy" : "usb_phy_clk");
         if (IS_ERR(motg->phy_reset_clk)) {
                 dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
-                ret = PTR_ERR(motg->phy_reset_clk);
-                goto free_motg;
+                return PTR_ERR(motg->phy_reset_clk);
         }
 
-        motg->clk = clk_get(&pdev->dev, "usb_hs_clk");
+        motg->clk = devm_clk_get(&pdev->dev, np ? "core" : "usb_hs_clk");
         if (IS_ERR(motg->clk)) {
                 dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
-                ret = PTR_ERR(motg->clk);
-                goto put_phy_reset_clk;
+                return PTR_ERR(motg->clk);
         }
-        clk_set_rate(motg->clk, 60000000);
 
         /*
          * If USB Core is running its protocol engine based on CORE CLK,
          * CORE CLK  must be running at >55Mhz for correct HSUSB
          * operation and USB core cannot tolerate frequency changes on
-         * CORE CLK. For such USB cores, vote for maximum clk frequency
-         * on pclk source
+         * CORE CLK.
          */
-         if (motg->pdata->pclk_src_name) {
-                motg->pclk_src = clk_get(&pdev->dev,
-                        motg->pdata->pclk_src_name);
-                if (IS_ERR(motg->pclk_src))
-                        goto put_clk;
-                clk_set_rate(motg->pclk_src, INT_MAX);
-                clk_prepare_enable(motg->pclk_src);
-        } else
-                motg->pclk_src = ERR_PTR(-ENOENT);
-
-
-        motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
+        motg->pclk = devm_clk_get(&pdev->dev, np ? "iface" : "usb_hs_pclk");
         if (IS_ERR(motg->pclk)) {
                 dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
-                ret = PTR_ERR(motg->pclk);
-                goto put_pclk_src;
+                return PTR_ERR(motg->pclk);
         }
 
         /*
@@ -1481,69 +1582,90 @@ static int __init msm_otg_probe(struct platform_device *pdev)
          * clock is introduced to remove the dependency on AXI
          * bus frequency.
          */
-        motg->core_clk = clk_get(&pdev->dev, "usb_hs_core_clk");
-        if (IS_ERR(motg->core_clk))
-                motg->core_clk = NULL;
+        motg->core_clk = devm_clk_get(&pdev->dev,
+                                      np ? "alt_core" : "usb_hs_core_clk");
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to get platform resource mem\n");
-                ret = -ENODEV;
-                goto put_core_clk;
-        }
+        if (!res)
+                return -EINVAL;
+        motg->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
+        if (!motg->regs)
+                return -ENOMEM;
 
-        motg->regs = ioremap(res->start, resource_size(res));
-        if (!motg->regs) {
-                dev_err(&pdev->dev, "ioremap failed\n");
-                ret = -ENOMEM;
-                goto put_core_clk;
+        /*
+         * NOTE: The PHYs can be multiplexed between the chipidea controller
+         * and the dwc3 controller, using a single bit. It is important that
+         * the dwc3 driver does not set this bit in an incompatible way.
+         */
+        if (motg->phy_number) {
+                phy_select = devm_ioremap_nocache(&pdev->dev, USB2_PHY_SEL, 4);
+                if (IS_ERR(phy_select))
+                        return PTR_ERR(phy_select);
+                /* Enable second PHY with the OTG port */
+                writel(0x1, phy_select);
         }
+
         dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);
 
         motg->irq = platform_get_irq(pdev, 0);
-        if (!motg->irq) {
+        if (motg->irq < 0) {
                 dev_err(&pdev->dev, "platform_get_irq failed\n");
-                ret = -ENODEV;
-                goto free_regs;
+                return motg->irq;
         }
 
+        regs[0].supply = "vddcx";
+        regs[1].supply = "v3p3";
+        regs[2].supply = "v1p8";
+
+        ret = devm_regulator_bulk_get(motg->phy.dev, ARRAY_SIZE(regs), regs);
+        if (ret)
+                return ret;
+
+        motg->vddcx = regs[0].consumer;
+        motg->v3p3  = regs[1].consumer;
+        motg->v1p8  = regs[2].consumer;
+
+        clk_set_rate(motg->clk, 60000000);
+
         clk_prepare_enable(motg->clk);
         clk_prepare_enable(motg->pclk);
 
+        if (!IS_ERR(motg->core_clk))
+                clk_prepare_enable(motg->core_clk);
+
         ret = msm_hsusb_init_vddcx(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
-                goto free_regs;
+                goto disable_clks;
         }
 
         ret = msm_hsusb_ldo_init(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
-                goto vddcx_exit;
+                goto disable_vddcx;
         }
-        ret = msm_hsusb_ldo_set_mode(1);
+        ret = msm_hsusb_ldo_set_mode(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vreg enable failed\n");
-                goto ldo_exit;
+                goto disable_ldo;
         }
 
-        if (motg->core_clk)
-                clk_prepare_enable(motg->core_clk);
-
         writel(0, USB_USBINTR);
         writel(0, USB_OTGSC);
 
         INIT_WORK(&motg->sm_work, msm_otg_sm_work);
         INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
-        ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,
+        ret = devm_request_irq(&pdev->dev, motg->irq, msm_otg_irq, IRQF_SHARED,
                                         "msm_otg", motg);
         if (ret) {
                 dev_err(&pdev->dev, "request irq failed\n");
-                goto disable_clks;
+                goto disable_ldo;
         }
 
-        phy->init = msm_otg_reset;
+        phy->init = msm_phy_init;
         phy->set_power = msm_otg_set_power;
+        phy->notify_disconnect = msm_phy_notify_disconnect;
+        phy->type = USB_PHY_TYPE_USB2;
 
         phy->io_ops = &msm_otg_io_ops;
 
@@ -1551,54 +1673,38 @@ static int __init msm_otg_probe(struct platform_device *pdev)
         phy->otg->set_host = msm_otg_set_host;
         phy->otg->set_peripheral = msm_otg_set_peripheral;
 
-        ret = usb_add_phy(&motg->phy, USB_PHY_TYPE_USB2);
+        msm_usb_reset(phy);
+
+        ret = usb_add_phy_dev(&motg->phy);
         if (ret) {
                 dev_err(&pdev->dev, "usb_add_phy failed\n");
-                goto free_irq;
+                goto disable_ldo;
         }
 
         platform_set_drvdata(pdev, motg);
         device_init_wakeup(&pdev->dev, 1);
 
-        if (motg->pdata->mode == USB_OTG &&
-                        motg->pdata->otg_control == OTG_USER_CONTROL) {
+        if (motg->pdata->mode == USB_DR_MODE_OTG &&
+                motg->pdata->otg_control == OTG_USER_CONTROL) {
                 ret = msm_otg_debugfs_init(motg);
                 if (ret)
-                        dev_dbg(&pdev->dev, "mode debugfs file is"
-                                        "not available\n");
+                        dev_dbg(&pdev->dev, "Can not create mode change file\n");
         }
 
         pm_runtime_set_active(&pdev->dev);
         pm_runtime_enable(&pdev->dev);
 
         return 0;
-free_irq:
-        free_irq(motg->irq, motg);
+
+disable_ldo:
+        msm_hsusb_ldo_init(motg, 0);
+disable_vddcx:
+        msm_hsusb_init_vddcx(motg, 0);
 disable_clks:
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-ldo_exit:
-        msm_hsusb_ldo_init(motg, 0);
-vddcx_exit:
-        msm_hsusb_init_vddcx(motg, 0);
-free_regs:
-        iounmap(motg->regs);
-put_core_clk:
-        if (motg->core_clk)
-                clk_put(motg->core_clk);
-        clk_put(motg->pclk);
-put_pclk_src:
-        if (!IS_ERR(motg->pclk_src)) {
-                clk_disable_unprepare(motg->pclk_src);
-                clk_put(motg->pclk_src);
-        }
-put_clk:
-        clk_put(motg->clk);
-put_phy_reset_clk:
-        clk_put(motg->phy_reset_clk);
-free_motg:
-        kfree(motg->phy.otg);
-        kfree(motg);
+        if (!IS_ERR(motg->core_clk))
+                clk_disable_unprepare(motg->core_clk);
         return ret;
 }
 
@@ -1621,7 +1727,7 @@ static int msm_otg_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
 
         usb_remove_phy(phy);
-        free_irq(motg->irq, motg);
+        disable_irq(motg->irq);
 
         /*
          * Put PHY in low power mode.
@@ -1641,26 +1747,12 @@ static int msm_otg_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_disable_unprepare(motg->core_clk);
-        if (!IS_ERR(motg->pclk_src)) {
-                clk_disable_unprepare(motg->pclk_src);
-                clk_put(motg->pclk_src);
-        }
         msm_hsusb_ldo_init(motg, 0);
 
-        iounmap(motg->regs);
         pm_runtime_set_suspended(&pdev->dev);
 
-        clk_put(motg->phy_reset_clk);
-        clk_put(motg->pclk);
-        clk_put(motg->clk);
-        if (motg->core_clk)
-                clk_put(motg->core_clk);
-
-        kfree(motg->phy.otg);
-        kfree(motg);
-
         return 0;
 }
 
@@ -1740,15 +1832,17 @@ static const struct dev_pm_ops msm_otg_dev_pm_ops = {
 };
 
 static struct platform_driver msm_otg_driver = {
+        .probe = msm_otg_probe,
         .remove = msm_otg_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
                 .pm = &msm_otg_dev_pm_ops,
+                .of_match_table = msm_otg_dt_match,
         },
 };
 
-module_platform_driver_probe(msm_otg_driver, msm_otg_probe);
+module_platform_driver(msm_otg_driver);
 
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("MSM USB transceiver driver");
diff --git a/drivers/usb/phy/phy-mv-u3d-usb.c b/drivers/usb/phy/phy-mv-u3d-usb.c
deleted file mode 100644
index d317903022bf..000000000000
--- a/drivers/usb/phy/phy-mv-u3d-usb.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- */
-
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/usb/otg.h>
-#include <linux/platform_data/mv_usb.h>
-
-#include "phy-mv-u3d-usb.h"
-
-/*
- * struct mv_u3d_phy - transceiver driver state
- * @phy: transceiver structure
- * @dev: The parent device supplied to the probe function
- * @clk: usb phy clock
- * @base: usb phy register memory base
- */
-struct mv_u3d_phy {
-        struct usb_phy  phy;
-        struct mv_usb_platform_data *plat;
-        struct device   *dev;
-        struct clk      *clk;
-        void __iomem    *base;
-};
-
-static u32 mv_u3d_phy_read(void __iomem *base, u32 reg)
-{
-        void __iomem *addr, *data;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        return readl_relaxed(data);
-}
-
-static void mv_u3d_phy_set(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-        u32 tmp;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        tmp = readl_relaxed(data);
-        tmp |= value;
-        writel_relaxed(tmp, data);
-}
-
-static void mv_u3d_phy_clear(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-        u32 tmp;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        tmp = readl_relaxed(data);
-        tmp &= ~value;
-        writel_relaxed(tmp, data);
-}
-
-static void mv_u3d_phy_write(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        writel_relaxed(value, data);
-}
-
-static void mv_u3d_phy_shutdown(struct usb_phy *phy)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        void __iomem *base;
-        u32 val;
-
-        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
-        base = mv_u3d_phy->base;
-
-        /* Power down Reference Analog current, bit 15
-         * Power down PLL, bit 14
-         * Power down Receiver, bit 13
-         * Power down Transmitter, bit 12
-         * of USB3_POWER_PLL_CONTROL register
-         */
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_PU);
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-
-        if (mv_u3d_phy->clk)
-                clk_disable(mv_u3d_phy->clk);
-}
-
-static int mv_u3d_phy_init(struct usb_phy *phy)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        void __iomem *base;
-        u32 val, count;
-
-        /* enable usb3 phy */
-        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
-
-        if (mv_u3d_phy->clk)
-                clk_enable(mv_u3d_phy->clk);
-
-        base = mv_u3d_phy->base;
-
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_PU_MASK);
-        val |= 0xF << USB3_POWER_PLL_CONTROL_PU_SHIFT;
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-        udelay(100);
-
-        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
-                        USB3_RESET_CONTROL_RESET_PIPE);
-        udelay(100);
-
-        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
-                        USB3_RESET_CONTROL_RESET_PIPE
-                        | USB3_RESET_CONTROL_RESET_PHY);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK
-                | USB3_POWER_PLL_CONTROL_PHY_MODE_MASK);
-        val |=  (USB3_PLL_25MHZ << USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT)
-                | (0x5 << USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT);
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-        udelay(100);
-
-        mv_u3d_phy_clear(base, USB3_KVCO_CALI_CONTROL,
-                USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_SQUELCH_FFE);
-        val &= ~(USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK
-                | USB3_SQUELCH_FFE_FFE_RES_SEL_MASK
-                | USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK);
-        val |= ((0xD << USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT)
-                | (0x7 << USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT)
-                | (0x8 << USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT));
-        mv_u3d_phy_write(base, USB3_SQUELCH_FFE, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN1_SET0);
-        val &= ~USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK;
-        val |= 1 << USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT;
-        mv_u3d_phy_write(base, USB3_GEN1_SET0, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN2_SET0);
-        val &= ~(USB3_GEN2_SET0_G2_TX_AMP_MASK
-                | USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK
-                | USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK);
-        val |= ((0x14 << USB3_GEN2_SET0_G2_TX_AMP_SHIFT)
-                | (1 << USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT)
-                | (0xA << USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT)
-                | (1 << USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT));
-        mv_u3d_phy_write(base, USB3_GEN2_SET0, val);
-        udelay(100);
-
-        mv_u3d_phy_read(base, USB3_TX_EMPPH);
-        val &= ~(USB3_TX_EMPPH_AMP_MASK
-                | USB3_TX_EMPPH_EN_MASK
-                | USB3_TX_EMPPH_AMP_FORCE_MASK
-                | USB3_TX_EMPPH_PAR1_MASK
-                | USB3_TX_EMPPH_PAR2_MASK);
-        val |= ((0xB << USB3_TX_EMPPH_AMP_SHIFT)
-                | (1 << USB3_TX_EMPPH_EN_SHIFT)
-                | (1 << USB3_TX_EMPPH_AMP_FORCE_SHIFT)
-                | (0x1C << USB3_TX_EMPPH_PAR1_SHIFT)
-                | (1 << USB3_TX_EMPPH_PAR2_SHIFT));
-
-        mv_u3d_phy_write(base, USB3_TX_EMPPH, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN2_SET1);
-        val &= ~(USB3_GEN2_SET1_G2_RX_SELMUPI_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUPF_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUFI_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUFF_MASK);
-        val |= ((1 << USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT));
-        mv_u3d_phy_write(base, USB3_GEN2_SET1, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_DIGITAL_LOOPBACK_EN);
-        val &= ~USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK;
-        val |= 1 << USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT;
-        mv_u3d_phy_write(base, USB3_DIGITAL_LOOPBACK_EN, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_TX_SSC);
-        val &= ~USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK;
-        val |= 0xC << USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT;
-        mv_u3d_phy_write(base, USB3_IMPEDANCE_TX_SSC, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_CALI_CTRL);
-        val &= ~USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK;
-        val |= 0x4 << USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT;
-        mv_u3d_phy_write(base, USB3_IMPEDANCE_CALI_CTRL, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_PHY_ISOLATION_MODE);
-        val &= ~(USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK
-                | USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK
-                | USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK);
-        val |= ((1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT)
-                | (1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT));
-        mv_u3d_phy_write(base, USB3_PHY_ISOLATION_MODE, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_TXDETRX);
-        val &= ~(USB3_TXDETRX_VTHSEL_MASK);
-        val |= 0x1 << USB3_TXDETRX_VTHSEL_SHIFT;
-        mv_u3d_phy_write(base, USB3_TXDETRX, val);
-        udelay(100);
-
-        dev_dbg(mv_u3d_phy->dev, "start calibration\n");
-
-calstart:
-        /* Perform Manual Calibration */
-        mv_u3d_phy_set(base, USB3_KVCO_CALI_CONTROL,
-                1 << USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT);
-
-        mdelay(1);
-
-        count = 0;
-        while (1) {
-                val = mv_u3d_phy_read(base, USB3_KVCO_CALI_CONTROL);
-                if (val & (1 << USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT))
-                        break;
-                else if (count > 50) {
-                        dev_dbg(mv_u3d_phy->dev, "calibration failure, retry...\n");
-                        goto calstart;
-                }
-                count++;
-                mdelay(1);
-        }
-
-        /* active PIPE interface */
-        mv_u3d_phy_write(base, USB3_PIPE_SM_CTRL,
-                1 << USB3_PIPE_SM_CTRL_PHY_INIT_DONE);
-
-        return 0;
-}
-
-static int mv_u3d_phy_probe(struct platform_device *pdev)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        struct mv_usb_platform_data *pdata;
-        struct device *dev = &pdev->dev;
-        struct resource *res;
-        void __iomem    *phy_base;
-        int     ret;
-
-        pdata = dev_get_platdata(&pdev->dev);
-        if (!pdata) {
-                dev_err(&pdev->dev, "%s: no platform data defined\n", __func__);
-                return -EINVAL;
-        }
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        phy_base = devm_ioremap_resource(dev, res);
-        if (IS_ERR(phy_base))
-                return PTR_ERR(phy_base);
-
-        mv_u3d_phy = devm_kzalloc(dev, sizeof(*mv_u3d_phy), GFP_KERNEL);
-        if (!mv_u3d_phy)
-                return -ENOMEM;
-
-        mv_u3d_phy->dev                 = &pdev->dev;
-        mv_u3d_phy->plat                = pdata;
-        mv_u3d_phy->base                = phy_base;
-        mv_u3d_phy->phy.dev             = mv_u3d_phy->dev;
-        mv_u3d_phy->phy.label           = "mv-u3d-phy";
-        mv_u3d_phy->phy.init            = mv_u3d_phy_init;
-        mv_u3d_phy->phy.shutdown        = mv_u3d_phy_shutdown;
-
-        ret = usb_add_phy(&mv_u3d_phy->phy, USB_PHY_TYPE_USB3);
-        if (ret)
-                goto err;
-
-        if (!mv_u3d_phy->clk)
-                mv_u3d_phy->clk = clk_get(mv_u3d_phy->dev, "u3dphy");
-
-        platform_set_drvdata(pdev, mv_u3d_phy);
-
-        dev_info(&pdev->dev, "Initialized Marvell USB 3.0 PHY\n");
-err:
-        return ret;
-}
-
-static int mv_u3d_phy_remove(struct platform_device *pdev)
-{
-        struct mv_u3d_phy *mv_u3d_phy = platform_get_drvdata(pdev);
-
-        usb_remove_phy(&mv_u3d_phy->phy);
-
-        if (mv_u3d_phy->clk) {
-                clk_put(mv_u3d_phy->clk);
-                mv_u3d_phy->clk = NULL;
-        }
-
-        return 0;
-}
-
-static struct platform_driver mv_u3d_phy_driver = {
-        .probe          = mv_u3d_phy_probe,
-        .remove         = mv_u3d_phy_remove,
-        .driver         = {
-                .name   = "mv-u3d-phy",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(mv_u3d_phy_driver);
-MODULE_DESCRIPTION("Marvell USB 3.0 PHY controller");
-MODULE_AUTHOR("Yu Xu <yuxu@marvell.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:mv-u3d-phy");
diff --git a/drivers/usb/phy/phy-mv-u3d-usb.h b/drivers/usb/phy/phy-mv-u3d-usb.h
deleted file mode 100644
index 2a658cb9a527..000000000000
--- a/drivers/usb/phy/phy-mv-u3d-usb.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- */
-
-#ifndef __MV_U3D_PHY_H
-#define __MV_U3D_PHY_H
-
-#define USB3_POWER_PLL_CONTROL          0x1
-#define USB3_KVCO_CALI_CONTROL          0x2
-#define USB3_IMPEDANCE_CALI_CTRL        0x3
-#define USB3_IMPEDANCE_TX_SSC           0x4
-#define USB3_SQUELCH_FFE                0x6
-#define USB3_GEN1_SET0                  0xD
-#define USB3_GEN2_SET0                  0xF
-#define USB3_GEN2_SET1                  0x10
-#define USB3_DIGITAL_LOOPBACK_EN        0x23
-#define USB3_PHY_ISOLATION_MODE         0x26
-#define USB3_TXDETRX                    0x48
-#define USB3_TX_EMPPH                   0x5E
-#define USB3_RESET_CONTROL              0x90
-#define USB3_PIPE_SM_CTRL               0x91
-
-#define USB3_RESET_CONTROL_RESET_PIPE                   0x1
-#define USB3_RESET_CONTROL_RESET_PHY                    0x2
-
-#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK        (0x1F << 0)
-#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT       0
-#define USB3_PLL_25MHZ                                  0x2
-#define USB3_PLL_26MHZ                                  0x5
-#define USB3_POWER_PLL_CONTROL_PHY_MODE_MASK            (0x7 << 5)
-#define USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT           5
-#define USB3_POWER_PLL_CONTROL_PU_MASK                  (0xF << 12)
-#define USB3_POWER_PLL_CONTROL_PU_SHIFT                 12
-#define USB3_POWER_PLL_CONTROL_PU                       (0xF << 12)
-
-#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK    (0x1 << 12)
-#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_SHIFT   12
-#define USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT           14
-#define USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT          15
-
-#define USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK               0xF
-#define USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT              0
-#define USB3_SQUELCH_FFE_FFE_RES_SEL_MASK               (0x7 << 4)
-#define USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT              4
-#define USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK              (0x1F << 8)
-#define USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT             8
-
-#define USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
-#define USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT              11
-
-#define USB3_GEN2_SET0_G2_TX_AMP_MASK                   (0x1F << 1)
-#define USB3_GEN2_SET0_G2_TX_AMP_SHIFT                  1
-#define USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT              6
-#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK              (0xF << 7)
-#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT             7
-#define USB3_GEN2_SET0_G2_TX_EMPH_EN_MASK               (0x1 << 11)
-#define USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT              11
-#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
-#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_SHIFT         15
-
-#define USB3_GEN2_SET1_G2_RX_SELMUPI_MASK               (0x7 << 0)
-#define USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT              0
-#define USB3_GEN2_SET1_G2_RX_SELMUPF_MASK               (0x7 << 3)
-#define USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT              3
-#define USB3_GEN2_SET1_G2_RX_SELMUFI_MASK               (0x3 << 6)
-#define USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT              6
-#define USB3_GEN2_SET1_G2_RX_SELMUFF_MASK               (0x3 << 8)
-#define USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT              8
-
-#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK          (0x3 << 10)
-#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT         10
-
-#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK       (0x7 << 12)
-#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT      12
-
-#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK              (0x3F << 0)
-#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT             0
-
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK         0xF
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT        0
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK         (0xF << 4)
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT        4
-#define USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK        (0x1 << 8)
-
-#define USB3_TXDETRX_VTHSEL_MASK                        (0x3 << 4)
-#define USB3_TXDETRX_VTHSEL_SHIFT                       4
-
-#define USB3_TX_EMPPH_AMP_MASK                          (0xF << 0)
-#define USB3_TX_EMPPH_AMP_SHIFT                         0
-#define USB3_TX_EMPPH_EN_MASK                           (0x1 << 6)
-#define USB3_TX_EMPPH_EN_SHIFT                          6
-#define USB3_TX_EMPPH_AMP_FORCE_MASK                    (0x1 << 7)
-#define USB3_TX_EMPPH_AMP_FORCE_SHIFT                   7
-#define USB3_TX_EMPPH_PAR1_MASK                         (0x1F << 8)
-#define USB3_TX_EMPPH_PAR1_SHIFT                        8
-#define USB3_TX_EMPPH_PAR2_MASK                         (0x1 << 13)
-#define USB3_TX_EMPPH_PAR2_SHIFT                        13
-
-#define USB3_PIPE_SM_CTRL_PHY_INIT_DONE                 15
-
-#endif /* __MV_U3D_PHY_H */
diff --git a/drivers/usb/phy/phy-ulpi.c b/drivers/usb/phy/phy-ulpi.c
index 17ea3f271bd8..4e3877c329f2 100644
--- a/drivers/usb/phy/phy-ulpi.c
+++ b/drivers/usb/phy/phy-ulpi.c
@@ -48,6 +48,7 @@ static struct ulpi_info ulpi_ids[] = {
         ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
         ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
         ULPI_INFO(ULPI_ID(0x0424, 0x0007), "SMSC USB3320"),
+        ULPI_INFO(ULPI_ID(0x0424, 0x0009), "SMSC USB334x"),
         ULPI_INFO(ULPI_ID(0x0451, 0x1507), "TI TUSB1210"),
 };
 
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index 35a2373cde67..9374bd2aba20 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -97,13 +97,19 @@ static int usb_serial_device_remove(struct device *dev)
         struct usb_serial_port *port;
         int retval = 0;
         int minor;
+        int autopm_err;
 
         port = to_usb_serial_port(dev);
         if (!port)
                 return -ENODEV;
 
-        /* make sure suspend/resume doesn't race against port_remove */
-        usb_autopm_get_interface(port->serial->interface);
+        /*
+         * Make sure suspend/resume doesn't race against port_remove.
+         *
+         * Note that no further runtime PM callbacks will be made if
+         * autopm_get fails.
+         */
+        autopm_err = usb_autopm_get_interface(port->serial->interface);
 
         minor = port->minor;
         tty_unregister_device(usb_serial_tty_driver, minor);
@@ -117,7 +123,9 @@ static int usb_serial_device_remove(struct device *dev)
         dev_info(dev, "%s converter now disconnected from ttyUSB%d\n",
                  driver->description, minor);
 
-        usb_autopm_put_interface(port->serial->interface);
+        if (!autopm_err)
+                usb_autopm_put_interface(port->serial->interface);
+
         return retval;
 }
 
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index d3acaead5a81..93cb7cebda62 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1535,14 +1535,14 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
 
         this_urb = p_priv->outcont_urb;
 
-        dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
-
                 /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
                 return -1;
         }
 
+        dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
+
         /* Save reset port val for resend.
            Don't overwrite resend for open/close condition. */
         if ((reset_port + 1) > p_priv->resend_cont)
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index fee242387f55..078f9ed419c8 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -215,13 +215,13 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                         priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
                 /* Setting Baudrate, Parity and Stopbits */
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_SetBaudRateParityAndStopBits,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity |
                                                         SUSBCR_SPASB_1StopBit,
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                 );
@@ -229,12 +229,12 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
 
                 /* reset all queues */
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_Misc,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_MSC_ResetAllQueues,
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                 );
@@ -445,12 +445,12 @@ static int kobil_tiocmset(struct tty_struct *tty,
                 else
                         dev_dbg(dev, "%s - Clearing DTR\n", __func__);
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_SetStatusLinesOrQueues,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT);
         } else {
@@ -459,12 +459,12 @@ static int kobil_tiocmset(struct tty_struct *tty,
                 else
                         dev_dbg(dev, "%s - Clearing RTS\n", __func__);
                 result = usb_control_msg(port->serial->dev,
-                        usb_rcvctrlpipe(port->serial->dev, 0),
+                        usb_sndctrlpipe(port->serial->dev, 0),
                         SUSBCRequest_SetStatusLinesOrQueues,
                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                         ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
                         0,
-                        transfer_buffer,
+                        NULL,
                         0,
                         KOBIL_TIMEOUT);
         }
@@ -514,7 +514,7 @@ static void kobil_set_termios(struct tty_struct *tty,
         tty_encode_baud_rate(tty, speed, speed);
 
         result = usb_control_msg(port->serial->dev,
-                  usb_rcvctrlpipe(port->serial->dev, 0),
+                  usb_sndctrlpipe(port->serial->dev, 0),
                   SUSBCRequest_SetBaudRateParityAndStopBits,
                   USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                   urb_val,
@@ -546,12 +546,12 @@ static int kobil_ioctl(struct tty_struct *tty,
                         return -ENOBUFS;
 
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_Misc,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_MSC_ResetAllQueues,
                           0,
-                          NULL, /* transfer_buffer, */
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                         );
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index f213ee978516..51e30740b2fe 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -1729,7 +1729,6 @@ static struct usb_serial_driver option_1port_device = {
         .write             = usb_wwan_write,
         .write_room        = usb_wwan_write_room,
         .chars_in_buffer   = usb_wwan_chars_in_buffer,
-        .set_termios       = usb_wwan_set_termios,
         .tiocmget          = usb_wwan_tiocmget,
         .tiocmset          = usb_wwan_tiocmset,
         .ioctl             = usb_wwan_ioctl,
@@ -1904,6 +1903,7 @@ static void option_instat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving IRQ data */
         if (status != -ESHUTDOWN && status != -ENOENT) {
+                usb_mark_last_busy(port->serial->dev);
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
                         dev_dbg(dev, "%s: resubmit intr urb failed. (%d)\n",
@@ -1923,6 +1923,7 @@ static int option_send_setup(struct usb_serial_port *port)
         struct option_private *priv = intfdata->private;
         struct usb_wwan_port_private *portdata;
         int val = 0;
+        int res;
 
         portdata = usb_get_serial_port_data(port);
 
@@ -1931,9 +1932,17 @@ static int option_send_setup(struct usb_serial_port *port)
         if (portdata->rts_state)
                 val |= 0x02;
 
-        return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+        res = usb_autopm_get_interface(serial->interface);
+        if (res)
+                return res;
+
+        res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                                 0x22, 0x21, val, priv->bInterfaceNumber, NULL,
                                 0, USB_CTRL_SET_TIMEOUT);
+
+        usb_autopm_put_interface(serial->interface);
+
+        return res;
 }
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index 6c0a542e8ec1..b2aa003bf411 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -22,8 +22,17 @@
 #define DRIVER_AUTHOR "Qualcomm Inc"
 #define DRIVER_DESC "Qualcomm USB Serial driver"
 
+/* standard device layouts supported by this driver */
+enum qcserial_layouts {
+        QCSERIAL_G2K = 0,       /* Gobi 2000 */
+        QCSERIAL_G1K = 1,       /* Gobi 1000 */
+        QCSERIAL_SWI = 2,       /* Sierra Wireless */
+};
+
 #define DEVICE_G1K(v, p) \
-        USB_DEVICE(v, p), .driver_info = 1
+        USB_DEVICE(v, p), .driver_info = QCSERIAL_G1K
+#define DEVICE_SWI(v, p) \
+        USB_DEVICE(v, p), .driver_info = QCSERIAL_SWI
 
 static const struct usb_device_id id_table[] = {
         /* Gobi 1000 devices */
@@ -126,46 +135,27 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x12D1, 0x14F1)},   /* Sony Gobi 3000 Composite */
         {USB_DEVICE(0x0AF0, 0x8120)},   /* Option GTM681W */
 
-        /* non Gobi Qualcomm serial devices */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 0)},       /* Sierra Wireless MC7700 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 2)},       /* Sierra Wireless MC7700 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 3)},       /* Sierra Wireless MC7700 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 0)},       /* Sierra Wireless MC7750 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 2)},       /* Sierra Wireless MC7750 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 3)},       /* Sierra Wireless MC7750 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 0)},       /* Sierra Wireless MC7710 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 2)},       /* Sierra Wireless MC7710 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 3)},       /* Sierra Wireless MC7710 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 0)},       /* Sierra Wireless MC73xx Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 2)},       /* Sierra Wireless MC73xx NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 3)},       /* Sierra Wireless MC73xx Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 0)},       /* Sierra Wireless EM7700 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 2)},       /* Sierra Wireless EM7700 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 3)},       /* Sierra Wireless EM7700 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 0)},       /* Sierra Wireless EM7355 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 2)},       /* Sierra Wireless EM7355 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 3)},       /* Sierra Wireless EM7355 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 0)},       /* Sierra Wireless MC7305/MC7355 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 2)},       /* Sierra Wireless MC7305/MC7355 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 3)},       /* Sierra Wireless MC7305/MC7355 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 0)},       /* Netgear AirCard 340U Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 2)},       /* Netgear AirCard 340U NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 3)},       /* Netgear AirCard 340U Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 0)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 2)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 3)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 0)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 2)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 3)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 0)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 2)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 3)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 0)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 2)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 3)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 0)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 2)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 3)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card Modem */
+        /* non-Gobi Sierra Wireless devices */
+        {DEVICE_SWI(0x0f3d, 0x68a2)},   /* Sierra Wireless MC7700 */
+        {DEVICE_SWI(0x114f, 0x68a2)},   /* Sierra Wireless MC7750 */
+        {DEVICE_SWI(0x1199, 0x68a2)},   /* Sierra Wireless MC7710 */
+        {DEVICE_SWI(0x1199, 0x68c0)},   /* Sierra Wireless MC73xx */
+        {DEVICE_SWI(0x1199, 0x901c)},   /* Sierra Wireless EM7700 */
+        {DEVICE_SWI(0x1199, 0x901f)},   /* Sierra Wireless EM7355 */
+        {DEVICE_SWI(0x1199, 0x9040)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9041)},   /* Sierra Wireless MC7305/MC7355 */
+        {DEVICE_SWI(0x1199, 0x9051)},   /* Netgear AirCard 340U */
+        {DEVICE_SWI(0x1199, 0x9053)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9054)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9055)},   /* Netgear AirCard 341U */
+        {DEVICE_SWI(0x1199, 0x9056)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9060)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9061)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x413c, 0x81a2)},   /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a3)},   /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a4)},   /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a8)},   /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a9)},   /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */
 
         { }                             /* Terminating entry */
 };
@@ -178,11 +168,8 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
         int retval = -ENODEV;
         __u8 nintf;
         __u8 ifnum;
-        bool is_gobi1k = id->driver_info ? true : false;
         int altsetting = -1;
 
-        dev_dbg(dev, "Is Gobi 1000 = %d\n", is_gobi1k);
-
         nintf = serial->dev->actconfig->desc.bNumInterfaces;
         dev_dbg(dev, "Num Interfaces = %d\n", nintf);
         ifnum = intf->desc.bInterfaceNumber;
@@ -210,32 +197,29 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
 
         }
 
-        /* allow any number of interfaces when doing direct interface match */
-        if (id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) {
-                dev_dbg(dev, "Generic Qualcomm serial interface found\n");
-                altsetting = 0;
-                goto done;
-        }
-
-        if (nintf < 3 || nintf > 4) {
-                dev_err(dev, "unknown number of interfaces: %d\n", nintf);
-                goto done;
-        }
-
         /* default to enabling interface */
         altsetting = 0;
 
-        /* Composite mode; don't bind to the QMI/net interface as that
+        /*
+         * Composite mode; don't bind to the QMI/net interface as that
          * gets handled by other drivers.
          */
 
-        if (is_gobi1k) {
-                /* Gobi 1K USB layout:
+        switch (id->driver_info) {
+        case QCSERIAL_G1K:
+                /*
+                 * Gobi 1K USB layout:
                  * 0: DM/DIAG (use libqcdm from ModemManager for communication)
                  * 1: serial port (doesn't respond)
                  * 2: AT-capable modem port
                  * 3: QMI/net
                  */
+                if (nintf < 3 || nintf > 4) {
+                        dev_err(dev, "unknown number of interfaces: %d\n", nintf);
+                        altsetting = -1;
+                        goto done;
+                }
+
                 if (ifnum == 0) {
                         dev_dbg(dev, "Gobi 1K DM/DIAG interface found\n");
                         altsetting = 1;
@@ -243,13 +227,21 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                         dev_dbg(dev, "Modem port found\n");
                 else
                         altsetting = -1;
-        } else {
-                /* Gobi 2K+ USB layout:
+                break;
+        case QCSERIAL_G2K:
+                /*
+                 * Gobi 2K+ USB layout:
                  * 0: QMI/net
                  * 1: DM/DIAG (use libqcdm from ModemManager for communication)
                  * 2: AT-capable modem port
                  * 3: NMEA
                  */
+                if (nintf < 3 || nintf > 4) {
+                        dev_err(dev, "unknown number of interfaces: %d\n", nintf);
+                        altsetting = -1;
+                        goto done;
+                }
+
                 switch (ifnum) {
                 case 0:
                         /* Don't claim the QMI/net interface */
@@ -270,6 +262,35 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                         dev_dbg(dev, "Gobi 2K+ NMEA GPS interface found\n");
                         break;
                 }
+                break;
+        case QCSERIAL_SWI:
+                /*
+                 * Sierra Wireless layout:
+                 * 0: DM/DIAG (use libqcdm from ModemManager for communication)
+                 * 2: NMEA
+                 * 3: AT-capable modem port
+                 * 8: QMI/net
+                 */
+                switch (ifnum) {
+                case 0:
+                        dev_dbg(dev, "DM/DIAG interface found\n");
+                        break;
+                case 2:
+                        dev_dbg(dev, "NMEA GPS interface found\n");
+                        break;
+                case 3:
+                        dev_dbg(dev, "Modem port found\n");
+                        break;
+                default:
+                        /* don't claim any unsupported interface */
+                        altsetting = -1;
+                        break;
+                }
+                break;
+        default:
+                dev_err(dev, "unsupported device layout type: %lu\n",
+                        id->driver_info);
+                break;
         }
 
 done:
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 6b192e602ce0..6f7f01eb556a 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -58,6 +58,7 @@ struct sierra_intf_private {
         spinlock_t susp_lock;
         unsigned int suspended:1;
         int in_flight;
+        unsigned int open_ports;
 };
 
 static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
@@ -315,7 +316,6 @@ struct sierra_port_private {
         int dsr_state;
         int dcd_state;
         int ri_state;
-        unsigned int opened:1;
 };
 
 static int sierra_send_setup(struct usb_serial_port *port)
@@ -364,20 +364,13 @@ static int sierra_send_setup(struct usb_serial_port *port)
         if (retval < 0)
                 return retval;
 
-        retval = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+        retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                 0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT);
         usb_autopm_put_interface(serial->interface);
 
         return retval;
 }
 
-static void sierra_set_termios(struct tty_struct *tty,
-                struct usb_serial_port *port, struct ktermios *old_termios)
-{
-        tty_termios_copy_hw(&tty->termios, old_termios);
-        sierra_send_setup(port);
-}
-
 static int sierra_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -418,9 +411,7 @@ static int sierra_tiocmset(struct tty_struct *tty,
 
 static void sierra_release_urb(struct urb *urb)
 {
-        struct usb_serial_port *port;
         if (urb) {
-                port = urb->context;
                 kfree(urb->transfer_buffer);
                 usb_free_urb(urb);
         }
@@ -433,7 +424,7 @@ static void sierra_outdat_callback(struct urb *urb)
         struct sierra_intf_private *intfdata;
         int status = urb->status;
 
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
         kfree(urb->transfer_buffer);
@@ -470,7 +461,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 return 0;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = serial->private;
+        intfdata = usb_get_serial_data(serial);
 
         dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
         spin_lock_irqsave(&portdata->lock, flags);
@@ -674,6 +665,23 @@ static int sierra_write_room(struct tty_struct *tty)
         return 2048;
 }
 
+static int sierra_chars_in_buffer(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        unsigned long flags;
+        int chars;
+
+        /* NOTE: This overcounts somewhat. */
+        spin_lock_irqsave(&portdata->lock, flags);
+        chars = portdata->outstanding_urbs * MAX_TRANSFER;
+        spin_unlock_irqrestore(&portdata->lock, flags);
+
+        dev_dbg(&port->dev, "%s - %d\n", __func__, chars);
+
+        return chars;
+}
+
 static void sierra_stop_rx_urbs(struct usb_serial_port *port)
 {
         int i;
@@ -729,9 +737,6 @@ static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
         struct urb      *urb;
         u8              *buf;
 
-        if (endpoint == -1)
-                return NULL;
-
         urb = usb_alloc_urb(0, mem_flags);
         if (!urb)
                 return NULL;
@@ -758,40 +763,48 @@ static void sierra_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
-        struct sierra_intf_private *intfdata = port->serial->private;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
+        struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
 
-        portdata->rts_state = 0;
-        portdata->dtr_state = 0;
-
-        mutex_lock(&serial->disc_mutex);
-        if (!serial->disconnected) {
+        /*
+         * Need to take susp_lock to make sure port is not already being
+         * resumed, but no need to hold it due to ASYNC_INITIALIZED.
+         */
+        spin_lock_irq(&intfdata->susp_lock);
+        if (--intfdata->open_ports == 0)
                 serial->interface->needs_remote_wakeup = 0;
-                /* odd error handling due to pm counters */
-                if (!usb_autopm_get_interface(serial->interface))
-                        sierra_send_setup(port);
-                else
-                        usb_autopm_get_interface_no_resume(serial->interface);
+        spin_unlock_irq(&intfdata->susp_lock);
 
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+                kfree(urb->transfer_buffer);
+                usb_free_urb(urb);
+                usb_autopm_put_interface_async(serial->interface);
+                spin_lock(&portdata->lock);
+                portdata->outstanding_urbs--;
+                spin_unlock(&portdata->lock);
         }
-        mutex_unlock(&serial->disc_mutex);
-        spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 0;
-        spin_unlock_irq(&intfdata->susp_lock);
 
         sierra_stop_rx_urbs(port);
+        usb_kill_anchored_urbs(&portdata->active);
+
         for (i = 0; i < portdata->num_in_urbs; i++) {
                 sierra_release_urb(portdata->in_urbs[i]);
                 portdata->in_urbs[i] = NULL;
         }
+
+        usb_autopm_get_interface_no_resume(serial->interface);
 }
 
 static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
-        struct sierra_intf_private *intfdata = serial->private;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
         int i;
         int err;
         int endpoint;
@@ -799,11 +812,6 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         portdata = usb_get_serial_port_data(port);
 
-        /* Set some sane defaults */
-        portdata->rts_state = 1;
-        portdata->dtr_state = 1;
-
-
         endpoint = port->bulk_in_endpointAddress;
         for (i = 0; i < portdata->num_in_urbs; i++) {
                 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
@@ -816,23 +824,26 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
                         usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);
 
         err = sierra_submit_rx_urbs(port, GFP_KERNEL);
-        if (err) {
-                /* get rid of everything as in close */
-                sierra_close(port);
-                /* restore balance for autopm */
-                if (!serial->disconnected)
-                        usb_autopm_put_interface(serial->interface);
-                return err;
-        }
-        sierra_send_setup(port);
+        if (err)
+                goto err_submit;
 
-        serial->interface->needs_remote_wakeup = 1;
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 1;
+        if (++intfdata->open_ports == 1)
+                serial->interface->needs_remote_wakeup = 1;
         spin_unlock_irq(&intfdata->susp_lock);
         usb_autopm_put_interface(serial->interface);
 
         return 0;
+
+err_submit:
+        sierra_stop_rx_urbs(port);
+
+        for (i = 0; i < portdata->num_in_urbs; i++) {
+                sierra_release_urb(portdata->in_urbs[i]);
+                portdata->in_urbs[i] = NULL;
+        }
+
+        return err;
 }
 
 
@@ -928,6 +939,7 @@ static int sierra_port_remove(struct usb_serial_port *port)
         struct sierra_port_private *portdata;
 
         portdata = usb_get_serial_port_data(port);
+        usb_set_serial_port_data(port, NULL);
         kfree(portdata);
 
         return 0;
@@ -944,6 +956,8 @@ static void stop_read_write_urbs(struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
+                if (!portdata)
+                        continue;
                 sierra_stop_rx_urbs(port);
                 usb_kill_anchored_urbs(&portdata->active);
         }
@@ -951,58 +965,84 @@ static void stop_read_write_urbs(struct usb_serial *serial)
 
 static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
 {
-        struct sierra_intf_private *intfdata;
-        int b;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
 
+        spin_lock_irq(&intfdata->susp_lock);
         if (PMSG_IS_AUTO(message)) {
-                intfdata = serial->private;
-                spin_lock_irq(&intfdata->susp_lock);
-                b = intfdata->in_flight;
-
-                if (b) {
+                if (intfdata->in_flight) {
                         spin_unlock_irq(&intfdata->susp_lock);
                         return -EBUSY;
-                } else {
-                        intfdata->suspended = 1;
-                        spin_unlock_irq(&intfdata->susp_lock);
                 }
         }
+        intfdata->suspended = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+
         stop_read_write_urbs(serial);
 
         return 0;
 }
 
+/* Caller must hold susp_lock. */
+static int sierra_submit_delayed_urbs(struct usb_serial_port *port)
+{
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_intf_private *intfdata;
+        struct urb *urb;
+        int ec = 0;
+        int err;
+
+        intfdata = usb_get_serial_data(port->serial);
+
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+
+                usb_anchor_urb(urb, &portdata->active);
+                intfdata->in_flight++;
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err) {
+                        dev_err(&port->dev, "%s - submit urb failed: %d",
+                                        __func__, err);
+                        ec++;
+                        intfdata->in_flight--;
+                        usb_unanchor_urb(urb);
+                        kfree(urb->transfer_buffer);
+                        usb_free_urb(urb);
+
+                        spin_lock(&portdata->lock);
+                        portdata->outstanding_urbs--;
+                        spin_unlock(&portdata->lock);
+                }
+        }
+
+        if (ec)
+                return -EIO;
+
+        return 0;
+}
+
 static int sierra_resume(struct usb_serial *serial)
 {
         struct usb_serial_port *port;
-        struct sierra_intf_private *intfdata = serial->private;
-        struct sierra_port_private *portdata;
-        struct urb *urb;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
         int ec = 0;
         int i, err;
 
         spin_lock_irq(&intfdata->susp_lock);
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                portdata = usb_get_serial_port_data(port);
 
-                while ((urb = usb_get_from_anchor(&portdata->delayed))) {
-                        usb_anchor_urb(urb, &portdata->active);
-                        intfdata->in_flight++;
-                        err = usb_submit_urb(urb, GFP_ATOMIC);
-                        if (err < 0) {
-                                intfdata->in_flight--;
-                                usb_unanchor_urb(urb);
-                                usb_scuttle_anchored_urbs(&portdata->delayed);
-                                break;
-                        }
-                }
+                if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
+                        continue;
 
-                if (portdata->opened) {
-                        err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
-                        if (err)
-                                ec++;
-                }
+                err = sierra_submit_delayed_urbs(port);
+                if (err)
+                        ec++;
+
+                err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
+                if (err)
+                        ec++;
         }
         intfdata->suspended = 0;
         spin_unlock_irq(&intfdata->susp_lock);
@@ -1029,7 +1069,7 @@ static struct usb_serial_driver sierra_device = {
         .dtr_rts           = sierra_dtr_rts,
         .write             = sierra_write,
         .write_room        = sierra_write_room,
-        .set_termios       = sierra_set_termios,
+        .chars_in_buffer   = sierra_chars_in_buffer,
         .tiocmget          = sierra_tiocmget,
         .tiocmset          = sierra_tiocmset,
         .attach            = sierra_startup,
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 6d40d56378d7..02de3110fe94 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -1060,6 +1060,7 @@ static void usb_serial_disconnect(struct usb_interface *interface)
         struct usb_serial *serial = usb_get_intfdata(interface);
         struct device *dev = &interface->dev;
         struct usb_serial_port *port;
+        struct tty_struct *tty;
 
         usb_serial_console_disconnect(serial);
 
@@ -1070,18 +1071,16 @@ static void usb_serial_disconnect(struct usb_interface *interface)
 
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
-                if (port) {
-                        struct tty_struct *tty = tty_port_tty_get(&port->port);
-                        if (tty) {
-                                tty_vhangup(tty);
-                                tty_kref_put(tty);
-                        }
-                        usb_serial_port_poison_urbs(port);
-                        wake_up_interruptible(&port->port.delta_msr_wait);
-                        cancel_work_sync(&port->work);
-                        if (device_is_registered(&port->dev))
-                                device_del(&port->dev);
+                tty = tty_port_tty_get(&port->port);
+                if (tty) {
+                        tty_vhangup(tty);
+                        tty_kref_put(tty);
                 }
+                usb_serial_port_poison_urbs(port);
+                wake_up_interruptible(&port->port.delta_msr_wait);
+                cancel_work_sync(&port->work);
+                if (device_is_registered(&port->dev))
+                        device_del(&port->dev);
         }
         if (serial->type->disconnect)
                 serial->type->disconnect(serial);
@@ -1094,7 +1093,6 @@ static void usb_serial_disconnect(struct usb_interface *interface)
 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct usb_serial *serial = usb_get_intfdata(intf);
-        struct usb_serial_port *port;
         int i, r = 0;
 
         serial->suspending = 1;
@@ -1112,12 +1110,8 @@ int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
                 }
         }
 
-        for (i = 0; i < serial->num_ports; ++i) {
-                port = serial->port[i];
-                if (port)
-                        usb_serial_port_poison_urbs(port);
-        }
-
+        for (i = 0; i < serial->num_ports; ++i)
+                usb_serial_port_poison_urbs(serial->port[i]);
 err_out:
         return r;
 }
@@ -1125,14 +1119,10 @@ EXPORT_SYMBOL(usb_serial_suspend);
 
 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
 {
-        struct usb_serial_port *port;
         int i;
 
-        for (i = 0; i < serial->num_ports; ++i) {
-                port = serial->port[i];
-                if (port)
-                        usb_serial_port_unpoison_urbs(port);
-        }
+        for (i = 0; i < serial->num_ports; ++i)
+                usb_serial_port_unpoison_urbs(serial->port[i]);
 }
 
 int usb_serial_resume(struct usb_interface *intf)
diff --git a/drivers/usb/serial/usb-wwan.h b/drivers/usb/serial/usb-wwan.h
index 684739b8efd0..f22dff58b587 100644
--- a/drivers/usb/serial/usb-wwan.h
+++ b/drivers/usb/serial/usb-wwan.h
@@ -11,15 +11,11 @@ extern void usb_wwan_close(struct usb_serial_port *port);
 extern int usb_wwan_port_probe(struct usb_serial_port *port);
 extern int usb_wwan_port_remove(struct usb_serial_port *port);
 extern int usb_wwan_write_room(struct tty_struct *tty);
-extern void usb_wwan_set_termios(struct tty_struct *tty,
-                                 struct usb_serial_port *port,
-                                 struct ktermios *old);
 extern int usb_wwan_tiocmget(struct tty_struct *tty);
 extern int usb_wwan_tiocmset(struct tty_struct *tty,
                              unsigned int set, unsigned int clear);
 extern int usb_wwan_ioctl(struct tty_struct *tty,
                           unsigned int cmd, unsigned long arg);
-extern int usb_wwan_send_setup(struct usb_serial_port *port);
 extern int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                           const unsigned char *buf, int count);
 extern int usb_wwan_chars_in_buffer(struct tty_struct *tty);
@@ -39,6 +35,7 @@ struct usb_wwan_intf_private {
         spinlock_t susp_lock;
         unsigned int suspended:1;
         int in_flight;
+        unsigned int open_ports;
         int (*send_setup) (struct usb_serial_port *port);
         void *private;
 };
@@ -51,7 +48,6 @@ struct usb_wwan_port_private {
         struct urb *out_urbs[N_OUT_URB];
         u8 *out_buffer[N_OUT_URB];
         unsigned long out_busy; /* Bit vector of URBs in use */
-        int opened;
         struct usb_anchor delayed;
 
         /* Settings for the port */
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index b078440e822f..2f805cb386a5 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -41,7 +41,7 @@ void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
         struct usb_wwan_port_private *portdata;
         struct usb_wwan_intf_private *intfdata;
 
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         if (!intfdata->send_setup)
                 return;
@@ -55,20 +55,6 @@ void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
 }
 EXPORT_SYMBOL(usb_wwan_dtr_rts);
 
-void usb_wwan_set_termios(struct tty_struct *tty,
-                          struct usb_serial_port *port,
-                          struct ktermios *old_termios)
-{
-        struct usb_wwan_intf_private *intfdata = port->serial->private;
-
-        /* Doesn't support option setting */
-        tty_termios_copy_hw(&tty->termios, old_termios);
-
-        if (intfdata->send_setup)
-                intfdata->send_setup(port);
-}
-EXPORT_SYMBOL(usb_wwan_set_termios);
-
 int usb_wwan_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -96,7 +82,7 @@ int usb_wwan_tiocmset(struct tty_struct *tty,
         struct usb_wwan_intf_private *intfdata;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         if (!intfdata->send_setup)
                 return -EINVAL;
@@ -192,7 +178,6 @@ int usb_wwan_ioctl(struct tty_struct *tty,
 }
 EXPORT_SYMBOL(usb_wwan_ioctl);
 
-/* Write */
 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                    const unsigned char *buf, int count)
 {
@@ -205,7 +190,7 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
         unsigned long flags;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
 
@@ -228,8 +213,10 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         usb_pipeendpoint(this_urb->pipe), i);
 
                 err = usb_autopm_get_interface_async(port->serial->interface);
-                if (err < 0)
+                if (err < 0) {
+                        clear_bit(i, &portdata->out_busy);
                         break;
+                }
 
                 /* send the data */
                 memcpy(this_urb->transfer_buffer, buf, todo);
@@ -244,9 +231,9 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         spin_unlock_irqrestore(&intfdata->susp_lock, flags);
                         err = usb_submit_urb(this_urb, GFP_ATOMIC);
                         if (err) {
-                                dev_dbg(&port->dev,
-                                        "usb_submit_urb %p (write bulk) failed (%d)\n",
-                                        this_urb, err);
+                                dev_err(&port->dev,
+                                        "%s: submit urb %d failed: %d\n",
+                                        __func__, i, err);
                                 clear_bit(i, &portdata->out_busy);
                                 spin_lock_irqsave(&intfdata->susp_lock, flags);
                                 intfdata->in_flight--;
@@ -314,7 +301,7 @@ static void usb_wwan_outdat_callback(struct urb *urb)
         int i;
 
         port = urb->context;
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         usb_serial_port_softint(port);
         usb_autopm_put_interface_async(port->serial->interface);
@@ -325,7 +312,7 @@ static void usb_wwan_outdat_callback(struct urb *urb)
 
         for (i = 0; i < N_OUT_URB; ++i) {
                 if (portdata->out_urbs[i] == urb) {
-                        smp_mb__before_clear_bit();
+                        smp_mb__before_atomic();
                         clear_bit(i, &portdata->out_busy);
                         break;
                 }
@@ -384,7 +371,15 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = serial->private;
+        intfdata = usb_get_serial_data(serial);
+
+        if (port->interrupt_in_urb) {
+                err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit int urb failed: %d\n",
+                                __func__, err);
+                }
+        }
 
         /* Start reading from the IN endpoint */
         for (i = 0; i < N_IN_URB; i++) {
@@ -393,17 +388,15 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
                         continue;
                 err = usb_submit_urb(urb, GFP_KERNEL);
                 if (err) {
-                        dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
-                                __func__, i, err, urb->transfer_buffer_length);
+                        dev_err(&port->dev,
+                                "%s: submit read urb %d failed: %d\n",
+                                __func__, i, err);
                 }
         }
 
-        if (intfdata->send_setup)
-                intfdata->send_setup(port);
-
-        serial->interface->needs_remote_wakeup = 1;
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 1;
+        if (++intfdata->open_ports == 1)
+                serial->interface->needs_remote_wakeup = 1;
         spin_unlock_irq(&intfdata->susp_lock);
         /* this balances a get in the generic USB serial code */
         usb_autopm_put_interface(serial->interface);
@@ -412,32 +405,56 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
 }
 EXPORT_SYMBOL(usb_wwan_open);
 
+static void unbusy_queued_urb(struct urb *urb,
+                                        struct usb_wwan_port_private *portdata)
+{
+        int i;
+
+        for (i = 0; i < N_OUT_URB; i++) {
+                if (urb == portdata->out_urbs[i]) {
+                        clear_bit(i, &portdata->out_busy);
+                        break;
+                }
+        }
+}
+
 void usb_wwan_close(struct usb_serial_port *port)
 {
         int i;
         struct usb_serial *serial = port->serial;
         struct usb_wwan_port_private *portdata;
-        struct usb_wwan_intf_private *intfdata = port->serial->private;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
+        struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
 
-        /* Stop reading/writing urbs */
+        /*
+         * Need to take susp_lock to make sure port is not already being
+         * resumed, but no need to hold it due to ASYNC_INITIALIZED.
+         */
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 0;
+        if (--intfdata->open_ports == 0)
+                serial->interface->needs_remote_wakeup = 0;
         spin_unlock_irq(&intfdata->susp_lock);
 
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+                unbusy_queued_urb(urb, portdata);
+                usb_autopm_put_interface_async(serial->interface);
+        }
+
         for (i = 0; i < N_IN_URB; i++)
                 usb_kill_urb(portdata->in_urbs[i]);
         for (i = 0; i < N_OUT_URB; i++)
                 usb_kill_urb(portdata->out_urbs[i]);
+        usb_kill_urb(port->interrupt_in_urb);
 
-        /* balancing - important as an error cannot be handled*/
         usb_autopm_get_interface_no_resume(serial->interface);
-        serial->interface->needs_remote_wakeup = 0;
 }
 EXPORT_SYMBOL(usb_wwan_close);
 
-/* Helper functions used by usb_wwan_setup_urbs */
 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
                                       int endpoint,
                                       int dir, void *ctx, char *buf, int len,
@@ -450,7 +467,6 @@ static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
         if (!urb)
                 return NULL;
 
-        /* Fill URB using supplied data. */
         usb_fill_bulk_urb(urb, serial->dev,
                           usb_sndbulkpipe(serial->dev, endpoint) | dir,
                           buf, len, callback, ctx);
@@ -463,7 +479,6 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
         u8 *buffer;
-        int err;
         int i;
 
         if (!port->bulk_in_size || !port->bulk_out_size)
@@ -503,13 +518,6 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
 
         usb_set_serial_port_data(port, portdata);
 
-        if (port->interrupt_in_urb) {
-                err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
-                if (err)
-                        dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
-                                __func__, err);
-        }
-
         return 0;
 
 bail_out_error2:
@@ -536,32 +544,28 @@ int usb_wwan_port_remove(struct usb_serial_port *port)
         portdata = usb_get_serial_port_data(port);
         usb_set_serial_port_data(port, NULL);
 
-        /* Stop reading/writing urbs and free them */
         for (i = 0; i < N_IN_URB; i++) {
-                usb_kill_urb(portdata->in_urbs[i]);
                 usb_free_urb(portdata->in_urbs[i]);
                 free_page((unsigned long)portdata->in_buffer[i]);
         }
         for (i = 0; i < N_OUT_URB; i++) {
-                usb_kill_urb(portdata->out_urbs[i]);
                 usb_free_urb(portdata->out_urbs[i]);
                 kfree(portdata->out_buffer[i]);
         }
 
-        /* Now free port private data */
         kfree(portdata);
+
         return 0;
 }
 EXPORT_SYMBOL(usb_wwan_port_remove);
 
 #ifdef CONFIG_PM
-static void stop_read_write_urbs(struct usb_serial *serial)
+static void stop_urbs(struct usb_serial *serial)
 {
         int i, j;
         struct usb_serial_port *port;
         struct usb_wwan_port_private *portdata;
 
-        /* Stop reading/writing urbs */
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
@@ -571,123 +575,117 @@ static void stop_read_write_urbs(struct usb_serial *serial)
                         usb_kill_urb(portdata->in_urbs[j]);
                 for (j = 0; j < N_OUT_URB; j++)
                         usb_kill_urb(portdata->out_urbs[j]);
+                usb_kill_urb(port->interrupt_in_urb);
         }
 }
 
 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
 {
-        struct usb_wwan_intf_private *intfdata = serial->private;
-        int b;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 
+        spin_lock_irq(&intfdata->susp_lock);
         if (PMSG_IS_AUTO(message)) {
-                spin_lock_irq(&intfdata->susp_lock);
-                b = intfdata->in_flight;
-                spin_unlock_irq(&intfdata->susp_lock);
-
-                if (b)
+                if (intfdata->in_flight) {
+                        spin_unlock_irq(&intfdata->susp_lock);
                         return -EBUSY;
+                }
         }
-
-        spin_lock_irq(&intfdata->susp_lock);
         intfdata->suspended = 1;
         spin_unlock_irq(&intfdata->susp_lock);
-        stop_read_write_urbs(serial);
+
+        stop_urbs(serial);
 
         return 0;
 }
 EXPORT_SYMBOL(usb_wwan_suspend);
 
-static void unbusy_queued_urb(struct urb *urb, struct usb_wwan_port_private *portdata)
+/* Caller must hold susp_lock. */
+static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
 {
-        int i;
-
-        for (i = 0; i < N_OUT_URB; i++) {
-                if (urb == portdata->out_urbs[i]) {
-                        clear_bit(i, &portdata->out_busy);
-                        break;
-                }
-        }
-}
-
-static void play_delayed(struct usb_serial_port *port)
-{
-        struct usb_wwan_intf_private *data;
+        struct usb_serial *serial = port->serial;
+        struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
+        int err_count = 0;
         int err;
 
         portdata = usb_get_serial_port_data(port);
-        data = port->serial->private;
-        while ((urb = usb_get_from_anchor(&portdata->delayed))) {
-                err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (!err) {
-                        data->in_flight++;
-                } else {
-                        /* we have to throw away the rest */
-                        do {
-                                unbusy_queued_urb(urb, portdata);
-                                usb_autopm_put_interface_no_suspend(port->serial->interface);
-                        } while ((urb = usb_get_from_anchor(&portdata->delayed)));
+
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
                         break;
+
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit urb failed: %d\n",
+                                        __func__, err);
+                        err_count++;
+                        unbusy_queued_urb(urb, portdata);
+                        usb_autopm_put_interface_async(serial->interface);
+                        continue;
                 }
+                data->in_flight++;
         }
+
+        if (err_count)
+                return -EIO;
+
+        return 0;
 }
 
 int usb_wwan_resume(struct usb_serial *serial)
 {
         int i, j;
         struct usb_serial_port *port;
-        struct usb_wwan_intf_private *intfdata = serial->private;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
-        int err = 0;
+        int err;
+        int err_count = 0;
 
-        /* get the interrupt URBs resubmitted unconditionally */
+        spin_lock_irq(&intfdata->susp_lock);
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                if (!port->interrupt_in_urb) {
-                        dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
+
+                if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
                         continue;
-                }
-                err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
-                dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
-                if (err < 0) {
-                        dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
-                                __func__, err);
-                        goto err_out;
-                }
-        }
 
-        for (i = 0; i < serial->num_ports; i++) {
-                /* walk all ports */
-                port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
 
-                /* skip closed ports */
-                spin_lock_irq(&intfdata->susp_lock);
-                if (!portdata || !portdata->opened) {
-                        spin_unlock_irq(&intfdata->susp_lock);
-                        continue;
+                if (port->interrupt_in_urb) {
+                        err = usb_submit_urb(port->interrupt_in_urb,
+                                        GFP_ATOMIC);
+                        if (err) {
+                                dev_err(&port->dev,
+                                        "%s: submit int urb failed: %d\n",
+                                        __func__, err);
+                                err_count++;
+                        }
                 }
 
+                err = usb_wwan_submit_delayed_urbs(port);
+                if (err)
+                        err_count++;
+
                 for (j = 0; j < N_IN_URB; j++) {
                         urb = portdata->in_urbs[j];
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err < 0) {
-                                dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
-                                        __func__, err, i);
-                                spin_unlock_irq(&intfdata->susp_lock);
-                                goto err_out;
+                                dev_err(&port->dev,
+                                        "%s: submit read urb %d failed: %d\n",
+                                        __func__, i, err);
+                                err_count++;
                         }
                 }
-                play_delayed(port);
-                spin_unlock_irq(&intfdata->susp_lock);
         }
-        spin_lock_irq(&intfdata->susp_lock);
         intfdata->suspended = 0;
         spin_unlock_irq(&intfdata->susp_lock);
-err_out:
-        return err;
+
+        if (err_count)
+                return -EIO;
+
+        return 0;
 }
 EXPORT_SYMBOL(usb_wwan_resume);
 #endif
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
index 1bfc9a6cab5f..ef6efb55dc31 100644
--- a/drivers/usb/storage/ene_ub6250.c
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -1928,11 +1928,10 @@ static int ene_load_bincode(struct us_data *us, unsigned char flag)
                 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
                 goto nofw;
         }
-        buf = kmalloc(sd_fw->size, GFP_KERNEL);
+        buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
         if (buf == NULL)
                 goto nofw;
 
-        memcpy(buf, sd_fw->data, sd_fw->size);
         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
         bcb->DataTransferLength = sd_fw->size;
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index 6d6da127f6de..a80c5d284b59 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -524,7 +524,7 @@ void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 
                 usb_control_msg(
-                        wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
+                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                         USB_REQ_RPIPE_ABORT,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                         0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -545,7 +545,7 @@ void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 
                 usb_control_msg(
-                        wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
+                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                         USB_REQ_CLEAR_FEATURE,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                         RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);