134 files changed, 4948 insertions, 3351 deletions

diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 2f1e2aa42b44..d8926c6cd2a8 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -5,6 +5,7 @@
 # Object files in subdirectories
 
 obj-$(CONFIG_USB)               += core/
+obj-$(CONFIG_USB_SUPPORT)       += phy/
 
 obj-$(CONFIG_USB_DWC3)          += dwc3/
 obj-$(CONFIG_USB_DWC2)          += dwc2/
@@ -48,7 +49,6 @@ obj-$(CONFIG_USB_MICROTEK)	+= image/
 obj-$(CONFIG_USB_SERIAL)        += serial/
 
 obj-$(CONFIG_USB)               += misc/
-obj-$(CONFIG_USB_SUPPORT)       += phy/
 obj-$(CONFIG_EARLY_PRINTK_DBGP) += early/
 
 obj-$(CONFIG_USB_ATM)           += atm/
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 5a459377574b..888998a7fe31 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -952,7 +952,7 @@ static void uea_load_page_e1(struct work_struct *work)
         int i;
 
         /* reload firmware when reboot start and it's loaded already */
-        if (ovl == 0 && pageno == 0 && sc->dsp_firm) {
+        if (ovl == 0 && pageno == 0) {
                 release_firmware(sc->dsp_firm);
                 sc->dsp_firm = NULL;
         }
@@ -1074,7 +1074,7 @@ static void uea_load_page_e4(struct work_struct *work)
         uea_dbg(INS_TO_USBDEV(sc), "sending DSP page %u\n", pageno);
 
         /* reload firmware when reboot start and it's loaded already */
-        if (pageno == 0 && sc->dsp_firm) {
+        if (pageno == 0) {
                 release_firmware(sc->dsp_firm);
                 sc->dsp_firm = NULL;
         }
diff --git a/drivers/usb/c67x00/c67x00-hcd.c b/drivers/usb/c67x00/c67x00-hcd.c
index 20ec4eee1ac8..c2d13968da82 100644
--- a/drivers/usb/c67x00/c67x00-hcd.c
+++ b/drivers/usb/c67x00/c67x00-hcd.c
@@ -34,7 +34,7 @@
 
 static __u8 c67x00_hub_des[] = {
         0x09,                   /*  __u8  bLength; */
-        0x29,                   /*  __u8  bDescriptorType; Hub-descriptor */
+        USB_DT_HUB,             /*  __u8  bDescriptorType; Hub-descriptor */
         0x02,                   /*  __u8  bNbrPorts; */
         0x00,                   /* __u16  wHubCharacteristics; */
         0x00,                   /*   (per-port OC, no power switching) */
diff --git a/drivers/usb/chipidea/Kconfig b/drivers/usb/chipidea/Kconfig
index 77b47d82c9a6..5ce3f1d6a6ed 100644
--- a/drivers/usb/chipidea/Kconfig
+++ b/drivers/usb/chipidea/Kconfig
@@ -10,6 +10,17 @@ config USB_CHIPIDEA
 
 if USB_CHIPIDEA
 
+config USB_CHIPIDEA_OF
+        tristate
+        depends on OF
+        default USB_CHIPIDEA
+
+config USB_CHIPIDEA_PCI
+        tristate
+        depends on PCI
+        depends on NOP_USB_XCEIV
+        default USB_CHIPIDEA
+
 config USB_CHIPIDEA_UDC
         bool "ChipIdea device controller"
         depends on USB_GADGET
diff --git a/drivers/usb/chipidea/Makefile b/drivers/usb/chipidea/Makefile
index 1fc86a2ca22d..4decb12f2578 100644
--- a/drivers/usb/chipidea/Makefile
+++ b/drivers/usb/chipidea/Makefile
@@ -14,11 +14,6 @@ obj-$(CONFIG_USB_CHIPIDEA)	+= ci_hdrc_usb2.o
 obj-$(CONFIG_USB_CHIPIDEA)      += ci_hdrc_msm.o
 obj-$(CONFIG_USB_CHIPIDEA)      += ci_hdrc_zevio.o
 
-# PCI doesn't provide stubs, need to check
-ifneq ($(CONFIG_PCI),)
-        obj-$(CONFIG_USB_CHIPIDEA)      += ci_hdrc_pci.o
-endif
+obj-$(CONFIG_USB_CHIPIDEA_PCI)  += ci_hdrc_pci.o
 
-ifneq ($(CONFIG_OF),)
-        obj-$(CONFIG_USB_CHIPIDEA)      += usbmisc_imx.o ci_hdrc_imx.o
-endif
+obj-$(CONFIG_USB_CHIPIDEA_OF)   += usbmisc_imx.o ci_hdrc_imx.o
diff --git a/drivers/usb/chipidea/bits.h b/drivers/usb/chipidea/bits.h
index ca57e3dcd3d5..3cb9bda51ddf 100644
--- a/drivers/usb/chipidea/bits.h
+++ b/drivers/usb/chipidea/bits.h
@@ -15,6 +15,16 @@
 
 #include <linux/usb/ehci_def.h>
 
+/*
+ * ID
+ * For 1.x revision, bit24 - bit31 are reserved
+ * For 2.x revision, bit25 - bit28 are 0x2
+ */
+#define TAG                   (0x1F << 16)
+#define REVISION              (0xF << 21)
+#define VERSION               (0xF << 25)
+#define CIVERSION             (0x7 << 29)
+
 /* HCCPARAMS */
 #define HCCPARAMS_LEN         BIT(17)
 
@@ -53,6 +63,7 @@
 #define PORTSC_HSP            BIT(9)
 #define PORTSC_PP             BIT(12)
 #define PORTSC_PTC            (0x0FUL << 16)
+#define PORTSC_WKCN           BIT(20)
 #define PORTSC_PHCD(d)        ((d) ? BIT(22) : BIT(23))
 /* PTS and PTW for non lpm version only */
 #define PORTSC_PFSC           BIT(24)
diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
index 65913d48f0c8..6d6200e37b71 100644
--- a/drivers/usb/chipidea/ci.h
+++ b/drivers/usb/chipidea/ci.h
@@ -29,6 +29,15 @@
 /******************************************************************************
  * REGISTERS
  *****************************************************************************/
+/* Identification Registers */
+#define ID_ID                           0x0
+#define ID_HWGENERAL                    0x4
+#define ID_HWHOST                       0x8
+#define ID_HWDEVICE                     0xc
+#define ID_HWTXBUF                      0x10
+#define ID_HWRXBUF                      0x14
+#define ID_SBUSCFG                      0x90
+
 /* register indices */
 enum ci_hw_regs {
         CAP_CAPLENGTH,
@@ -97,6 +106,18 @@ enum ci_role {
         CI_ROLE_END,
 };
 
+enum ci_revision {
+        CI_REVISION_1X = 10,    /* Revision 1.x */
+        CI_REVISION_20 = 20, /* Revision 2.0 */
+        CI_REVISION_21, /* Revision 2.1 */
+        CI_REVISION_22, /* Revision 2.2 */
+        CI_REVISION_23, /* Revision 2.3 */
+        CI_REVISION_24, /* Revision 2.4 */
+        CI_REVISION_25, /* Revision 2.5 */
+        CI_REVISION_25_PLUS, /* Revision above than 2.5 */
+        CI_REVISION_UNKNOWN = 99, /* Unknown Revision */
+};
+
 /**
  * struct ci_role_driver - host/gadget role driver
  * @start: start this role
@@ -141,7 +162,10 @@ struct hw_bank {
  * @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
+ * @otg_fsm_hrtimer: hrtimer for otg fsm timers
+ * @hr_timeouts: time out list for active otg fsm timers
+ * @enabled_otg_timer_bits: bits of enabled otg timers
+ * @next_otg_timer: next nearest enabled timer to be expired
  * @work: work for role changing
  * @wq: workqueue thread
  * @qh_pool: allocation pool for queue heads
@@ -169,6 +193,10 @@ struct hw_bank {
  * @b_sess_valid_event: indicates there is a vbus event, and handled
  * at ci_otg_work
  * @imx28_write_fix: Freescale imx28 needs swp instruction for writing
+ * @supports_runtime_pm: if runtime pm is supported
+ * @in_lpm: if the core in low power mode
+ * @wakeup_int: if wakeup interrupt occur
+ * @rev: The revision number for controller
  */
 struct ci_hdrc {
         struct device                   *dev;
@@ -180,7 +208,10 @@ struct ci_hdrc {
         bool                            is_otg;
         struct usb_otg                  otg;
         struct otg_fsm                  fsm;
-        struct ci_otg_fsm_timer_list    *fsm_timer;
+        struct hrtimer                  otg_fsm_hrtimer;
+        ktime_t                         hr_timeouts[NUM_OTG_FSM_TIMERS];
+        unsigned                        enabled_otg_timer_bits;
+        enum otg_fsm_timer              next_otg_timer;
         struct work_struct              work;
         struct workqueue_struct         *wq;
 
@@ -211,6 +242,10 @@ struct ci_hdrc {
         bool                            id_event;
         bool                            b_sess_valid_event;
         bool                            imx28_write_fix;
+        bool                            supports_runtime_pm;
+        bool                            in_lpm;
+        bool                            wakeup_int;
+        enum ci_revision                rev;
 };
 
 static inline struct ci_role_driver *ci_role(struct ci_hdrc *ci)
@@ -248,6 +283,36 @@ static inline void ci_role_stop(struct ci_hdrc *ci)
 }
 
 /**
+ * hw_read_id_reg: reads from a identification register
+ * @ci: the controller
+ * @offset: offset from the beginning of identification registers region
+ * @mask: bitfield mask
+ *
+ * This function returns register contents
+ */
+static inline u32 hw_read_id_reg(struct ci_hdrc *ci, u32 offset, u32 mask)
+{
+        return ioread32(ci->hw_bank.abs + offset) & mask;
+}
+
+/**
+ * hw_write_id_reg: writes to a identification register
+ * @ci: the controller
+ * @offset: offset from the beginning of identification registers region
+ * @mask: bitfield mask
+ * @data: new value
+ */
+static inline void hw_write_id_reg(struct ci_hdrc *ci, u32 offset,
+                            u32 mask, u32 data)
+{
+        if (~mask)
+                data = (ioread32(ci->hw_bank.abs + offset) & ~mask)
+                        | (data & mask);
+
+        iowrite32(data, ci->hw_bank.abs + offset);
+}
+
+/**
  * hw_read: reads from a hw register
  * @ci: the controller
  * @reg:  register index
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_hdrc_imx.c
index 0f05de7c6b6c..389f0e034259 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.c
+++ b/drivers/usb/chipidea/ci_hdrc_imx.c
@@ -23,22 +23,40 @@
 #include "ci.h"
 #include "ci_hdrc_imx.h"
 
-#define CI_HDRC_IMX_IMX28_WRITE_FIX BIT(0)
-
 struct ci_hdrc_imx_platform_flag {
         unsigned int flags;
+        bool runtime_pm;
 };
 
 static const struct ci_hdrc_imx_platform_flag imx27_usb_data = {
 };
 
 static const struct ci_hdrc_imx_platform_flag imx28_usb_data = {
-        .flags = CI_HDRC_IMX_IMX28_WRITE_FIX,
+        .flags = CI_HDRC_IMX28_WRITE_FIX |
+                CI_HDRC_TURN_VBUS_EARLY_ON,
+};
+
+static const struct ci_hdrc_imx_platform_flag imx6q_usb_data = {
+        .flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
+                CI_HDRC_TURN_VBUS_EARLY_ON,
+};
+
+static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data = {
+        .flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
+                CI_HDRC_TURN_VBUS_EARLY_ON,
+};
+
+static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data = {
+        .flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
+                CI_HDRC_TURN_VBUS_EARLY_ON,
 };
 
 static const struct of_device_id ci_hdrc_imx_dt_ids[] = {
         { .compatible = "fsl,imx28-usb", .data = &imx28_usb_data},
         { .compatible = "fsl,imx27-usb", .data = &imx27_usb_data},
+        { .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data},
+        { .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data},
+        { .compatible = "fsl,imx6sx-usb", .data = &imx6sl_usb_data},
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids);
@@ -48,6 +66,8 @@ struct ci_hdrc_imx_data {
         struct platform_device *ci_pdev;
         struct clk *clk;
         struct imx_usbmisc_data *usbmisc_data;
+        bool supports_runtime_pm;
+        bool in_lpm;
 };
 
 /* Common functions shared by usbmisc drivers */
@@ -145,21 +165,18 @@ static int ci_hdrc_imx_probe(struct platform_device *pdev)
         }
 
         pdata.usb_phy = data->phy;
-
-        if (imx_platform_flag->flags & CI_HDRC_IMX_IMX28_WRITE_FIX)
-                pdata.flags |= CI_HDRC_IMX28_WRITE_FIX;
+        pdata.flags |= imx_platform_flag->flags;
+        if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM)
+                data->supports_runtime_pm = true;
 
         ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
         if (ret)
                 goto err_clk;
 
-        if (data->usbmisc_data) {
-                ret = imx_usbmisc_init(data->usbmisc_data);
-                if (ret) {
-                        dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n",
-                                        ret);
-                        goto err_clk;
-                }
+        ret = imx_usbmisc_init(data->usbmisc_data);
+        if (ret) {
+                dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret);
+                goto err_clk;
         }
 
         data->ci_pdev = ci_hdrc_add_device(&pdev->dev,
@@ -173,19 +190,20 @@ static int ci_hdrc_imx_probe(struct platform_device *pdev)
                 goto err_clk;
         }
 
-        if (data->usbmisc_data) {
-                ret = imx_usbmisc_init_post(data->usbmisc_data);
-                if (ret) {
-                        dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n",
-                                        ret);
-                        goto disable_device;
-                }
+        ret = imx_usbmisc_init_post(data->usbmisc_data);
+        if (ret) {
+                dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret);
+                goto disable_device;
         }
 
         platform_set_drvdata(pdev, data);
 
-        pm_runtime_no_callbacks(&pdev->dev);
-        pm_runtime_enable(&pdev->dev);
+        if (data->supports_runtime_pm) {
+                pm_runtime_set_active(&pdev->dev);
+                pm_runtime_enable(&pdev->dev);
+        }
+
+        device_set_wakeup_capable(&pdev->dev, true);
 
         return 0;
 
@@ -200,14 +218,18 @@ static int ci_hdrc_imx_remove(struct platform_device *pdev)
 {
         struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev);
 
-        pm_runtime_disable(&pdev->dev);
+        if (data->supports_runtime_pm) {
+                pm_runtime_get_sync(&pdev->dev);
+                pm_runtime_disable(&pdev->dev);
+                pm_runtime_put_noidle(&pdev->dev);
+        }
         ci_hdrc_remove_device(data->ci_pdev);
         clk_disable_unprepare(data->clk);
 
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
 static int imx_controller_suspend(struct device *dev)
 {
         struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
@@ -215,6 +237,7 @@ static int imx_controller_suspend(struct device *dev)
         dev_dbg(dev, "at %s\n", __func__);
 
         clk_disable_unprepare(data->clk);
+        data->in_lpm = true;
 
         return 0;
 }
@@ -222,25 +245,103 @@ static int imx_controller_suspend(struct device *dev)
 static int imx_controller_resume(struct device *dev)
 {
         struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
+        int ret = 0;
 
         dev_dbg(dev, "at %s\n", __func__);
 
-        return clk_prepare_enable(data->clk);
+        if (!data->in_lpm) {
+                WARN_ON(1);
+                return 0;
+        }
+
+        ret = clk_prepare_enable(data->clk);
+        if (ret)
+                return ret;
+
+        data->in_lpm = false;
+
+        ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false);
+        if (ret) {
+                dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
+                goto clk_disable;
+        }
+
+        return 0;
+
+clk_disable:
+        clk_disable_unprepare(data->clk);
+        return ret;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int ci_hdrc_imx_suspend(struct device *dev)
 {
+        int ret;
+
+        struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
+
+        if (data->in_lpm)
+                /* The core's suspend doesn't run */
+                return 0;
+
+        if (device_may_wakeup(dev)) {
+                ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
+                if (ret) {
+                        dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n",
+                                        ret);
+                        return ret;
+                }
+        }
+
         return imx_controller_suspend(dev);
 }
 
 static int ci_hdrc_imx_resume(struct device *dev)
 {
-        return imx_controller_resume(dev);
+        struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
+        int ret;
+
+        ret = imx_controller_resume(dev);
+        if (!ret && data->supports_runtime_pm) {
+                pm_runtime_disable(dev);
+                pm_runtime_set_active(dev);
+                pm_runtime_enable(dev);
+        }
+
+        return ret;
 }
 #endif /* CONFIG_PM_SLEEP */
 
+static int ci_hdrc_imx_runtime_suspend(struct device *dev)
+{
+        struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
+        int ret;
+
+        if (data->in_lpm) {
+                WARN_ON(1);
+                return 0;
+        }
+
+        ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
+        if (ret) {
+                dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
+                return ret;
+        }
+
+        return imx_controller_suspend(dev);
+}
+
+static int ci_hdrc_imx_runtime_resume(struct device *dev)
+{
+        return imx_controller_resume(dev);
+}
+
+#endif /* CONFIG_PM */
+
 static const struct dev_pm_ops ci_hdrc_imx_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume)
+        SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend,
+                        ci_hdrc_imx_runtime_resume, NULL)
 };
 static struct platform_driver ci_hdrc_imx_driver = {
         .probe = ci_hdrc_imx_probe,
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.h b/drivers/usb/chipidea/ci_hdrc_imx.h
index 4ed828f75a1e..635717e9354a 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.h
+++ b/drivers/usb/chipidea/ci_hdrc_imx.h
@@ -22,5 +22,6 @@ struct imx_usbmisc_data {
 
 int imx_usbmisc_init(struct imx_usbmisc_data *);
 int imx_usbmisc_init_post(struct imx_usbmisc_data *);
+int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *, bool);
 
 #endif /* __DRIVER_USB_CHIPIDEA_CI_HDRC_IMX_H */
diff --git a/drivers/usb/chipidea/ci_hdrc_pci.c b/drivers/usb/chipidea/ci_hdrc_pci.c
index 4df669437211..773d150512fa 100644
--- a/drivers/usb/chipidea/ci_hdrc_pci.c
+++ b/drivers/usb/chipidea/ci_hdrc_pci.c
@@ -16,10 +16,16 @@
 #include <linux/interrupt.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/chipidea.h>
+#include <linux/usb/usb_phy_generic.h>
 
 /* driver name */
 #define UDC_DRIVER_NAME   "ci_hdrc_pci"
 
+struct ci_hdrc_pci {
+        struct platform_device  *ci;
+        struct platform_device  *phy;
+};
+
 /******************************************************************************
  * PCI block
  *****************************************************************************/
@@ -52,7 +58,7 @@ static int ci_hdrc_pci_probe(struct pci_dev *pdev,
                                        const struct pci_device_id *id)
 {
         struct ci_hdrc_platform_data *platdata = (void *)id->driver_data;
-        struct platform_device *plat_ci;
+        struct ci_hdrc_pci *ci;
         struct resource res[3];
         int retval = 0, nres = 2;
 
@@ -61,6 +67,10 @@ static int ci_hdrc_pci_probe(struct pci_dev *pdev,
                 return -ENODEV;
         }
 
+        ci = devm_kzalloc(&pdev->dev, sizeof(*ci), GFP_KERNEL);
+        if (!ci)
+                return -ENOMEM;
+
         retval = pcim_enable_device(pdev);
         if (retval)
                 return retval;
@@ -73,6 +83,11 @@ static int ci_hdrc_pci_probe(struct pci_dev *pdev,
         pci_set_master(pdev);
         pci_try_set_mwi(pdev);
 
+        /* register a nop PHY */
+        ci->phy = usb_phy_generic_register();
+        if (!ci->phy)
+                return -ENOMEM;
+
         memset(res, 0, sizeof(res));
         res[0].start    = pci_resource_start(pdev, 0);
         res[0].end      = pci_resource_end(pdev, 0);
@@ -80,13 +95,14 @@ static int ci_hdrc_pci_probe(struct pci_dev *pdev,
         res[1].start    = pdev->irq;
         res[1].flags    = IORESOURCE_IRQ;
 
-        plat_ci = ci_hdrc_add_device(&pdev->dev, res, nres, platdata);
-        if (IS_ERR(plat_ci)) {
+        ci->ci = ci_hdrc_add_device(&pdev->dev, res, nres, platdata);
+        if (IS_ERR(ci->ci)) {
                 dev_err(&pdev->dev, "ci_hdrc_add_device failed!\n");
-                return PTR_ERR(plat_ci);
+                usb_phy_generic_unregister(ci->phy);
+                return PTR_ERR(ci->ci);
         }
 
-        pci_set_drvdata(pdev, plat_ci);
+        pci_set_drvdata(pdev, ci);
 
         return 0;
 }
@@ -101,9 +117,10 @@ static int ci_hdrc_pci_probe(struct pci_dev *pdev,
  */
 static void ci_hdrc_pci_remove(struct pci_dev *pdev)
 {
-        struct platform_device *plat_ci = pci_get_drvdata(pdev);
+        struct ci_hdrc_pci *ci = pci_get_drvdata(pdev);
 
-        ci_hdrc_remove_device(plat_ci);
+        ci_hdrc_remove_device(ci->ci);
+        usb_phy_generic_unregister(ci->phy);
 }
 
 /**
diff --git a/drivers/usb/chipidea/ci_hdrc_zevio.c b/drivers/usb/chipidea/ci_hdrc_zevio.c
index d976fc1db73a..1264de505527 100644
--- a/drivers/usb/chipidea/ci_hdrc_zevio.c
+++ b/drivers/usb/chipidea/ci_hdrc_zevio.c
@@ -18,7 +18,7 @@
 
 static struct ci_hdrc_platform_data ci_hdrc_zevio_platdata = {
         .name                   = "ci_hdrc_zevio",
-        .flags                  = CI_HDRC_REGS_SHARED,
+        .flags                  = CI_HDRC_REGS_SHARED | CI_HDRC_FORCE_FULLSPEED,
         .capoffset              = DEF_CAPOFFSET,
 };
 
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index a57dc8866fc5..74fea4fa41b1 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -137,6 +137,22 @@ static int hw_alloc_regmap(struct ci_hdrc *ci, bool is_lpm)
         return 0;
 }
 
+static enum ci_revision ci_get_revision(struct ci_hdrc *ci)
+{
+        int ver = hw_read_id_reg(ci, ID_ID, VERSION) >> __ffs(VERSION);
+        enum ci_revision rev = CI_REVISION_UNKNOWN;
+
+        if (ver == 0x2) {
+                rev = hw_read_id_reg(ci, ID_ID, REVISION)
+                        >> __ffs(REVISION);
+                rev += CI_REVISION_20;
+        } else if (ver == 0x0) {
+                rev = CI_REVISION_1X;
+        }
+
+        return rev;
+}
+
 /**
  * hw_read_intr_enable: returns interrupt enable register
  *
@@ -251,8 +267,11 @@ static int hw_device_init(struct ci_hdrc *ci, void __iomem *base)
         /* Clear all interrupts status bits*/
         hw_write(ci, OP_USBSTS, 0xffffffff, 0xffffffff);
 
-        dev_dbg(ci->dev, "ChipIdea HDRC found, lpm: %d; cap: %p op: %p\n",
-                ci->hw_bank.lpm, ci->hw_bank.cap, ci->hw_bank.op);
+        ci->rev = ci_get_revision(ci);
+
+        dev_dbg(ci->dev,
+                "ChipIdea HDRC found, revision: %d, lpm: %d; cap: %p op: %p\n",
+                ci->rev, ci->hw_bank.lpm, ci->hw_bank.cap, ci->hw_bank.op);
 
         /* setup lock mode ? */
 
@@ -491,6 +510,13 @@ static irqreturn_t ci_irq(int irq, void *data)
         irqreturn_t ret = IRQ_NONE;
         u32 otgsc = 0;
 
+        if (ci->in_lpm) {
+                disable_irq_nosync(irq);
+                ci->wakeup_int = true;
+                pm_runtime_get(ci->dev);
+                return IRQ_HANDLED;
+        }
+
         if (ci->is_otg) {
                 otgsc = hw_read_otgsc(ci, ~0);
                 if (ci_otg_is_fsm_mode(ci)) {
@@ -642,8 +668,12 @@ 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");
+                /* Disable and clear all OTG irq */
+                hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
+                                                        OTGSC_INT_STATUS_BITS);
+        }
 }
 
 static int ci_hdrc_probe(struct platform_device *pdev)
@@ -673,6 +703,8 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         ci->platdata = dev_get_platdata(dev);
         ci->imx28_write_fix = !!(ci->platdata->flags &
                 CI_HDRC_IMX28_WRITE_FIX);
+        ci->supports_runtime_pm = !!(ci->platdata->flags &
+                CI_HDRC_SUPPORTS_RUNTIME_PM);
 
         ret = hw_device_init(ci, base);
         if (ret < 0) {
@@ -740,9 +772,6 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         }
 
         if (ci->is_otg && ci->roles[CI_ROLE_GADGET]) {
-                /* 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);
@@ -769,11 +798,11 @@ static int ci_hdrc_probe(struct platform_device *pdev)
                         : CI_ROLE_GADGET;
         }
 
-        /* only update vbus status for peripheral */
-        if (ci->role == CI_ROLE_GADGET)
-                ci_handle_vbus_change(ci);
-
         if (!ci_otg_is_fsm_mode(ci)) {
+                /* only update vbus status for peripheral */
+                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",
@@ -788,9 +817,19 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ret)
                 goto stop;
 
+        if (ci->supports_runtime_pm) {
+                pm_runtime_set_active(&pdev->dev);
+                pm_runtime_enable(&pdev->dev);
+                pm_runtime_set_autosuspend_delay(&pdev->dev, 2000);
+                pm_runtime_mark_last_busy(ci->dev);
+                pm_runtime_use_autosuspend(&pdev->dev);
+        }
+
         if (ci_otg_is_fsm_mode(ci))
                 ci_hdrc_otg_fsm_start(ci);
 
+        device_set_wakeup_capable(&pdev->dev, true);
+
         ret = dbg_create_files(ci);
         if (!ret)
                 return 0;
@@ -807,6 +846,12 @@ static int ci_hdrc_remove(struct platform_device *pdev)
 {
         struct ci_hdrc *ci = platform_get_drvdata(pdev);
 
+        if (ci->supports_runtime_pm) {
+                pm_runtime_get_sync(&pdev->dev);
+                pm_runtime_disable(&pdev->dev);
+                pm_runtime_put_noidle(&pdev->dev);
+        }
+
         dbg_remove_files(ci);
         ci_role_destroy(ci);
         ci_hdrc_enter_lpm(ci, true);
@@ -815,13 +860,41 @@ static int ci_hdrc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
+/* Prepare wakeup by SRP before suspend */
+static void ci_otg_fsm_suspend_for_srp(struct ci_hdrc *ci)
+{
+        if ((ci->fsm.otg->state == OTG_STATE_A_IDLE) &&
+                                !hw_read_otgsc(ci, OTGSC_ID)) {
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP,
+                                                                PORTSC_PP);
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_WKCN,
+                                                                PORTSC_WKCN);
+        }
+}
+
+/* Handle SRP when wakeup by data pulse */
+static void ci_otg_fsm_wakeup_by_srp(struct ci_hdrc *ci)
+{
+        if ((ci->fsm.otg->state == OTG_STATE_A_IDLE) &&
+                (ci->fsm.a_bus_drop == 1) && (ci->fsm.a_bus_req == 0)) {
+                if (!hw_read_otgsc(ci, OTGSC_ID)) {
+                        ci->fsm.a_srp_det = 1;
+                        ci->fsm.a_bus_drop = 0;
+                } else {
+                        ci->fsm.id = 1;
+                }
+                ci_otg_queue_work(ci);
+        }
+}
+
 static void ci_controller_suspend(struct ci_hdrc *ci)
 {
+        disable_irq(ci->irq);
         ci_hdrc_enter_lpm(ci, true);
-
-        if (ci->usb_phy)
-                usb_phy_set_suspend(ci->usb_phy, 1);
+        usb_phy_set_suspend(ci->usb_phy, 1);
+        ci->in_lpm = true;
+        enable_irq(ci->irq);
 }
 
 static int ci_controller_resume(struct device *dev)
@@ -830,23 +903,59 @@ static int ci_controller_resume(struct device *dev)
 
         dev_dbg(dev, "at %s\n", __func__);
 
-        ci_hdrc_enter_lpm(ci, false);
+        if (!ci->in_lpm) {
+                WARN_ON(1);
+                return 0;
+        }
 
+        ci_hdrc_enter_lpm(ci, false);
         if (ci->usb_phy) {
                 usb_phy_set_suspend(ci->usb_phy, 0);
                 usb_phy_set_wakeup(ci->usb_phy, false);
                 hw_wait_phy_stable();
         }
 
+        ci->in_lpm = false;
+        if (ci->wakeup_int) {
+                ci->wakeup_int = false;
+                pm_runtime_mark_last_busy(ci->dev);
+                pm_runtime_put_autosuspend(ci->dev);
+                enable_irq(ci->irq);
+                if (ci_otg_is_fsm_mode(ci))
+                        ci_otg_fsm_wakeup_by_srp(ci);
+        }
+
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int ci_suspend(struct device *dev)
 {
         struct ci_hdrc *ci = dev_get_drvdata(dev);
 
         if (ci->wq)
                 flush_workqueue(ci->wq);
+        /*
+         * Controller needs to be active during suspend, otherwise the core
+         * may run resume when the parent is at suspend if other driver's
+         * suspend fails, it occurs before parent's suspend has not started,
+         * but the core suspend has finished.
+         */
+        if (ci->in_lpm)
+                pm_runtime_resume(dev);
+
+        if (ci->in_lpm) {
+                WARN_ON(1);
+                return 0;
+        }
+
+        if (device_may_wakeup(dev)) {
+                if (ci_otg_is_fsm_mode(ci))
+                        ci_otg_fsm_suspend_for_srp(ci);
+
+                usb_phy_set_wakeup(ci->usb_phy, true);
+                enable_irq_wake(ci->irq);
+        }
 
         ci_controller_suspend(ci);
 
@@ -855,13 +964,57 @@ static int ci_suspend(struct device *dev)
 
 static int ci_resume(struct device *dev)
 {
-        return ci_controller_resume(dev);
+        struct ci_hdrc *ci = dev_get_drvdata(dev);
+        int ret;
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(ci->irq);
+
+        ret = ci_controller_resume(dev);
+        if (ret)
+                return ret;
+
+        if (ci->supports_runtime_pm) {
+                pm_runtime_disable(dev);
+                pm_runtime_set_active(dev);
+                pm_runtime_enable(dev);
+        }
+
+        return ret;
 }
 #endif /* CONFIG_PM_SLEEP */
 
+static int ci_runtime_suspend(struct device *dev)
+{
+        struct ci_hdrc *ci = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "at %s\n", __func__);
+
+        if (ci->in_lpm) {
+                WARN_ON(1);
+                return 0;
+        }
+
+        if (ci_otg_is_fsm_mode(ci))
+                ci_otg_fsm_suspend_for_srp(ci);
+
+        usb_phy_set_wakeup(ci->usb_phy, true);
+        ci_controller_suspend(ci);
+
+        return 0;
+}
+
+static int ci_runtime_resume(struct device *dev)
+{
+        return ci_controller_resume(dev);
+}
+
+#endif /* CONFIG_PM */
 static const struct dev_pm_ops ci_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(ci_suspend, ci_resume)
+        SET_RUNTIME_PM_OPS(ci_runtime_suspend, ci_runtime_resume, NULL)
 };
+
 static struct platform_driver ci_hdrc_driver = {
         .probe  = ci_hdrc_probe,
         .remove = ci_hdrc_remove,
diff --git a/drivers/usb/chipidea/debug.c b/drivers/usb/chipidea/debug.c
index 268e4236e84c..dfb05edcdb96 100644
--- a/drivers/usb/chipidea/debug.c
+++ b/drivers/usb/chipidea/debug.c
@@ -336,8 +336,8 @@ static int ci_registers_show(struct seq_file *s, void *unused)
         struct ci_hdrc *ci = s->private;
         u32 tmp_reg;
 
-        if (!ci)
-                return 0;
+        if (!ci || ci->in_lpm)
+                return -EPERM;
 
         /* ------ Registers ----- */
         tmp_reg = hw_read_intr_enable(ci);
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index 48731d0bab35..21fe1a314313 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -33,6 +33,7 @@
 #include "host.h"
 
 static struct hc_driver __read_mostly ci_ehci_hc_driver;
+static int (*orig_bus_suspend)(struct usb_hcd *hcd);
 
 struct ehci_ci_priv {
         struct regulator *reg_vbus;
@@ -43,11 +44,10 @@ static int ehci_ci_portpower(struct usb_hcd *hcd, int portnum, bool enable)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         struct ehci_ci_priv *priv = (struct ehci_ci_priv *)ehci->priv;
         struct device *dev = hcd->self.controller;
-        struct ci_hdrc *ci = dev_get_drvdata(dev);
         int ret = 0;
         int port = HCS_N_PORTS(ehci->hcs_params);
 
-        if (priv->reg_vbus && !ci_otg_is_fsm_mode(ci)) {
+        if (priv->reg_vbus) {
                 if (port > 1) {
                         dev_warn(dev,
                                 "Not support multi-port regulator control\n");
@@ -113,12 +113,23 @@ static int host_start(struct ci_hdrc *ci)
         priv = (struct ehci_ci_priv *)ehci->priv;
         priv->reg_vbus = NULL;
 
-        if (ci->platdata->reg_vbus)
-                priv->reg_vbus = ci->platdata->reg_vbus;
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) {
+                if (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON) {
+                        ret = regulator_enable(ci->platdata->reg_vbus);
+                        if (ret) {
+                                dev_err(ci->dev,
+                                "Failed to enable vbus regulator, ret=%d\n",
+                                                                        ret);
+                                goto put_hcd;
+                        }
+                } else {
+                        priv->reg_vbus = ci->platdata->reg_vbus;
+                }
+        }
 
         ret = usb_add_hcd(hcd, 0, 0);
         if (ret) {
-                goto put_hcd;
+                goto disable_reg;
         } else {
                 struct usb_otg *otg = &ci->otg;
 
@@ -133,8 +144,15 @@ static int host_start(struct ci_hdrc *ci)
         if (ci->platdata->flags & CI_HDRC_DISABLE_STREAMING)
                 hw_write(ci, OP_USBMODE, USBMODE_CI_SDIS, USBMODE_CI_SDIS);
 
+        if (ci->platdata->flags & CI_HDRC_FORCE_FULLSPEED)
+                hw_write(ci, OP_PORTSC, PORTSC_PFSC, PORTSC_PFSC);
+
         return ret;
 
+disable_reg:
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) &&
+                        (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON))
+                regulator_disable(ci->platdata->reg_vbus);
 put_hcd:
         usb_put_hcd(hcd);
 
@@ -148,6 +166,9 @@ static void host_stop(struct ci_hdrc *ci)
         if (hcd) {
                 usb_remove_hcd(hcd);
                 usb_put_hcd(hcd);
+                if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) &&
+                        (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON))
+                                regulator_disable(ci->platdata->reg_vbus);
         }
 }
 
@@ -158,6 +179,47 @@ void ci_hdrc_host_destroy(struct ci_hdrc *ci)
                 host_stop(ci);
 }
 
+static int ci_ehci_bus_suspend(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int port;
+        u32 tmp;
+
+        int ret = orig_bus_suspend(hcd);
+
+        if (ret)
+                return ret;
+
+        port = HCS_N_PORTS(ehci->hcs_params);
+        while (port--) {
+                u32 __iomem *reg = &ehci->regs->port_status[port];
+                u32 portsc = ehci_readl(ehci, reg);
+
+                if (portsc & PORT_CONNECT) {
+                        /*
+                         * For chipidea, the resume signal will be ended
+                         * automatically, so for remote wakeup case, the
+                         * usbcmd.rs may not be set before the resume has
+                         * ended if other resume paths consumes too much
+                         * time (~24ms), in that case, the SOF will not
+                         * send out within 3ms after resume ends, then the
+                         * high speed device will enter full speed mode.
+                         */
+
+                        tmp = ehci_readl(ehci, &ehci->regs->command);
+                        tmp |= CMD_RUN;
+                        ehci_writel(ehci, tmp, &ehci->regs->command);
+                        /*
+                         * It needs a short delay between set RS bit and PHCD.
+                         */
+                        usleep_range(150, 200);
+                        break;
+                }
+        }
+
+        return 0;
+}
+
 int ci_hdrc_host_init(struct ci_hdrc *ci)
 {
         struct ci_role_driver *rdrv;
@@ -176,6 +238,8 @@ int ci_hdrc_host_init(struct ci_hdrc *ci)
         ci->roles[CI_ROLE_HOST] = rdrv;
 
         ehci_init_driver(&ci_ehci_hc_driver, &ehci_ci_overrides);
+        orig_bus_suspend = ci_ehci_hc_driver.bus_suspend;
+        ci_ehci_hc_driver.bus_suspend = ci_ehci_bus_suspend;
 
         return 0;
 }
diff --git a/drivers/usb/chipidea/otg.c b/drivers/usb/chipidea/otg.c
index a048b08b9d4d..ad6c87a4653c 100644
--- a/drivers/usb/chipidea/otg.c
+++ b/drivers/usb/chipidea/otg.c
@@ -96,6 +96,7 @@ static void ci_otg_work(struct work_struct *work)
                 return;
         }
 
+        pm_runtime_get_sync(ci->dev);
         if (ci->id_event) {
                 ci->id_event = false;
                 ci_handle_id_switch(ci);
@@ -104,6 +105,7 @@ static void ci_otg_work(struct work_struct *work)
                 ci_handle_vbus_change(ci);
         } else
                 dev_err(ci->dev, "unexpected event occurs at %s\n", __func__);
+        pm_runtime_put_sync(ci->dev);
 
         enable_irq(ci->irq);
 }
diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c
index 562e581f6765..083acf45ad5a 100644
--- a/drivers/usb/chipidea/otg_fsm.c
+++ b/drivers/usb/chipidea/otg_fsm.c
@@ -30,22 +30,6 @@
 #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)
@@ -204,229 +188,227 @@ static struct attribute_group inputs_attr_group = {
 };
 
 /*
+ * Keep this list in the same order as timers indexed
+ * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
+ */
+static unsigned otg_timer_ms[] = {
+        TA_WAIT_VRISE,
+        TA_WAIT_VFALL,
+        TA_WAIT_BCON,
+        TA_AIDL_BDIS,
+        TB_ASE0_BRST,
+        TA_BIDL_ADIS,
+        TB_SE0_SRP,
+        TB_SRP_FAIL,
+        0,
+        TB_DATA_PLS,
+        TB_SSEND_SRP,
+};
+
+/*
  * Add timer to active timer list
  */
-static void ci_otg_add_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+static void ci_otg_add_timer(struct ci_hdrc *ci, enum otg_fsm_timer 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;
+        unsigned long flags, timer_sec, timer_nsec;
 
-        if (t >= NUM_CI_OTG_FSM_TIMERS)
+        if (t >= NUM_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);
+        spin_lock_irqsave(&ci->lock, flags);
+        timer_sec = otg_timer_ms[t] / MSEC_PER_SEC;
+        timer_nsec = (otg_timer_ms[t] % MSEC_PER_SEC) * NSEC_PER_MSEC;
+        ci->hr_timeouts[t] = ktime_add(ktime_get(),
+                                ktime_set(timer_sec, timer_nsec));
+        ci->enabled_otg_timer_bits |= (1 << t);
+        if ((ci->next_otg_timer == NUM_OTG_FSM_TIMERS) ||
+                        (ci->hr_timeouts[ci->next_otg_timer].tv64 >
+                                                ci->hr_timeouts[t].tv64)) {
+                        ci->next_otg_timer = t;
+                        hrtimer_start_range_ns(&ci->otg_fsm_hrtimer,
+                                        ci->hr_timeouts[t], NSEC_PER_MSEC,
+                                                        HRTIMER_MODE_ABS);
+        }
+        spin_unlock_irqrestore(&ci->lock, flags);
 }
 
 /*
  * Remove timer from active timer list
  */
-static void ci_otg_del_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer 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;
+        unsigned long flags, enabled_timer_bits;
+        enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS;
 
-        if (t >= NUM_CI_OTG_FSM_TIMERS)
+        if ((t >= NUM_OTG_FSM_TIMERS) ||
+                        !(ci->enabled_otg_timer_bits & (1 << t)))
                 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;
+        spin_lock_irqsave(&ci->lock, flags);
+        ci->enabled_otg_timer_bits &= ~(1 << t);
+        if (ci->next_otg_timer == t) {
+                if (ci->enabled_otg_timer_bits == 0) {
+                        /* No enabled timers after delete it */
+                        hrtimer_cancel(&ci->otg_fsm_hrtimer);
+                        ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
+                } else {
+                        /* Find the next timer */
+                        enabled_timer_bits = ci->enabled_otg_timer_bits;
+                        for_each_set_bit(cur_timer, &enabled_timer_bits,
+                                                        NUM_OTG_FSM_TIMERS) {
+                                if ((next_timer == NUM_OTG_FSM_TIMERS) ||
+                                        (ci->hr_timeouts[next_timer].tv64 <
+                                        ci->hr_timeouts[cur_timer].tv64))
+                                        next_timer = cur_timer;
+                        }
                 }
         }
-
-        /* 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;
+        if (next_timer != NUM_OTG_FSM_TIMERS) {
+                ci->next_otg_timer = next_timer;
+                hrtimer_start_range_ns(&ci->otg_fsm_hrtimer,
+                        ci->hr_timeouts[next_timer], NSEC_PER_MSEC,
+                                                        HRTIMER_MODE_ABS);
+        }
+        spin_unlock_irqrestore(&ci->lock, flags);
 }
 
-/* The timeout callback function to set time out bit */
-static void set_tmout(void *ptr, unsigned long indicator)
+/* OTG FSM timer handlers */
+static int a_wait_vrise_tmout(struct ci_hdrc *ci)
 {
-        *(int *)indicator = 1;
+        ci->fsm.a_wait_vrise_tmout = 1;
+        return 0;
 }
 
-static void set_tmout_and_fsm(void *ptr, unsigned long indicator)
+static int a_wait_vfall_tmout(struct ci_hdrc *ci)
 {
-        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
-
-        set_tmout(ci, indicator);
-
-        ci_otg_queue_work(ci);
+        ci->fsm.a_wait_vfall_tmout = 1;
+        return 0;
 }
 
-static void a_wait_vfall_tmout_func(void *ptr, unsigned long indicator)
+static int a_wait_bcon_tmout(struct ci_hdrc *ci)
 {
-        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 existing 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);
+        ci->fsm.a_wait_bcon_tmout = 1;
+        return 0;
 }
 
-static void b_ase0_brst_tmout_func(void *ptr, unsigned long indicator)
+static int a_aidl_bdis_tmout(struct ci_hdrc *ci)
 {
-        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);
+        ci->fsm.a_aidl_bdis_tmout = 1;
+        return 0;
 }
 
-static void b_ssend_srp_tmout_func(void *ptr, unsigned long indicator)
+static int b_ase0_brst_tmout(struct ci_hdrc *ci)
 {
-        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->fsm.otg->state == OTG_STATE_B_IDLE)
-                ci_otg_queue_work(ci);
+        ci->fsm.b_ase0_brst_tmout = 1;
+        return 0;
 }
 
-static void b_sess_vld_tmout_func(void *ptr, unsigned long indicator)
+static int a_bidl_adis_tmout(struct ci_hdrc *ci)
 {
-        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+        ci->fsm.a_bidl_adis_tmout = 1;
+        return 0;
+}
 
-        /* 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 int b_se0_srp_tmout(struct ci_hdrc *ci)
+{
+        ci->fsm.b_se0_srp = 1;
+        return 0;
 }
 
-static void b_data_pulse_end(void *ptr, unsigned long indicator)
+static int b_srp_fail_tmout(struct ci_hdrc *ci)
 {
-        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+        ci->fsm.b_srp_done = 1;
+        return 1;
+}
 
+static int b_data_pls_tmout(struct ci_hdrc *ci)
+{
         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);
+        pm_runtime_put(ci->dev);
+        return 0;
+}
 
-        ci_otg_queue_work(ci);
+static int b_ssend_srp_tmout(struct ci_hdrc *ci)
+{
+        ci->fsm.b_ssend_srp = 1;
+        /* only vbus fall below B_sess_vld in b_idle state */
+        if (ci->fsm.otg->state == OTG_STATE_B_IDLE)
+                return 0;
+        else
+                return 1;
+}
+
+/*
+ * Keep this list in the same order as timers indexed
+ * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
+ */
+static int (*otg_timer_handlers[])(struct ci_hdrc *) = {
+        a_wait_vrise_tmout,     /* A_WAIT_VRISE */
+        a_wait_vfall_tmout,     /* A_WAIT_VFALL */
+        a_wait_bcon_tmout,      /* A_WAIT_BCON */
+        a_aidl_bdis_tmout,      /* A_AIDL_BDIS */
+        b_ase0_brst_tmout,      /* B_ASE0_BRST */
+        a_bidl_adis_tmout,      /* A_BIDL_ADIS */
+        b_se0_srp_tmout,        /* B_SE0_SRP */
+        b_srp_fail_tmout,       /* B_SRP_FAIL */
+        NULL,                   /* A_WAIT_ENUM */
+        b_data_pls_tmout,       /* B_DATA_PLS */
+        b_ssend_srp_tmout,      /* B_SSEND_SRP */
+};
+
+/*
+ * Enable the next nearest enabled timer if have
+ */
+static enum hrtimer_restart ci_otg_hrtimer_func(struct hrtimer *t)
+{
+        struct ci_hdrc *ci = container_of(t, struct ci_hdrc, otg_fsm_hrtimer);
+        ktime_t now, *timeout;
+        unsigned long   enabled_timer_bits;
+        unsigned long   flags;
+        enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&ci->lock, flags);
+        enabled_timer_bits = ci->enabled_otg_timer_bits;
+        ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
+
+        now = ktime_get();
+        for_each_set_bit(cur_timer, &enabled_timer_bits, NUM_OTG_FSM_TIMERS) {
+                if (now.tv64 >= ci->hr_timeouts[cur_timer].tv64) {
+                        ci->enabled_otg_timer_bits &= ~(1 << cur_timer);
+                        if (otg_timer_handlers[cur_timer])
+                                ret = otg_timer_handlers[cur_timer](ci);
+                } else {
+                        if ((next_timer == NUM_OTG_FSM_TIMERS) ||
+                                (ci->hr_timeouts[cur_timer].tv64 <
+                                        ci->hr_timeouts[next_timer].tv64))
+                                next_timer = cur_timer;
+                }
+        }
+        /* Enable the next nearest timer */
+        if (next_timer < NUM_OTG_FSM_TIMERS) {
+                timeout = &ci->hr_timeouts[next_timer];
+                hrtimer_start_range_ns(&ci->otg_fsm_hrtimer, *timeout,
+                                        NSEC_PER_MSEC, HRTIMER_MODE_ABS);
+                ci->next_otg_timer = next_timer;
+        }
+        spin_unlock_irqrestore(&ci->lock, flags);
+
+        if (!ret)
+                ci_otg_queue_work(ci);
+
+        return HRTIMER_NORESTART;
 }
 
 /* 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;
+        hrtimer_init(&ci->otg_fsm_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+        ci->otg_fsm_hrtimer.function = ci_otg_hrtimer_func;
 
         return 0;
 }
@@ -530,6 +512,7 @@ static void ci_otg_start_pulse(struct otg_fsm *fsm)
         /* Hardware Assistant Data pulse */
         hw_write_otgsc(ci, OTGSC_HADP, OTGSC_HADP);
 
+        pm_runtime_get(ci->dev);
         ci_otg_add_timer(ci, B_DATA_PLS);
 }
 
@@ -585,6 +568,7 @@ int ci_otg_fsm_work(struct ci_hdrc *ci)
                 ci->fsm.otg->state < OTG_STATE_A_IDLE)
                 return 0;
 
+        pm_runtime_get_sync(ci->dev);
         if (otg_statemachine(&ci->fsm)) {
                 if (ci->fsm.otg->state == OTG_STATE_A_IDLE) {
                         /*
@@ -596,8 +580,15 @@ int ci_otg_fsm_work(struct ci_hdrc *ci)
                          * a_idle to a_wait_vrise when power up
                          */
                         if ((ci->fsm.id) || (ci->id_event) ||
-                                                (ci->fsm.power_up))
+                                                (ci->fsm.power_up)) {
                                 ci_otg_queue_work(ci);
+                        } else {
+                                /* Enable data pulse irq */
+                                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS |
+                                                                PORTSC_PP, 0);
+                                hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
+                                hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE);
+                        }
                         if (ci->id_event)
                                 ci->id_event = false;
                 } else if (ci->fsm.otg->state == OTG_STATE_B_IDLE) {
@@ -609,8 +600,13 @@ int ci_otg_fsm_work(struct ci_hdrc *ci)
                                  */
                                 ci_otg_queue_work(ci);
                         }
+                } else if (ci->fsm.otg->state == OTG_STATE_A_HOST) {
+                        pm_runtime_mark_last_busy(ci->dev);
+                        pm_runtime_put_autosuspend(ci->dev);
+                        return 0;
                 }
         }
+        pm_runtime_put_sync(ci->dev);
         return 0;
 }
 
@@ -655,7 +651,6 @@ static void ci_otg_fsm_event(struct ci_hdrc *ci)
                         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:
@@ -725,11 +720,7 @@ irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
         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) {
+                if (otg_int_src & OTGSC_DPIS) {
                         hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
                         fsm->a_srp_det = 1;
                         fsm->a_bus_drop = 0;
@@ -793,17 +784,13 @@ int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
 
         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)
-                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;
         }
+        ci->enabled_otg_timer_bits = 0;
+        ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
 
         retval = sysfs_create_group(&ci->dev->kobj, &inputs_attr_group);
         if (retval < 0) {
diff --git a/drivers/usb/chipidea/otg_fsm.h b/drivers/usb/chipidea/otg_fsm.h
index 94c085f456a9..2689375ae5da 100644
--- a/drivers/usb/chipidea/otg_fsm.h
+++ b/drivers/usb/chipidea/otg_fsm.h
@@ -62,33 +62,6 @@
 /* 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);
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index ff451048c1ac..764f668d45a9 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -86,10 +86,8 @@ static int hw_device_state(struct ci_hdrc *ci, u32 dma)
                 /* interrupt, error, port change, reset, sleep/suspend */
                 hw_write(ci, OP_USBINTR, ~0,
                              USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
-                hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
         } else {
                 hw_write(ci, OP_USBINTR, ~0, 0);
-                hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
         }
         return 0;
 }
@@ -522,6 +520,20 @@ static void free_pending_td(struct ci_hw_ep *hwep)
         kfree(pending);
 }
 
+static int reprime_dtd(struct ci_hdrc *ci, struct ci_hw_ep *hwep,
+                                           struct td_node *node)
+{
+        hwep->qh.ptr->td.next = node->dma;
+        hwep->qh.ptr->td.token &=
+                cpu_to_le32(~(TD_STATUS_HALTED | TD_STATUS_ACTIVE));
+
+        /* Synchronize before ep prime */
+        wmb();
+
+        return hw_ep_prime(ci, hwep->num, hwep->dir,
+                                hwep->type == USB_ENDPOINT_XFER_CONTROL);
+}
+
 /**
  * _hardware_dequeue: handles a request at hardware level
  * @gadget: gadget
@@ -535,6 +547,7 @@ static int _hardware_dequeue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
         struct td_node *node, *tmpnode;
         unsigned remaining_length;
         unsigned actual = hwreq->req.length;
+        struct ci_hdrc *ci = hwep->ci;
 
         if (hwreq->req.status != -EALREADY)
                 return -EINVAL;
@@ -544,6 +557,11 @@ static int _hardware_dequeue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
         list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
                 tmptoken = le32_to_cpu(node->ptr->token);
                 if ((TD_STATUS_ACTIVE & tmptoken) != 0) {
+                        int n = hw_ep_bit(hwep->num, hwep->dir);
+
+                        if (ci->rev == CI_REVISION_24)
+                                if (!hw_read(ci, OP_ENDPTSTAT, BIT(n)))
+                                        reprime_dtd(ci, hwep, node);
                         hwreq->req.status = -EALREADY;
                         return -EBUSY;
                 }
@@ -929,6 +947,13 @@ __acquires(hwep->lock)
         return retval;
 }
 
+static int otg_a_alt_hnp_support(struct ci_hdrc *ci)
+{
+        dev_warn(&ci->gadget.dev,
+                "connect the device to an alternate port if you want HNP\n");
+        return isr_setup_status_phase(ci);
+}
+
 /**
  * isr_setup_packet_handler: setup packet handler
  * @ci: UDC descriptor
@@ -1061,6 +1086,10 @@ __acquires(ci->lock)
                                                         ci);
                                 }
                                 break;
+                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
+                                if (ci_otg_is_fsm_mode(ci))
+                                        err = otg_a_alt_hnp_support(ci);
+                                break;
                         default:
                                 goto delegate;
                         }
@@ -1151,10 +1180,13 @@ static int ep_enable(struct usb_ep *ep,
 
         /* only internal SW should enable ctrl endpts */
 
-        hwep->ep.desc = desc;
-
-        if (!list_empty(&hwep->qh.queue))
+        if (!list_empty(&hwep->qh.queue)) {
                 dev_warn(hwep->ci->dev, "enabling a non-empty endpoint!\n");
+                spin_unlock_irqrestore(hwep->lock, flags);
+                return -EBUSY;
+        }
+
+        hwep->ep.desc = desc;
 
         hwep->dir  = usb_endpoint_dir_in(desc) ? TX : RX;
         hwep->num  = usb_endpoint_num(desc);
@@ -1474,7 +1506,9 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                         hw_device_reset(ci);
                         hw_device_state(ci, ci->ep0out->qh.dma);
                         usb_gadget_set_state(_gadget, USB_STATE_POWERED);
+                        usb_udc_vbus_handler(_gadget, true);
                 } else {
+                        usb_udc_vbus_handler(_gadget, false);
                         if (ci->driver)
                                 ci->driver->disconnect(&ci->gadget);
                         hw_device_state(ci, 0);
@@ -1540,13 +1574,16 @@ static int ci_udc_pullup(struct usb_gadget *_gadget, int is_on)
 {
         struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
 
-        if (!ci->vbus_active)
-                return -EOPNOTSUPP;
+        /* Data+ pullup controlled by OTG state machine in OTG fsm mode */
+        if (ci_otg_is_fsm_mode(ci))
+                return 0;
 
+        pm_runtime_get_sync(&ci->gadget.dev);
         if (is_on)
                 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
         else
                 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
+        pm_runtime_put_sync(&ci->gadget.dev);
 
         return 0;
 }
@@ -1676,6 +1713,7 @@ static int ci_udc_start(struct usb_gadget *gadget,
                 spin_lock_irqsave(&ci->lock, flags);
                 hw_device_reset(ci);
         } else {
+                usb_udc_vbus_handler(&ci->gadget, false);
                 pm_runtime_put_sync(&ci->gadget.dev);
                 return retval;
         }
diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbmisc_imx.c
index c3c6225b8acf..140945cb124f 100644
--- a/drivers/usb/chipidea/usbmisc_imx.c
+++ b/drivers/usb/chipidea/usbmisc_imx.c
@@ -11,7 +11,6 @@
 
 #include <linux/module.h>
 #include <linux/of_platform.h>
-#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/delay.h>
@@ -56,6 +55,19 @@
 #define MX53_USB_PLL_DIV_24_MHZ         0x01
 
 #define MX6_BM_OVER_CUR_DIS             BIT(7)
+#define MX6_BM_WAKEUP_ENABLE            BIT(10)
+#define MX6_BM_ID_WAKEUP                BIT(16)
+#define MX6_BM_VBUS_WAKEUP              BIT(17)
+#define MX6SX_BM_DPDM_WAKEUP_EN         BIT(29)
+#define MX6_BM_WAKEUP_INTR              BIT(31)
+#define MX6_USB_OTG1_PHY_CTRL           0x18
+/* For imx6dql, it is host-only controller, for later imx6, it is otg's */
+#define MX6_USB_OTG2_PHY_CTRL           0x1c
+#define MX6SX_USB_VBUS_WAKEUP_SOURCE(v) (v << 8)
+#define MX6SX_USB_VBUS_WAKEUP_SOURCE_VBUS       MX6SX_USB_VBUS_WAKEUP_SOURCE(0)
+#define MX6SX_USB_VBUS_WAKEUP_SOURCE_AVALID     MX6SX_USB_VBUS_WAKEUP_SOURCE(1)
+#define MX6SX_USB_VBUS_WAKEUP_SOURCE_BVALID     MX6SX_USB_VBUS_WAKEUP_SOURCE(2)
+#define MX6SX_USB_VBUS_WAKEUP_SOURCE_SESS_END   MX6SX_USB_VBUS_WAKEUP_SOURCE(3)
 
 #define VF610_OVER_CUR_DIS              BIT(7)
 
@@ -64,12 +76,13 @@ struct usbmisc_ops {
         int (*init)(struct imx_usbmisc_data *data);
         /* It's called once after adding a usb device */
         int (*post)(struct imx_usbmisc_data *data);
+        /* It's called when we need to enable/disable usb wakeup */
+        int (*set_wakeup)(struct imx_usbmisc_data *data, bool enabled);
 };
 
 struct imx_usbmisc {
         void __iomem *base;
         spinlock_t lock;
-        struct clk *clk;
         const struct usbmisc_ops *ops;
 };
 
@@ -204,6 +217,35 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
         return 0;
 }
 
+static int usbmisc_imx6q_set_wakeup
+        (struct imx_usbmisc_data *data, bool enabled)
+{
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+        unsigned long flags;
+        u32 val;
+        u32 wakeup_setting = (MX6_BM_WAKEUP_ENABLE |
+                MX6_BM_VBUS_WAKEUP | MX6_BM_ID_WAKEUP);
+        int ret = 0;
+
+        if (data->index > 3)
+                return -EINVAL;
+
+        spin_lock_irqsave(&usbmisc->lock, flags);
+        val = readl(usbmisc->base + data->index * 4);
+        if (enabled) {
+                val |= wakeup_setting;
+                writel(val, usbmisc->base + data->index * 4);
+        } else {
+                if (val & MX6_BM_WAKEUP_INTR)
+                        pr_debug("wakeup int at ci_hdrc.%d\n", data->index);
+                val &= ~wakeup_setting;
+                writel(val, usbmisc->base + data->index * 4);
+        }
+        spin_unlock_irqrestore(&usbmisc->lock, flags);
+
+        return ret;
+}
+
 static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 {
         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
@@ -221,6 +263,36 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
                 spin_unlock_irqrestore(&usbmisc->lock, flags);
         }
 
+        usbmisc_imx6q_set_wakeup(data, false);
+
+        return 0;
+}
+
+static int usbmisc_imx6sx_init(struct imx_usbmisc_data *data)
+{
+        void __iomem *reg = NULL;
+        unsigned long flags;
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+        u32 val;
+
+        usbmisc_imx6q_init(data);
+
+        if (data->index == 0 || data->index == 1) {
+                reg = usbmisc->base + MX6_USB_OTG1_PHY_CTRL + data->index * 4;
+                spin_lock_irqsave(&usbmisc->lock, flags);
+                /* Set vbus wakeup source as bvalid */
+                val = readl(reg);
+                writel(val | MX6SX_USB_VBUS_WAKEUP_SOURCE_BVALID, reg);
+                /*
+                 * Disable dp/dm wakeup in device mode when vbus is
+                 * not there.
+                 */
+                val = readl(usbmisc->base + data->index * 4);
+                writel(val & ~MX6SX_BM_DPDM_WAKEUP_EN,
+                        usbmisc->base + data->index * 4);
+                spin_unlock_irqrestore(&usbmisc->lock, flags);
+        }
+
         return 0;
 }
 
@@ -258,6 +330,7 @@ static const struct usbmisc_ops imx53_usbmisc_ops = {
 };
 
 static const struct usbmisc_ops imx6q_usbmisc_ops = {
+        .set_wakeup = usbmisc_imx6q_set_wakeup,
         .init = usbmisc_imx6q_init,
 };
 
@@ -265,10 +338,19 @@ static const struct usbmisc_ops vf610_usbmisc_ops = {
         .init = usbmisc_vf610_init,
 };
 
+static const struct usbmisc_ops imx6sx_usbmisc_ops = {
+        .set_wakeup = usbmisc_imx6q_set_wakeup,
+        .init = usbmisc_imx6sx_init,
+};
+
 int imx_usbmisc_init(struct imx_usbmisc_data *data)
 {
-        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+        struct imx_usbmisc *usbmisc;
+
+        if (!data)
+                return 0;
 
+        usbmisc = dev_get_drvdata(data->dev);
         if (!usbmisc->ops->init)
                 return 0;
         return usbmisc->ops->init(data);
@@ -277,14 +359,32 @@ EXPORT_SYMBOL_GPL(imx_usbmisc_init);
 
 int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
 {
-        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+        struct imx_usbmisc *usbmisc;
 
+        if (!data)
+                return 0;
+
+        usbmisc = dev_get_drvdata(data->dev);
         if (!usbmisc->ops->post)
                 return 0;
         return usbmisc->ops->post(data);
 }
 EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);
 
+int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *data, bool enabled)
+{
+        struct imx_usbmisc *usbmisc;
+
+        if (!data)
+                return 0;
+
+        usbmisc = dev_get_drvdata(data->dev);
+        if (!usbmisc->ops->set_wakeup)
+                return 0;
+        return usbmisc->ops->set_wakeup(data, enabled);
+}
+EXPORT_SYMBOL_GPL(imx_usbmisc_set_wakeup);
+
 static const struct of_device_id usbmisc_imx_dt_ids[] = {
         {
                 .compatible = "fsl,imx25-usbmisc",
@@ -314,6 +414,10 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = {
                 .compatible = "fsl,vf610-usbmisc",
                 .data = &vf610_usbmisc_ops,
         },
+        {
+                .compatible = "fsl,imx6sx-usbmisc",
+                .data = &imx6sx_usbmisc_ops,
+        },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
@@ -322,7 +426,6 @@ static int usbmisc_imx_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct imx_usbmisc *data;
-        int ret;
         struct of_device_id *tmp_dev;
 
         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
@@ -336,20 +439,6 @@ static int usbmisc_imx_probe(struct platform_device *pdev)
         if (IS_ERR(data->base))
                 return PTR_ERR(data->base);
 
-        data->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(data->clk)) {
-                dev_err(&pdev->dev,
-                        "failed to get clock, err=%ld\n", PTR_ERR(data->clk));
-                return PTR_ERR(data->clk);
-        }
-
-        ret = clk_prepare_enable(data->clk);
-        if (ret) {
-                dev_err(&pdev->dev,
-                        "clk_prepare_enable failed, err=%d\n", ret);
-                return ret;
-        }
-
         tmp_dev = (struct of_device_id *)
                 of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
         data->ops = (const struct usbmisc_ops *)tmp_dev->data;
@@ -360,8 +449,6 @@ static int usbmisc_imx_probe(struct platform_device *pdev)
 
 static int usbmisc_imx_remove(struct platform_device *pdev)
 {
-        struct imx_usbmisc *usbmisc = dev_get_drvdata(&pdev->dev);
-        clk_disable_unprepare(usbmisc->clk);
         return 0;
 }
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 683617714e7c..3e15add665e2 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -360,7 +360,7 @@ static void acm_ctrl_irq(struct urb *urb)
         }
 exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
-        if (retval)
+        if (retval && retval != -EPERM)
                 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
                                                         __func__, retval);
 }
@@ -417,25 +417,33 @@ static void acm_read_bulk_callback(struct urb *urb)
         struct acm_rb *rb = urb->context;
         struct acm *acm = rb->instance;
         unsigned long flags;
+        int status = urb->status;
 
         dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
                                         rb->index, urb->actual_length);
-        set_bit(rb->index, &acm->read_urbs_free);
 
         if (!acm->dev) {
+                set_bit(rb->index, &acm->read_urbs_free);
                 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
                 return;
         }
 
-        if (urb->status) {
+        if (status) {
+                set_bit(rb->index, &acm->read_urbs_free);
                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
-                                                        __func__, urb->status);
+                                                        __func__, status);
                 return;
         }
 
         usb_mark_last_busy(acm->dev);
 
         acm_process_read_urb(acm, urb);
+        /*
+         * Unthrottle may run on another CPU which needs to see events
+         * in the same order. Submission has an implict barrier
+         */
+        smp_mb__before_atomic();
+        set_bit(rb->index, &acm->read_urbs_free);
 
         /* throttle device if requested by tty */
         spin_lock_irqsave(&acm->read_lock, flags);
@@ -454,13 +462,14 @@ static void acm_write_bulk(struct urb *urb)
         struct acm_wb *wb = urb->context;
         struct acm *acm = wb->instance;
         unsigned long flags;
+        int status = urb->status;
 
-        if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
+        if (status || (urb->actual_length != urb->transfer_buffer_length))
                 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
                         __func__,
                         urb->actual_length,
                         urb->transfer_buffer_length,
-                        urb->status);
+                        status);
 
         spin_lock_irqsave(&acm->write_lock, flags);
         acm_write_done(acm, wb);
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index a051a7a2b1bd..61ea87917433 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -245,7 +245,7 @@ static void wdm_int_callback(struct urb *urb)
         case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
                 dev_dbg(&desc->intf->dev,
                         "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
-                        dr->wIndex, dr->wLength);
+                        le16_to_cpu(dr->wIndex), le16_to_cpu(dr->wLength));
                 break;
 
         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
@@ -262,7 +262,9 @@ static void wdm_int_callback(struct urb *urb)
                 clear_bit(WDM_POLL_RUNNING, &desc->flags);
                 dev_err(&desc->intf->dev,
                         "unknown notification %d received: index %d len %d\n",
-                        dr->bNotificationType, dr->wIndex, dr->wLength);
+                        dr->bNotificationType,
+                        le16_to_cpu(dr->wIndex),
+                        le16_to_cpu(dr->wLength));
                 goto exit;
         }
 
@@ -339,7 +341,7 @@ static ssize_t wdm_write
         desc->werr = 0;
         spin_unlock_irq(&desc->iuspin);
         if (we < 0)
-                return -EIO;
+                return usb_translate_errors(we);
 
         buf = kmalloc(count, GFP_KERNEL);
         if (!buf) {
@@ -349,30 +351,25 @@ static ssize_t wdm_write
 
         r = copy_from_user(buf, buffer, count);
         if (r > 0) {
-                kfree(buf);
                 rv = -EFAULT;
-                goto outnl;
+                goto out_free_mem;
         }
 
         /* concurrent writes and disconnect */
         r = mutex_lock_interruptible(&desc->wlock);
         rv = -ERESTARTSYS;
-        if (r) {
-                kfree(buf);
-                goto outnl;
-        }
+        if (r)
+                goto out_free_mem;
 
         if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
-                kfree(buf);
                 rv = -ENODEV;
-                goto outnp;
+                goto out_free_mem_lock;
         }
 
         r = usb_autopm_get_interface(desc->intf);
         if (r < 0) {
-                kfree(buf);
                 rv = usb_translate_errors(r);
-                goto outnp;
+                goto out_free_mem_lock;
         }
 
         if (!(file->f_flags & O_NONBLOCK))
@@ -386,9 +383,8 @@ static ssize_t wdm_write
                 r = -EIO;
 
         if (r < 0) {
-                kfree(buf);
                 rv = r;
-                goto out;
+                goto out_free_mem_pm;
         }
 
         req = desc->orq;
@@ -408,28 +404,35 @@ static ssize_t wdm_write
                              USB_RECIP_INTERFACE);
         req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
         req->wValue = 0;
-        req->wIndex = desc->inum;
+        req->wIndex = desc->inum; /* already converted */
         req->wLength = cpu_to_le16(count);
         set_bit(WDM_IN_USE, &desc->flags);
         desc->outbuf = buf;
 
         rv = usb_submit_urb(desc->command, GFP_KERNEL);
         if (rv < 0) {
-                kfree(buf);
                 desc->outbuf = NULL;
                 clear_bit(WDM_IN_USE, &desc->flags);
                 dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
                 rv = usb_translate_errors(rv);
+                goto out_free_mem_pm;
         } else {
                 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
-                        req->wIndex);
+                        le16_to_cpu(req->wIndex));
         }
-out:
+
         usb_autopm_put_interface(desc->intf);
-outnp:
         mutex_unlock(&desc->wlock);
 outnl:
         return rv < 0 ? rv : count;
+
+out_free_mem_pm:
+        usb_autopm_put_interface(desc->intf);
+out_free_mem_lock:
+        mutex_unlock(&desc->wlock);
+out_free_mem:
+        kfree(buf);
+        return rv;
 }
 
 /*
@@ -519,9 +522,9 @@ retry:
                 spin_lock_irq(&desc->iuspin);
 
                 if (desc->rerr) { /* read completed, error happened */
+                        rv = usb_translate_errors(desc->rerr);
                         desc->rerr = 0;
                         spin_unlock_irq(&desc->iuspin);
-                        rv = -EIO;
                         goto err;
                 }
                 /*
@@ -820,7 +823,7 @@ static int wdm_create(struct usb_interface *intf, struct usb_endpoint_descriptor
         desc->irq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
         desc->irq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
         desc->irq->wValue = 0;
-        desc->irq->wIndex = desc->inum;
+        desc->irq->wIndex = desc->inum; /* already converted */
         desc->irq->wLength = cpu_to_le16(desc->wMaxCommand);
 
         usb_fill_control_urb(
diff --git a/drivers/usb/common/usb-otg-fsm.c b/drivers/usb/common/usb-otg-fsm.c
index c6b35b77dab7..61d538aa2346 100644
--- a/drivers/usb/common/usb-otg-fsm.c
+++ b/drivers/usb/common/usb-otg-fsm.c
@@ -150,9 +150,9 @@ static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 break;
         case OTG_STATE_B_PERIPHERAL:
                 otg_chrg_vbus(fsm, 0);
-                otg_loc_conn(fsm, 1);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_GADGET);
+                otg_loc_conn(fsm, 1);
                 break;
         case OTG_STATE_B_WAIT_ACON:
                 otg_chrg_vbus(fsm, 0);
@@ -213,10 +213,10 @@ static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 
                 break;
         case OTG_STATE_A_PERIPHERAL:
-                otg_loc_conn(fsm, 1);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_GADGET);
                 otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 1);
                 otg_add_timer(fsm, A_BIDL_ADIS);
                 break;
         case OTG_STATE_A_WAIT_VFALL:
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 11635537c052..4b0448c26810 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -2408,7 +2408,7 @@ static int usbdev_notify(struct notifier_block *self,
 }
 
 static struct notifier_block usbdev_nb = {
-        .notifier_call =        usbdev_notify,
+        .notifier_call =        usbdev_notify,
 };
 
 static struct cdev usb_device_cdev;
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index d7c3d5a35946..3b7151687776 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -3406,10 +3406,10 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         if (status) {
                 dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
         } else {
-                /* drive resume for at least 20 msec */
+                /* drive resume for USB_RESUME_TIMEOUT msec */
                 dev_dbg(&udev->dev, "usb %sresume\n",
                                 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
-                msleep(25);
+                msleep(USB_RESUME_TIMEOUT);
 
                 /* Virtual root hubs can trigger on GET_PORT_STATUS to
                  * stop resume signaling.  Then finish the resume
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index b1fb9aef0f5b..8d5b2f4113cd 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -49,6 +49,22 @@ const char *usbcore_name = "usbcore";
 
 static bool nousb;      /* Disable USB when built into kernel image */
 
+/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
+#ifdef MODULE
+module_param(nousb, bool, 0444);
+#else
+core_param(nousb, nousb, bool, 0444);
+#endif
+
+/*
+ * for external read access to <nousb>
+ */
+int usb_disabled(void)
+{
+        return nousb;
+}
+EXPORT_SYMBOL_GPL(usb_disabled);
+
 #ifdef  CONFIG_PM
 static int usb_autosuspend_delay = 2;           /* Default delay value,
                                                  * in seconds */
@@ -964,22 +980,6 @@ void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
 EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
 #endif
 
-/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
-#ifdef MODULE
-module_param(nousb, bool, 0444);
-#else
-core_param(nousb, nousb, bool, 0444);
-#endif
-
-/*
- * for external read access to <nousb>
- */
-int usb_disabled(void)
-{
-        return nousb;
-}
-EXPORT_SYMBOL_GPL(usb_disabled);
-
 /*
  * Notifications of device and interface registration
  */
@@ -1045,7 +1045,7 @@ static void usb_debugfs_cleanup(void)
 static int __init usb_init(void)
 {
         int retval;
-        if (nousb) {
+        if (usb_disabled()) {
                 pr_info("%s: USB support disabled\n", usbcore_name);
                 return 0;
         }
@@ -1102,7 +1102,7 @@ out:
 static void __exit usb_exit(void)
 {
         /* This will matter if shutdown/reboot does exitcalls. */
-        if (nousb)
+        if (usb_disabled())
                 return;
 
         usb_deregister_device_driver(&usb_generic_driver);
diff --git a/drivers/usb/dwc2/Kconfig b/drivers/usb/dwc2/Kconfig
index 76b9ba4dc925..1bcb36ae6505 100644
--- a/drivers/usb/dwc2/Kconfig
+++ b/drivers/usb/dwc2/Kconfig
@@ -59,11 +59,13 @@ config USB_DWC2_PLATFORM
 
 config USB_DWC2_PCI
         tristate "DWC2 PCI"
-        depends on USB_DWC2_HOST && PCI
-        default USB_DWC2_HOST
+        depends on PCI
+        default n
+        select USB_DWC2_PLATFORM
+        select NOP_USB_XCEIV
         help
           The Designware USB2.0 PCI interface module for controllers
-          connected to a PCI bus. This is only used for host mode.
+          connected to a PCI bus.
 
 config USB_DWC2_DEBUG
         bool "Enable Debugging Messages"
diff --git a/drivers/usb/dwc2/Makefile b/drivers/usb/dwc2/Makefile
index 8f752679752a..f07b425eaff3 100644
--- a/drivers/usb/dwc2/Makefile
+++ b/drivers/usb/dwc2/Makefile
@@ -19,10 +19,8 @@ endif
 # mode. The PCI bus interface module will called dwc2_pci.ko and the platform
 # interface module will be called dwc2_platform.ko.
 
-ifneq ($(CONFIG_USB_DWC2_PCI),)
-        obj-$(CONFIG_USB_DWC2)          += dwc2_pci.o
-        dwc2_pci-y                      := pci.o
-endif
+obj-$(CONFIG_USB_DWC2_PCI)              += dwc2_pci.o
+dwc2_pci-y                              := pci.o
 
 obj-$(CONFIG_USB_DWC2_PLATFORM)         += dwc2_platform.o
 dwc2_platform-y                         := platform.o
diff --git a/drivers/usb/dwc2/core.h b/drivers/usb/dwc2/core.h
index f74304b12652..836c012c7707 100644
--- a/drivers/usb/dwc2/core.h
+++ b/drivers/usb/dwc2/core.h
@@ -593,6 +593,8 @@ struct dwc2_hsotg {
         struct dwc2_core_params *core_params;
         enum usb_otg_state op_state;
         enum usb_dr_mode dr_mode;
+        unsigned int hcd_enabled:1;
+        unsigned int gadget_enabled:1;
 
         struct phy *phy;
         struct usb_phy *uphy;
diff --git a/drivers/usb/dwc2/core_intr.c b/drivers/usb/dwc2/core_intr.c
index 02e3e2d4ea56..6cf047878dba 100644
--- a/drivers/usb/dwc2/core_intr.c
+++ b/drivers/usb/dwc2/core_intr.c
@@ -377,6 +377,9 @@ static void dwc2_handle_disconnect_intr(struct dwc2_hsotg *hsotg)
                 dwc2_is_host_mode(hsotg) ? "Host" : "Device",
                 dwc2_op_state_str(hsotg));
 
+        if (hsotg->op_state == OTG_STATE_A_HOST)
+                dwc2_hcd_disconnect(hsotg);
+
         /* Change to L3 (OFF) state */
         hsotg->lx_state = DWC2_L3;
 
diff --git a/drivers/usb/dwc2/hcd.c b/drivers/usb/dwc2/hcd.c
index c78c8740db1d..fbbbac2150a5 100644
--- a/drivers/usb/dwc2/hcd.c
+++ b/drivers/usb/dwc2/hcd.c
@@ -257,6 +257,14 @@ static void dwc2_hcd_cleanup_channels(struct dwc2_hsotg *hsotg)
                  */
                 channel->qh = NULL;
         }
+        /* All channels have been freed, mark them available */
+        if (hsotg->core_params->uframe_sched > 0) {
+                hsotg->available_host_channels =
+                        hsotg->core_params->host_channels;
+        } else {
+                hsotg->non_periodic_channels = 0;
+                hsotg->periodic_channels = 0;
+        }
 }
 
 /**
@@ -1527,7 +1535,7 @@ static int dwc2_hcd_hub_control(struct dwc2_hsotg *hsotg, u16 typereq,
                         hprt0 |= HPRT0_RES;
                         writel(hprt0, hsotg->regs + HPRT0);
                         hprt0 &= ~HPRT0_SUSP;
-                        usleep_range(100000, 150000);
+                        msleep(USB_RESUME_TIMEOUT);
 
                         hprt0 &= ~HPRT0_RES;
                         writel(hprt0, hsotg->regs + HPRT0);
@@ -1608,7 +1616,7 @@ static int dwc2_hcd_hub_control(struct dwc2_hsotg *hsotg, u16 typereq,
                 dev_dbg(hsotg->dev, "GetHubDescriptor\n");
                 hub_desc = (struct usb_hub_descriptor *)buf;
                 hub_desc->bDescLength = 9;
-                hub_desc->bDescriptorType = 0x29;
+                hub_desc->bDescriptorType = USB_DT_HUB;
                 hub_desc->bNbrPorts = 1;
                 hub_desc->wHubCharacteristics =
                         cpu_to_le16(HUB_CHAR_COMMON_LPSM |
diff --git a/drivers/usb/dwc2/pci.c b/drivers/usb/dwc2/pci.c
index a4e724b0a62e..ae419615a176 100644
--- a/drivers/usb/dwc2/pci.c
+++ b/drivers/usb/dwc2/pci.c
@@ -50,113 +50,97 @@
 
 #include <linux/usb/hcd.h>
 #include <linux/usb/ch11.h>
+#include <linux/platform_device.h>
+#include <linux/usb/usb_phy_generic.h>
 
-#include "core.h"
-#include "hcd.h"
-
-#define PCI_VENDOR_ID_SYNOPSYS          0x16c3
 #define PCI_PRODUCT_ID_HAPS_HSOTG       0xabc0
 
-static const char dwc2_driver_name[] = "dwc2";
-
-static const struct dwc2_core_params dwc2_module_params = {
-        .otg_cap                        = -1,
-        .otg_ver                        = -1,
-        .dma_enable                     = -1,
-        .dma_desc_enable                = 0,
-        .speed                          = -1,
-        .enable_dynamic_fifo            = -1,
-        .en_multiple_tx_fifo            = -1,
-        .host_rx_fifo_size              = 1024,
-        .host_nperio_tx_fifo_size       = 256,
-        .host_perio_tx_fifo_size        = 1024,
-        .max_transfer_size              = 65535,
-        .max_packet_count               = 511,
-        .host_channels                  = -1,
-        .phy_type                       = -1,
-        .phy_utmi_width                 = -1,
-        .phy_ulpi_ddr                   = -1,
-        .phy_ulpi_ext_vbus              = -1,
-        .i2c_enable                     = -1,
-        .ulpi_fs_ls                     = -1,
-        .host_support_fs_ls_low_power   = -1,
-        .host_ls_low_power_phy_clk      = -1,
-        .ts_dline                       = -1,
-        .reload_ctl                     = -1,
-        .ahbcfg                         = -1,
-        .uframe_sched                   = -1,
+static const char dwc2_driver_name[] = "dwc2-pci";
+
+struct dwc2_pci_glue {
+        struct platform_device *dwc2;
+        struct platform_device *phy;
 };
 
-/**
- * dwc2_driver_remove() - Called when the DWC_otg core is unregistered with the
- * DWC_otg driver
- *
- * @dev: Bus device
- *
- * This routine is called, for example, when the rmmod command is executed. The
- * device may or may not be electrically present. If it is present, the driver
- * stops device processing. Any resources used on behalf of this device are
- * freed.
- */
-static void dwc2_driver_remove(struct pci_dev *dev)
+static void dwc2_pci_remove(struct pci_dev *pci)
 {
-        struct dwc2_hsotg *hsotg = pci_get_drvdata(dev);
+        struct dwc2_pci_glue *glue = pci_get_drvdata(pci);
 
-        dwc2_hcd_remove(hsotg);
-        pci_disable_device(dev);
+        platform_device_unregister(glue->dwc2);
+        usb_phy_generic_unregister(glue->phy);
+        kfree(glue);
+        pci_set_drvdata(pci, NULL);
 }
 
-/**
- * dwc2_driver_probe() - Called when the DWC_otg core is bound to the DWC_otg
- * driver
- *
- * @dev: Bus device
- *
- * This routine creates the driver components required to control the device
- * (core, HCD, and PCD) and initializes the device. The driver components are
- * stored in a dwc2_hsotg structure. A reference to the dwc2_hsotg is saved
- * in the device private data. This allows the driver to access the dwc2_hsotg
- * structure on subsequent calls to driver methods for this device.
- */
-static int dwc2_driver_probe(struct pci_dev *dev,
-                             const struct pci_device_id *id)
+static int dwc2_pci_probe(struct pci_dev *pci,
+                const struct pci_device_id *id)
 {
-        struct dwc2_hsotg *hsotg;
-        int retval;
+        struct resource         res[2];
+        struct platform_device  *dwc2;
+        struct platform_device  *phy;
+        int                     ret;
+        struct device           *dev = &pci->dev;
+        struct dwc2_pci_glue    *glue;
+
+        ret = pcim_enable_device(pci);
+        if (ret) {
+                dev_err(dev, "failed to enable pci device\n");
+                return -ENODEV;
+        }
+
+        pci_set_master(pci);
 
-        hsotg = devm_kzalloc(&dev->dev, sizeof(*hsotg), GFP_KERNEL);
-        if (!hsotg)
+        dwc2 = platform_device_alloc("dwc2", PLATFORM_DEVID_AUTO);
+        if (!dwc2) {
+                dev_err(dev, "couldn't allocate dwc2 device\n");
                 return -ENOMEM;
+        }
 
-        hsotg->dev = &dev->dev;
-        hsotg->regs = devm_ioremap_resource(&dev->dev, &dev->resource[0]);
-        if (IS_ERR(hsotg->regs))
-                return PTR_ERR(hsotg->regs);
+        memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
 
-        dev_dbg(&dev->dev, "mapped PA %08lx to VA %p\n",
-                (unsigned long)pci_resource_start(dev, 0), hsotg->regs);
+        res[0].start    = pci_resource_start(pci, 0);
+        res[0].end      = pci_resource_end(pci, 0);
+        res[0].name     = "dwc2";
+        res[0].flags    = IORESOURCE_MEM;
 
-        if (pci_enable_device(dev) < 0)
-                return -ENODEV;
+        res[1].start    = pci->irq;
+        res[1].name     = "dwc2";
+        res[1].flags    = IORESOURCE_IRQ;
 
-        pci_set_master(dev);
+        ret = platform_device_add_resources(dwc2, res, ARRAY_SIZE(res));
+        if (ret) {
+                dev_err(dev, "couldn't add resources to dwc2 device\n");
+                return ret;
+        }
 
-        retval = devm_request_irq(hsotg->dev, dev->irq,
-                                  dwc2_handle_common_intr, IRQF_SHARED,
-                                  dev_name(hsotg->dev), hsotg);
-        if (retval)
-                return retval;
+        dwc2->dev.parent = dev;
 
-        spin_lock_init(&hsotg->lock);
-        retval = dwc2_hcd_init(hsotg, dev->irq, &dwc2_module_params);
-        if (retval) {
-                pci_disable_device(dev);
-                return retval;
+        phy = usb_phy_generic_register();
+        if (IS_ERR(phy)) {
+                dev_err(dev, "error registering generic PHY (%ld)\n",
+                        PTR_ERR(phy));
+                return PTR_ERR(phy);
         }
 
-        pci_set_drvdata(dev, hsotg);
+        ret = platform_device_add(dwc2);
+        if (ret) {
+                dev_err(dev, "failed to register dwc2 device\n");
+                goto err;
+        }
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue)
+                return -ENOMEM;
+
+        glue->phy = phy;
+        glue->dwc2 = dwc2;
+        pci_set_drvdata(pci, glue);
 
-        return retval;
+        return 0;
+err:
+        usb_phy_generic_unregister(phy);
+        platform_device_put(dwc2);
+        return ret;
 }
 
 static const struct pci_device_id dwc2_pci_ids[] = {
@@ -174,8 +158,8 @@ MODULE_DEVICE_TABLE(pci, dwc2_pci_ids);
 static struct pci_driver dwc2_pci_driver = {
         .name = dwc2_driver_name,
         .id_table = dwc2_pci_ids,
-        .probe = dwc2_driver_probe,
-        .remove = dwc2_driver_remove,
+        .probe = dwc2_pci_probe,
+        .remove = dwc2_pci_remove,
 };
 
 module_pci_driver(dwc2_pci_driver);
diff --git a/drivers/usb/dwc2/platform.c b/drivers/usb/dwc2/platform.c
index ae095f009b4f..185663e0b5f4 100644
--- a/drivers/usb/dwc2/platform.c
+++ b/drivers/usb/dwc2/platform.c
@@ -121,8 +121,10 @@ static int dwc2_driver_remove(struct platform_device *dev)
 {
         struct dwc2_hsotg *hsotg = platform_get_drvdata(dev);
 
-        dwc2_hcd_remove(hsotg);
-        s3c_hsotg_remove(hsotg);
+        if (hsotg->hcd_enabled)
+                dwc2_hcd_remove(hsotg);
+        if (hsotg->gadget_enabled)
+                s3c_hsotg_remove(hsotg);
 
         return 0;
 }
@@ -234,12 +236,23 @@ static int dwc2_driver_probe(struct platform_device *dev)
 
         spin_lock_init(&hsotg->lock);
         mutex_init(&hsotg->init_mutex);
-        retval = dwc2_gadget_init(hsotg, irq);
-        if (retval)
-                return retval;
-        retval = dwc2_hcd_init(hsotg, irq, params);
-        if (retval)
-                return retval;
+
+        if (hsotg->dr_mode != USB_DR_MODE_HOST) {
+                retval = dwc2_gadget_init(hsotg, irq);
+                if (retval)
+                        return retval;
+                hsotg->gadget_enabled = 1;
+        }
+
+        if (hsotg->dr_mode != USB_DR_MODE_PERIPHERAL) {
+                retval = dwc2_hcd_init(hsotg, irq, params);
+                if (retval) {
+                        if (hsotg->gadget_enabled)
+                                s3c_hsotg_remove(hsotg);
+                        return retval;
+                }
+                hsotg->hcd_enabled = 1;
+        }
 
         platform_set_drvdata(dev, hsotg);
 
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index edbf9c85af7e..827c4f80379f 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -104,11 +104,4 @@ config USB_DWC3_DEBUG
         help
           Say Y here to enable debugging messages on DWC3 Driver.
 
-config DWC3_HOST_USB3_LPM_ENABLE
-        bool "Enable USB3 LPM Capability"
-        depends on USB_DWC3_HOST=y || USB_DWC3_DUAL_ROLE=y
-        default n
-        help
-          Select this when you want to enable USB3 LPM with dwc3 xhci host.
-
 endif
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 9f0e209b8f6c..2bbab3d86fff 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -774,17 +774,13 @@ static int dwc3_probe(struct platform_device *pdev)
          * since it will be requested by the xhci-plat driver.
          */
         regs = devm_ioremap_resource(dev, res);
-        if (IS_ERR(regs))
-                return PTR_ERR(regs);
+        if (IS_ERR(regs)) {
+                ret = PTR_ERR(regs);
+                goto err0;
+        }
 
         dwc->regs       = regs;
         dwc->regs_size  = resource_size(res);
-        /*
-         * restore res->start back to its original value so that,
-         * in case the probe is deferred, we don't end up getting error in
-         * request the memory region the next time probe is called.
-         */
-        res->start -= DWC3_GLOBALS_REGS_START;
 
         /* default to highest possible threshold */
         lpm_nyet_threshold = 0xff;
@@ -808,6 +804,8 @@ static int dwc3_probe(struct platform_device *pdev)
                                 "snps,is-utmi-l1-suspend");
                 of_property_read_u8(node, "snps,hird-threshold",
                                 &hird_threshold);
+                dwc->usb3_lpm_capable = of_property_read_bool(node,
+                                "snps,usb3_lpm_capable");
 
                 dwc->needs_fifo_resize = of_property_read_bool(node,
                                 "tx-fifo-resize");
@@ -848,6 +846,7 @@ static int dwc3_probe(struct platform_device *pdev)
                         hird_threshold = pdata->hird_threshold;
 
                 dwc->needs_fifo_resize = pdata->tx_fifo_resize;
+                dwc->usb3_lpm_capable = pdata->usb3_lpm_capable;
                 dwc->dr_mode = pdata->dr_mode;
 
                 dwc->disable_scramble_quirk = pdata->disable_scramble_quirk;
@@ -878,7 +877,7 @@ static int dwc3_probe(struct platform_device *pdev)
 
         ret = dwc3_core_get_phy(dwc);
         if (ret)
-                return ret;
+                goto err0;
 
         spin_lock_init(&dwc->lock);
         platform_set_drvdata(pdev, dwc);
@@ -899,7 +898,7 @@ static int dwc3_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(dwc->dev, "failed to allocate event buffers\n");
                 ret = -ENOMEM;
-                goto err0;
+                goto err1;
         }
 
         if (IS_ENABLED(CONFIG_USB_DWC3_HOST))
@@ -913,65 +912,81 @@ static int dwc3_probe(struct platform_device *pdev)
         ret = dwc3_core_init(dwc);
         if (ret) {
                 dev_err(dev, "failed to initialize core\n");
-                goto err0;
+                goto err1;
         }
 
         usb_phy_set_suspend(dwc->usb2_phy, 0);
         usb_phy_set_suspend(dwc->usb3_phy, 0);
         ret = phy_power_on(dwc->usb2_generic_phy);
         if (ret < 0)
-                goto err1;
+                goto err2;
 
         ret = phy_power_on(dwc->usb3_generic_phy);
         if (ret < 0)
-                goto err_usb2phy_power;
+                goto err3;
 
         ret = dwc3_event_buffers_setup(dwc);
         if (ret) {
                 dev_err(dwc->dev, "failed to setup event buffers\n");
-                goto err_usb3phy_power;
+                goto err4;
         }
 
         ret = dwc3_core_init_mode(dwc);
         if (ret)
-                goto err2;
+                goto err5;
 
         ret = dwc3_debugfs_init(dwc);
         if (ret) {
                 dev_err(dev, "failed to initialize debugfs\n");
-                goto err3;
+                goto err6;
         }
 
         pm_runtime_allow(dev);
 
         return 0;
 
-err3:
+err6:
         dwc3_core_exit_mode(dwc);
 
-err2:
+err5:
         dwc3_event_buffers_cleanup(dwc);
 
-err_usb3phy_power:
+err4:
         phy_power_off(dwc->usb3_generic_phy);
 
-err_usb2phy_power:
+err3:
         phy_power_off(dwc->usb2_generic_phy);
 
-err1:
+err2:
         usb_phy_set_suspend(dwc->usb2_phy, 1);
         usb_phy_set_suspend(dwc->usb3_phy, 1);
         dwc3_core_exit(dwc);
 
-err0:
+err1:
         dwc3_free_event_buffers(dwc);
 
+err0:
+        /*
+         * restore res->start back to its original value so that, in case the
+         * probe is deferred, we don't end up getting error in request the
+         * memory region the next time probe is called.
+         */
+        res->start -= DWC3_GLOBALS_REGS_START;
+
         return ret;
 }
 
 static int dwc3_remove(struct platform_device *pdev)
 {
         struct dwc3     *dwc = platform_get_drvdata(pdev);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        /*
+         * restore res->start back to its original value so that, in case the
+         * probe is deferred, we don't end up getting error in request the
+         * memory region the next time probe is called.
+         */
+        res->start -= DWC3_GLOBALS_REGS_START;
 
         dwc3_debugfs_exit(dwc);
         dwc3_core_exit_mode(dwc);
diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h
index d201910b892f..fdab715a0631 100644
--- a/drivers/usb/dwc3/core.h
+++ b/drivers/usb/dwc3/core.h
@@ -689,6 +689,7 @@ struct dwc3_scratchpad_array {
  * @setup_packet_pending: true when there's a Setup Packet in FIFO. Workaround
  * @start_config_issued: true when StartConfig command has been issued
  * @three_stage_setup: set if we perform a three phase setup
+ * @usb3_lpm_capable: set if hadrware supports Link Power Management
  * @disable_scramble_quirk: set if we enable the disable scramble quirk
  * @u2exit_lfps_quirk: set if we enable u2exit lfps quirk
  * @u2ss_inp3_quirk: set if we enable P3 OK for U2/SS Inactive quirk
@@ -812,6 +813,7 @@ struct dwc3 {
         unsigned                setup_packet_pending:1;
         unsigned                start_config_issued:1;
         unsigned                three_stage_setup:1;
+        unsigned                usb3_lpm_capable:1;
 
         unsigned                disable_scramble_quirk:1;
         unsigned                u2exit_lfps_quirk:1;
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 52e0c4e5e48e..edba5348be18 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -325,15 +325,6 @@ static irqreturn_t dwc3_omap_interrupt(int irq, void *_omap)
         return IRQ_HANDLED;
 }
 
-static int dwc3_omap_remove_core(struct device *dev, void *c)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-
-        of_device_unregister(pdev);
-
-        return 0;
-}
-
 static void dwc3_omap_enable_irqs(struct dwc3_omap *omap)
 {
         u32                     reg;
@@ -600,7 +591,7 @@ static int dwc3_omap_remove(struct platform_device *pdev)
         if (omap->extcon_id_dev.edev)
                 extcon_unregister_interest(&omap->extcon_id_dev);
         dwc3_omap_disable_irqs(omap);
-        device_for_each_child(&pdev->dev, NULL, dwc3_omap_remove_core);
+        of_platform_depopulate(omap->dev);
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index 8d950569d557..b773fb53d6a7 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -24,8 +24,6 @@
 
 #include "platform_data.h"
 
-/* FIXME define these in <linux/pci_ids.h> */
-#define PCI_VENDOR_ID_SYNOPSYS          0x16c3
 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
 #define PCI_DEVICE_ID_INTEL_BYT         0x0f37
 #define PCI_DEVICE_ID_INTEL_MRFLD       0x119e
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index a03a485205c7..8946c32047e9 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -1855,32 +1855,27 @@ static int dwc3_cleanup_done_reqs(struct dwc3 *dwc, struct dwc3_ep *dep,
         unsigned int            i;
         int                     ret;
 
+        req = next_request(&dep->req_queued);
+        if (!req) {
+                WARN_ON_ONCE(1);
+                return 1;
+        }
+        i = 0;
         do {
-                req = next_request(&dep->req_queued);
-                if (!req) {
-                        WARN_ON_ONCE(1);
-                        return 1;
-                }
-                i = 0;
-                do {
-                        slot = req->start_slot + i;
-                        if ((slot == DWC3_TRB_NUM - 1) &&
+                slot = req->start_slot + i;
+                if ((slot == DWC3_TRB_NUM - 1) &&
                                 usb_endpoint_xfer_isoc(dep->endpoint.desc))
-                                slot++;
-                        slot %= DWC3_TRB_NUM;
-                        trb = &dep->trb_pool[slot];
-
-                        ret = __dwc3_cleanup_done_trbs(dwc, dep, req, trb,
-                                        event, status);
-                        if (ret)
-                                break;
-                }while (++i < req->request.num_mapped_sgs);
-
-                dwc3_gadget_giveback(dep, req, status);
+                        slot++;
+                slot %= DWC3_TRB_NUM;
+                trb = &dep->trb_pool[slot];
 
+                ret = __dwc3_cleanup_done_trbs(dwc, dep, req, trb,
+                                event, status);
                 if (ret)
                         break;
-        } while (1);
+        } while (++i < req->request.num_mapped_sgs);
+
+        dwc3_gadget_giveback(dep, req, status);
 
         if (usb_endpoint_xfer_isoc(dep->endpoint.desc) &&
                         list_empty(&dep->req_queued)) {
diff --git a/drivers/usb/dwc3/host.c b/drivers/usb/dwc3/host.c
index 12bfd3c5405e..c679f63783ae 100644
--- a/drivers/usb/dwc3/host.c
+++ b/drivers/usb/dwc3/host.c
@@ -49,9 +49,7 @@ int dwc3_host_init(struct dwc3 *dwc)
 
         memset(&pdata, 0, sizeof(pdata));
 
-#ifdef CONFIG_DWC3_HOST_USB3_LPM_ENABLE
-        pdata.usb3_lpm_capable = 1;
-#endif
+        pdata.usb3_lpm_capable = dwc->usb3_lpm_capable;
 
         ret = platform_device_add_data(xhci, &pdata, sizeof(pdata));
         if (ret) {
diff --git a/drivers/usb/dwc3/platform_data.h b/drivers/usb/dwc3/platform_data.h
index a3a3b6d5668c..a2bd464be828 100644
--- a/drivers/usb/dwc3/platform_data.h
+++ b/drivers/usb/dwc3/platform_data.h
@@ -24,6 +24,7 @@ struct dwc3_platform_data {
         enum usb_device_speed maximum_speed;
         enum usb_dr_mode dr_mode;
         bool tx_fifo_resize;
+        bool usb3_lpm_capable;
 
         unsigned is_utmi_l1_suspend:1;
         u8 hird_threshold;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index b454d05be583..bcf83c0a6e62 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -196,6 +196,9 @@ config USB_F_MIDI
 config USB_F_HID
         tristate
 
+config USB_F_PRINTER
+        tristate
+
 choice
         tristate "USB Gadget Drivers"
         default USB_ETH
@@ -434,6 +437,20 @@ config USB_CONFIGFS_F_UVC
           device. It provides a userspace API to process UVC control requests
           and stream video data to the host.
 
+config USB_CONFIGFS_F_PRINTER
+        bool "Printer function"
+        select USB_F_PRINTER
+        depends on USB_CONFIGFS
+        help
+          The Printer function channels data between the USB host and a
+          userspace program driving the print engine. The user space
+          program reads and writes the device file /dev/g_printer<X> to
+          receive or send printer data. It can use ioctl calls to
+          the device file to get or set printer status.
+
+          For more information, see Documentation/usb/gadget_printer.txt
+          which includes sample code for accessing the device file.
+
 source "drivers/usb/gadget/legacy/Kconfig"
 
 endchoice
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 13adfd1a3f54..4e3447bbd097 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1161,11 +1161,11 @@ static struct usb_gadget_string_container *copy_gadget_strings(
  * This function will create a deep copy of usb_gadget_strings and usb_string
  * and attach it to the cdev. The actual string (usb_string.s) will not be
  * copied but only a referenced will be made. The struct usb_gadget_strings
- * array may contain multiple languges and should be NULL terminated.
+ * array may contain multiple languages and should be NULL terminated.
  * The ->language pointer of each struct usb_gadget_strings has to contain the
  * same amount of entries.
  * For instance: sp[0] is en-US, sp[1] is es-ES. It is expected that the first
- * usb_string entry of es-ES containts the translation of the first usb_string
+ * usb_string entry of es-ES contains the translation of the first usb_string
  * entry of en-US. Therefore both entries become the same id assign.
  */
 struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
@@ -1472,6 +1472,13 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
         req->length = 0;
         gadget->ep0->driver_data = cdev;
 
+        /*
+         * Don't let non-standard requests match any of the cases below
+         * by accident.
+         */
+        if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
+                goto unknown;
+
         switch (ctrl->bRequest) {
 
         /* we handle all standard USB descriptors */
@@ -1751,6 +1758,10 @@ unknown:
                  * take such requests too, if that's ever needed:  to work
                  * in config 0, etc.
                  */
+                list_for_each_entry(f, &cdev->config->functions, list)
+                        if (f->req_match && f->req_match(f, ctrl))
+                                goto try_fun_setup;
+                f = NULL;
                 switch (ctrl->bRequestType & USB_RECIP_MASK) {
                 case USB_RECIP_INTERFACE:
                         if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
@@ -1768,7 +1779,7 @@ unknown:
                                 f = NULL;
                         break;
                 }
-
+try_fun_setup:
                 if (f && f->setup)
                         value = f->setup(f, ctrl);
                 else {
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index f71b1aaa0edf..bd7def576955 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -42,3 +42,5 @@ usb_f_midi-y			:= f_midi.o
 obj-$(CONFIG_USB_F_MIDI)        += usb_f_midi.o
 usb_f_hid-y                     := f_hid.o
 obj-$(CONFIG_USB_F_HID)         += usb_f_hid.o
+usb_f_printer-y                 := f_printer.o
+obj-$(CONFIG_USB_F_PRINTER)     += usb_f_printer.o
diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c
index a2612fb79eff..13dfc9915b1d 100644
--- a/drivers/usb/gadget/function/f_hid.c
+++ b/drivers/usb/gadget/function/f_hid.c
@@ -908,7 +908,6 @@ static void hidg_unbind(struct usb_configuration *c, struct usb_function *f)
 
         /* disable/free request and end point */
         usb_ep_disable(hidg->in_ep);
-        usb_ep_dequeue(hidg->in_ep, hidg->req);
         kfree(hidg->req->buf);
         usb_ep_free_request(hidg->in_ep, hidg->req);
 
diff --git a/drivers/usb/gadget/function/f_loopback.c b/drivers/usb/gadget/function/f_loopback.c
index 298b46112b1a..39f49f1ad22f 100644
--- a/drivers/usb/gadget/function/f_loopback.c
+++ b/drivers/usb/gadget/function/f_loopback.c
@@ -289,8 +289,7 @@ static void disable_loopback(struct f_loopback *loop)
         struct usb_composite_dev        *cdev;
 
         cdev = loop->function.config->cdev;
-        disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL, NULL,
-                        NULL);
+        disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL);
         VDBG(cdev, "%s disabled\n", loop->function.name);
 }
 
diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c
index 811929cd4c9e..3cc109f3c9c8 100644
--- a/drivers/usb/gadget/function/f_mass_storage.c
+++ b/drivers/usb/gadget/function/f_mass_storage.c
@@ -1085,7 +1085,7 @@ static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
         if (!curlun) {          /* Unsupported LUNs are okay */
                 common->bad_lun_okay = 1;
                 memset(buf, 0, 36);
-                buf[0] = 0x7f;          /* Unsupported, no device-type */
+                buf[0] = TYPE_NO_LUN;   /* Unsupported, no device-type */
                 buf[4] = 31;            /* Additional length */
                 return 36;
         }
@@ -2624,13 +2624,10 @@ static ssize_t file_store(struct device *dev, struct device_attribute *attr,
         return fsg_store_file(curlun, filesem, buf, count);
 }
 
-static DEVICE_ATTR_RW(ro);
 static DEVICE_ATTR_RW(nofua);
-static DEVICE_ATTR_RW(file);
-
-static struct device_attribute dev_attr_ro_cdrom = __ATTR_RO(ro);
-static struct device_attribute dev_attr_file_nonremovable = __ATTR_RO(file);
-
+/* mode wil be set in fsg_lun_attr_is_visible() */
+static DEVICE_ATTR(ro, 0, ro_show, ro_store);
+static DEVICE_ATTR(file, 0, file_show, file_store);
 
 /****************************** FSG COMMON ******************************/
 
@@ -2745,40 +2742,10 @@ error_release:
 }
 EXPORT_SYMBOL_GPL(fsg_common_set_num_buffers);
 
-static inline void fsg_common_remove_sysfs(struct fsg_lun *lun)
-{
-        device_remove_file(&lun->dev, &dev_attr_nofua);
-        /*
-         * device_remove_file() =>
-         *
-         * here the attr (e.g. dev_attr_ro) is only used to be passed to:
-         *
-         *      sysfs_remove_file() =>
-         *
-         *      here e.g. both dev_attr_ro_cdrom and dev_attr_ro are in
-         *      the same namespace and
-         *      from here only attr->name is passed to:
-         *
-         *              sysfs_hash_and_remove()
-         *
-         *              attr->name is the same for dev_attr_ro_cdrom and
-         *              dev_attr_ro
-         *              attr->name is the same for dev_attr_file and
-         *              dev_attr_file_nonremovable
-         *
-         * so we don't differentiate between removing e.g. dev_attr_ro_cdrom
-         * and dev_attr_ro
-         */
-        device_remove_file(&lun->dev, &dev_attr_ro);
-        device_remove_file(&lun->dev, &dev_attr_file);
-}
-
 void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs)
 {
-        if (sysfs) {
-                fsg_common_remove_sysfs(lun);
+        if (sysfs)
                 device_unregister(&lun->dev);
-        }
         fsg_lun_close(lun);
         kfree(lun);
 }
@@ -2877,41 +2844,35 @@ int fsg_common_set_cdev(struct fsg_common *common,
 }
 EXPORT_SYMBOL_GPL(fsg_common_set_cdev);
 
-static inline int fsg_common_add_sysfs(struct fsg_common *common,
-                                       struct fsg_lun *lun)
-{
-        int rc;
+static struct attribute *fsg_lun_dev_attrs[] = {
+        &dev_attr_ro.attr,
+        &dev_attr_file.attr,
+        &dev_attr_nofua.attr,
+        NULL
+};
 
-        rc = device_register(&lun->dev);
-        if (rc) {
-                put_device(&lun->dev);
-                return rc;
-        }
+static umode_t fsg_lun_dev_is_visible(struct kobject *kobj,
+                                      struct attribute *attr, int idx)
+{
+        struct device *dev = kobj_to_dev(kobj);
+        struct fsg_lun *lun = fsg_lun_from_dev(dev);
 
-        rc = device_create_file(&lun->dev,
-                                lun->cdrom
-                              ? &dev_attr_ro_cdrom
-                              : &dev_attr_ro);
-        if (rc)
-                goto error;
-        rc = device_create_file(&lun->dev,
-                                lun->removable
-                              ? &dev_attr_file
-                              : &dev_attr_file_nonremovable);
-        if (rc)
-                goto error;
-        rc = device_create_file(&lun->dev, &dev_attr_nofua);
-        if (rc)
-                goto error;
+        if (attr == &dev_attr_ro.attr)
+                return lun->cdrom ? S_IRUGO : (S_IWUSR | S_IRUGO);
+        if (attr == &dev_attr_file.attr)
+                return lun->removable ? (S_IWUSR | S_IRUGO) : S_IRUGO;
+        return attr->mode;
+}
 
-        return 0;
+static const struct attribute_group fsg_lun_dev_group = {
+        .attrs = fsg_lun_dev_attrs,
+        .is_visible = fsg_lun_dev_is_visible,
+};
 
-error:
-        /* removing nonexistent files is a no-op */
-        fsg_common_remove_sysfs(lun);
-        device_unregister(&lun->dev);
-        return rc;
-}
+static const struct attribute_group *fsg_lun_dev_groups[] = {
+        &fsg_lun_dev_group,
+        NULL
+};
 
 int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
                           unsigned int id, const char *name,
@@ -2949,13 +2910,15 @@ int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
         } else {
                 lun->dev.release = fsg_lun_release;
                 lun->dev.parent = &common->gadget->dev;
+                lun->dev.groups = fsg_lun_dev_groups;
                 dev_set_drvdata(&lun->dev, &common->filesem);
                 dev_set_name(&lun->dev, "%s", name);
                 lun->name = dev_name(&lun->dev);
 
-                rc = fsg_common_add_sysfs(common, lun);
+                rc = device_register(&lun->dev);
                 if (rc) {
                         pr_info("failed to register LUN%d: %d\n", id, rc);
+                        put_device(&lun->dev);
                         goto error_sysfs;
                 }
         }
@@ -2988,10 +2951,8 @@ int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
         return 0;
 
 error_lun:
-        if (common->sysfs) {
-                fsg_common_remove_sysfs(lun);
+        if (common->sysfs)
                 device_unregister(&lun->dev);
-        }
         fsg_lun_close(lun);
         common->luns[id] = NULL;
 error_sysfs:
@@ -3077,8 +3038,6 @@ static void fsg_common_release(struct kref *ref)
                         struct fsg_lun *lun = *lun_it;
                         if (!lun)
                                 continue;
-                        if (common->sysfs)
-                                fsg_common_remove_sysfs(lun);
                         fsg_lun_close(lun);
                         if (common->sysfs)
                                 device_unregister(&lun->dev);
diff --git a/drivers/usb/gadget/function/f_printer.c b/drivers/usb/gadget/function/f_printer.c
new file mode 100644
index 000000000000..44173df27273
--- /dev/null
+++ b/drivers/usb/gadget/function/f_printer.c
@@ -0,0 +1,1471 @@
+/*
+ * f_printer.c - USB printer function driver
+ *
+ * Copied from drivers/usb/gadget/legacy/printer.c,
+ * which was:
+ *
+ * printer.c -- Printer gadget driver
+ *
+ * Copyright (C) 2003-2005 David Brownell
+ * Copyright (C) 2006 Craig W. Nadler
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/idr.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/moduleparam.h>
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/types.h>
+#include <linux/ctype.h>
+#include <linux/cdev.h>
+
+#include <asm/byteorder.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/uaccess.h>
+#include <asm/unaligned.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/g_printer.h>
+
+#include "u_printer.h"
+
+#define PNP_STRING_LEN          1024
+#define PRINTER_MINORS          4
+#define GET_DEVICE_ID           0
+#define GET_PORT_STATUS         1
+#define SOFT_RESET              2
+
+static int major, minors;
+static struct class *usb_gadget_class;
+static DEFINE_IDA(printer_ida);
+static DEFINE_MUTEX(printer_ida_lock); /* protects access do printer_ida */
+
+/*-------------------------------------------------------------------------*/
+
+struct printer_dev {
+        spinlock_t              lock;           /* lock this structure */
+        /* lock buffer lists during read/write calls */
+        struct mutex            lock_printer_io;
+        struct usb_gadget       *gadget;
+        s8                      interface;
+        struct usb_ep           *in_ep, *out_ep;
+
+        struct list_head        rx_reqs;        /* List of free RX structs */
+        struct list_head        rx_reqs_active; /* List of Active RX xfers */
+        struct list_head        rx_buffers;     /* List of completed xfers */
+        /* wait until there is data to be read. */
+        wait_queue_head_t       rx_wait;
+        struct list_head        tx_reqs;        /* List of free TX structs */
+        struct list_head        tx_reqs_active; /* List of Active TX xfers */
+        /* Wait until there are write buffers available to use. */
+        wait_queue_head_t       tx_wait;
+        /* Wait until all write buffers have been sent. */
+        wait_queue_head_t       tx_flush_wait;
+        struct usb_request      *current_rx_req;
+        size_t                  current_rx_bytes;
+        u8                      *current_rx_buf;
+        u8                      printer_status;
+        u8                      reset_printer;
+        int                     minor;
+        struct cdev             printer_cdev;
+        u8                      printer_cdev_open;
+        wait_queue_head_t       wait;
+        unsigned                q_len;
+        char                    *pnp_string;    /* We don't own memory! */
+        struct usb_function     function;
+};
+
+static inline struct printer_dev *func_to_printer(struct usb_function *f)
+{
+        return container_of(f, struct printer_dev, function);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * DESCRIPTORS ... most are static, but strings and (full) configuration
+ * descriptors are built on demand.
+ */
+
+/* holds our biggest descriptor */
+#define USB_DESC_BUFSIZE                256
+#define USB_BUFSIZE                     8192
+
+static struct usb_interface_descriptor intf_desc = {
+        .bLength =              sizeof(intf_desc),
+        .bDescriptorType =      USB_DT_INTERFACE,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_PRINTER,
+        .bInterfaceSubClass =   1,      /* Printer Sub-Class */
+        .bInterfaceProtocol =   2,      /* Bi-Directional */
+        .iInterface =           0
+};
+
+static struct usb_endpoint_descriptor fs_ep_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK
+};
+
+static struct usb_endpoint_descriptor fs_ep_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK
+};
+
+static struct usb_descriptor_header *fs_printer_function[] = {
+        (struct usb_descriptor_header *) &intf_desc,
+        (struct usb_descriptor_header *) &fs_ep_in_desc,
+        (struct usb_descriptor_header *) &fs_ep_out_desc,
+        NULL
+};
+
+/*
+ * usb 2.0 devices need to expose both high speed and full speed
+ * descriptors, unless they only run at full speed.
+ */
+
+static struct usb_endpoint_descriptor hs_ep_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512)
+};
+
+static struct usb_endpoint_descriptor hs_ep_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512)
+};
+
+static struct usb_qualifier_descriptor dev_qualifier = {
+        .bLength =              sizeof(dev_qualifier),
+        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
+        .bcdUSB =               cpu_to_le16(0x0200),
+        .bDeviceClass =         USB_CLASS_PRINTER,
+        .bNumConfigurations =   1
+};
+
+static struct usb_descriptor_header *hs_printer_function[] = {
+        (struct usb_descriptor_header *) &intf_desc,
+        (struct usb_descriptor_header *) &hs_ep_in_desc,
+        (struct usb_descriptor_header *) &hs_ep_out_desc,
+        NULL
+};
+
+/*
+ * Added endpoint descriptors for 3.0 devices
+ */
+
+static struct usb_endpoint_descriptor ss_ep_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = {
+        .bLength =              sizeof(ss_ep_in_comp_desc),
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+};
+
+static struct usb_endpoint_descriptor ss_ep_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = {
+        .bLength =              sizeof(ss_ep_out_comp_desc),
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+};
+
+static struct usb_descriptor_header *ss_printer_function[] = {
+        (struct usb_descriptor_header *) &intf_desc,
+        (struct usb_descriptor_header *) &ss_ep_in_desc,
+        (struct usb_descriptor_header *) &ss_ep_in_comp_desc,
+        (struct usb_descriptor_header *) &ss_ep_out_desc,
+        (struct usb_descriptor_header *) &ss_ep_out_comp_desc,
+        NULL
+};
+
+/* maxpacket and other transfer characteristics vary by speed. */
+static inline struct usb_endpoint_descriptor *ep_desc(struct usb_gadget *gadget,
+                                        struct usb_endpoint_descriptor *fs,
+                                        struct usb_endpoint_descriptor *hs,
+                                        struct usb_endpoint_descriptor *ss)
+{
+        switch (gadget->speed) {
+        case USB_SPEED_SUPER:
+                return ss;
+        case USB_SPEED_HIGH:
+                return hs;
+        default:
+                return fs;
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_request *
+printer_req_alloc(struct usb_ep *ep, unsigned len, gfp_t gfp_flags)
+{
+        struct usb_request      *req;
+
+        req = usb_ep_alloc_request(ep, gfp_flags);
+
+        if (req != NULL) {
+                req->length = len;
+                req->buf = kmalloc(len, gfp_flags);
+                if (req->buf == NULL) {
+                        usb_ep_free_request(ep, req);
+                        return NULL;
+                }
+        }
+
+        return req;
+}
+
+static void
+printer_req_free(struct usb_ep *ep, struct usb_request *req)
+{
+        if (ep != NULL && req != NULL) {
+                kfree(req->buf);
+                usb_ep_free_request(ep, req);
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void rx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct printer_dev      *dev = ep->driver_data;
+        int                     status = req->status;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
+
+        list_del_init(&req->list);      /* Remode from Active List */
+
+        switch (status) {
+
+        /* normal completion */
+        case 0:
+                if (req->actual > 0) {
+                        list_add_tail(&req->list, &dev->rx_buffers);
+                        DBG(dev, "G_Printer : rx length %d\n", req->actual);
+                } else {
+                        list_add(&req->list, &dev->rx_reqs);
+                }
+                break;
+
+        /* software-driven interface shutdown */
+        case -ECONNRESET:               /* unlink */
+        case -ESHUTDOWN:                /* disconnect etc */
+                VDBG(dev, "rx shutdown, code %d\n", status);
+                list_add(&req->list, &dev->rx_reqs);
+                break;
+
+        /* for hardware automagic (such as pxa) */
+        case -ECONNABORTED:             /* endpoint reset */
+                DBG(dev, "rx %s reset\n", ep->name);
+                list_add(&req->list, &dev->rx_reqs);
+                break;
+
+        /* data overrun */
+        case -EOVERFLOW:
+                /* FALLTHROUGH */
+
+        default:
+                DBG(dev, "rx status %d\n", status);
+                list_add(&req->list, &dev->rx_reqs);
+                break;
+        }
+
+        wake_up_interruptible(&dev->rx_wait);
+        spin_unlock_irqrestore(&dev->lock, flags);
+}
+
+static void tx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct printer_dev      *dev = ep->driver_data;
+
+        switch (req->status) {
+        default:
+                VDBG(dev, "tx err %d\n", req->status);
+                /* FALLTHROUGH */
+        case -ECONNRESET:               /* unlink */
+        case -ESHUTDOWN:                /* disconnect etc */
+                break;
+        case 0:
+                break;
+        }
+
+        spin_lock(&dev->lock);
+        /* Take the request struct off the active list and put it on the
+         * free list.
+         */
+        list_del_init(&req->list);
+        list_add(&req->list, &dev->tx_reqs);
+        wake_up_interruptible(&dev->tx_wait);
+        if (likely(list_empty(&dev->tx_reqs_active)))
+                wake_up_interruptible(&dev->tx_flush_wait);
+
+        spin_unlock(&dev->lock);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int
+printer_open(struct inode *inode, struct file *fd)
+{
+        struct printer_dev      *dev;
+        unsigned long           flags;
+        int                     ret = -EBUSY;
+
+        dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
+
+        spin_lock_irqsave(&dev->lock, flags);
+
+        if (!dev->printer_cdev_open) {
+                dev->printer_cdev_open = 1;
+                fd->private_data = dev;
+                ret = 0;
+                /* Change the printer status to show that it's on-line. */
+                dev->printer_status |= PRINTER_SELECTED;
+        }
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        DBG(dev, "printer_open returned %x\n", ret);
+        return ret;
+}
+
+static int
+printer_close(struct inode *inode, struct file *fd)
+{
+        struct printer_dev      *dev = fd->private_data;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
+        dev->printer_cdev_open = 0;
+        fd->private_data = NULL;
+        /* Change printer status to show that the printer is off-line. */
+        dev->printer_status &= ~PRINTER_SELECTED;
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        DBG(dev, "printer_close\n");
+
+        return 0;
+}
+
+/* This function must be called with interrupts turned off. */
+static void
+setup_rx_reqs(struct printer_dev *dev)
+{
+        struct usb_request              *req;
+
+        while (likely(!list_empty(&dev->rx_reqs))) {
+                int error;
+
+                req = container_of(dev->rx_reqs.next,
+                                struct usb_request, list);
+                list_del_init(&req->list);
+
+                /* The USB Host sends us whatever amount of data it wants to
+                 * so we always set the length field to the full USB_BUFSIZE.
+                 * If the amount of data is more than the read() caller asked
+                 * for it will be stored in the request buffer until it is
+                 * asked for by read().
+                 */
+                req->length = USB_BUFSIZE;
+                req->complete = rx_complete;
+
+                /* here, we unlock, and only unlock, to avoid deadlock. */
+                spin_unlock(&dev->lock);
+                error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
+                spin_lock(&dev->lock);
+                if (error) {
+                        DBG(dev, "rx submit --> %d\n", error);
+                        list_add(&req->list, &dev->rx_reqs);
+                        break;
+                }
+                /* if the req is empty, then add it into dev->rx_reqs_active. */
+                else if (list_empty(&req->list))
+                        list_add(&req->list, &dev->rx_reqs_active);
+        }
+}
+
+static ssize_t
+printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
+{
+        struct printer_dev              *dev = fd->private_data;
+        unsigned long                   flags;
+        size_t                          size;
+        size_t                          bytes_copied;
+        struct usb_request              *req;
+        /* This is a pointer to the current USB rx request. */
+        struct usb_request              *current_rx_req;
+        /* This is the number of bytes in the current rx buffer. */
+        size_t                          current_rx_bytes;
+        /* This is a pointer to the current rx buffer. */
+        u8                              *current_rx_buf;
+
+        if (len == 0)
+                return -EINVAL;
+
+        DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
+
+        mutex_lock(&dev->lock_printer_io);
+        spin_lock_irqsave(&dev->lock, flags);
+
+        /* We will use this flag later to check if a printer reset happened
+         * after we turn interrupts back on.
+         */
+        dev->reset_printer = 0;
+
+        setup_rx_reqs(dev);
+
+        bytes_copied = 0;
+        current_rx_req = dev->current_rx_req;
+        current_rx_bytes = dev->current_rx_bytes;
+        current_rx_buf = dev->current_rx_buf;
+        dev->current_rx_req = NULL;
+        dev->current_rx_bytes = 0;
+        dev->current_rx_buf = NULL;
+
+        /* Check if there is any data in the read buffers. Please note that
+         * current_rx_bytes is the number of bytes in the current rx buffer.
+         * If it is zero then check if there are any other rx_buffers that
+         * are on the completed list. We are only out of data if all rx
+         * buffers are empty.
+         */
+        if ((current_rx_bytes == 0) &&
+                        (likely(list_empty(&dev->rx_buffers)))) {
+                /* Turn interrupts back on before sleeping. */
+                spin_unlock_irqrestore(&dev->lock, flags);
+
+                /*
+                 * If no data is available check if this is a NON-Blocking
+                 * call or not.
+                 */
+                if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
+                        mutex_unlock(&dev->lock_printer_io);
+                        return -EAGAIN;
+                }
+
+                /* Sleep until data is available */
+                wait_event_interruptible(dev->rx_wait,
+                                (likely(!list_empty(&dev->rx_buffers))));
+                spin_lock_irqsave(&dev->lock, flags);
+        }
+
+        /* We have data to return then copy it to the caller's buffer.*/
+        while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
+                        && len) {
+                if (current_rx_bytes == 0) {
+                        req = container_of(dev->rx_buffers.next,
+                                        struct usb_request, list);
+                        list_del_init(&req->list);
+
+                        if (req->actual && req->buf) {
+                                current_rx_req = req;
+                                current_rx_bytes = req->actual;
+                                current_rx_buf = req->buf;
+                        } else {
+                                list_add(&req->list, &dev->rx_reqs);
+                                continue;
+                        }
+                }
+
+                /* Don't leave irqs off while doing memory copies */
+                spin_unlock_irqrestore(&dev->lock, flags);
+
+                if (len > current_rx_bytes)
+                        size = current_rx_bytes;
+                else
+                        size = len;
+
+                size -= copy_to_user(buf, current_rx_buf, size);
+                bytes_copied += size;
+                len -= size;
+                buf += size;
+
+                spin_lock_irqsave(&dev->lock, flags);
+
+                /* We've disconnected or reset so return. */
+                if (dev->reset_printer) {
+                        list_add(&current_rx_req->list, &dev->rx_reqs);
+                        spin_unlock_irqrestore(&dev->lock, flags);
+                        mutex_unlock(&dev->lock_printer_io);
+                        return -EAGAIN;
+                }
+
+                /* If we not returning all the data left in this RX request
+                 * buffer then adjust the amount of data left in the buffer.
+                 * Othewise if we are done with this RX request buffer then
+                 * requeue it to get any incoming data from the USB host.
+                 */
+                if (size < current_rx_bytes) {
+                        current_rx_bytes -= size;
+                        current_rx_buf += size;
+                } else {
+                        list_add(&current_rx_req->list, &dev->rx_reqs);
+                        current_rx_bytes = 0;
+                        current_rx_buf = NULL;
+                        current_rx_req = NULL;
+                }
+        }
+
+        dev->current_rx_req = current_rx_req;
+        dev->current_rx_bytes = current_rx_bytes;
+        dev->current_rx_buf = current_rx_buf;
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+        mutex_unlock(&dev->lock_printer_io);
+
+        DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied);
+
+        if (bytes_copied)
+                return bytes_copied;
+        else
+                return -EAGAIN;
+}
+
+static ssize_t
+printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
+{
+        struct printer_dev      *dev = fd->private_data;
+        unsigned long           flags;
+        size_t                  size;   /* Amount of data in a TX request. */
+        size_t                  bytes_copied = 0;
+        struct usb_request      *req;
+
+        DBG(dev, "printer_write trying to send %d bytes\n", (int)len);
+
+        if (len == 0)
+                return -EINVAL;
+
+        mutex_lock(&dev->lock_printer_io);
+        spin_lock_irqsave(&dev->lock, flags);
+
+        /* Check if a printer reset happens while we have interrupts on */
+        dev->reset_printer = 0;
+
+        /* Check if there is any available write buffers */
+        if (likely(list_empty(&dev->tx_reqs))) {
+                /* Turn interrupts back on before sleeping. */
+                spin_unlock_irqrestore(&dev->lock, flags);
+
+                /*
+                 * If write buffers are available check if this is
+                 * a NON-Blocking call or not.
+                 */
+                if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
+                        mutex_unlock(&dev->lock_printer_io);
+                        return -EAGAIN;
+                }
+
+                /* Sleep until a write buffer is available */
+                wait_event_interruptible(dev->tx_wait,
+                                (likely(!list_empty(&dev->tx_reqs))));
+                spin_lock_irqsave(&dev->lock, flags);
+        }
+
+        while (likely(!list_empty(&dev->tx_reqs)) && len) {
+
+                if (len > USB_BUFSIZE)
+                        size = USB_BUFSIZE;
+                else
+                        size = len;
+
+                req = container_of(dev->tx_reqs.next, struct usb_request,
+                                list);
+                list_del_init(&req->list);
+
+                req->complete = tx_complete;
+                req->length = size;
+
+                /* Check if we need to send a zero length packet. */
+                if (len > size)
+                        /* They will be more TX requests so no yet. */
+                        req->zero = 0;
+                else
+                        /* If the data amount is not a multiple of the
+                         * maxpacket size then send a zero length packet.
+                         */
+                        req->zero = ((len % dev->in_ep->maxpacket) == 0);
+
+                /* Don't leave irqs off while doing memory copies */
+                spin_unlock_irqrestore(&dev->lock, flags);
+
+                if (copy_from_user(req->buf, buf, size)) {
+                        list_add(&req->list, &dev->tx_reqs);
+                        mutex_unlock(&dev->lock_printer_io);
+                        return bytes_copied;
+                }
+
+                bytes_copied += size;
+                len -= size;
+                buf += size;
+
+                spin_lock_irqsave(&dev->lock, flags);
+
+                /* We've disconnected or reset so free the req and buffer */
+                if (dev->reset_printer) {
+                        list_add(&req->list, &dev->tx_reqs);
+                        spin_unlock_irqrestore(&dev->lock, flags);
+                        mutex_unlock(&dev->lock_printer_io);
+                        return -EAGAIN;
+                }
+
+                if (usb_ep_queue(dev->in_ep, req, GFP_ATOMIC)) {
+                        list_add(&req->list, &dev->tx_reqs);
+                        spin_unlock_irqrestore(&dev->lock, flags);
+                        mutex_unlock(&dev->lock_printer_io);
+                        return -EAGAIN;
+                }
+
+                list_add(&req->list, &dev->tx_reqs_active);
+
+        }
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+        mutex_unlock(&dev->lock_printer_io);
+
+        DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied);
+
+        if (bytes_copied)
+                return bytes_copied;
+        else
+                return -EAGAIN;
+}
+
+static int
+printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync)
+{
+        struct printer_dev      *dev = fd->private_data;
+        struct inode *inode = file_inode(fd);
+        unsigned long           flags;
+        int                     tx_list_empty;
+
+        mutex_lock(&inode->i_mutex);
+        spin_lock_irqsave(&dev->lock, flags);
+        tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        if (!tx_list_empty) {
+                /* Sleep until all data has been sent */
+                wait_event_interruptible(dev->tx_flush_wait,
+                                (likely(list_empty(&dev->tx_reqs_active))));
+        }
+        mutex_unlock(&inode->i_mutex);
+
+        return 0;
+}
+
+static unsigned int
+printer_poll(struct file *fd, poll_table *wait)
+{
+        struct printer_dev      *dev = fd->private_data;
+        unsigned long           flags;
+        int                     status = 0;
+
+        mutex_lock(&dev->lock_printer_io);
+        spin_lock_irqsave(&dev->lock, flags);
+        setup_rx_reqs(dev);
+        spin_unlock_irqrestore(&dev->lock, flags);
+        mutex_unlock(&dev->lock_printer_io);
+
+        poll_wait(fd, &dev->rx_wait, wait);
+        poll_wait(fd, &dev->tx_wait, wait);
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (likely(!list_empty(&dev->tx_reqs)))
+                status |= POLLOUT | POLLWRNORM;
+
+        if (likely(dev->current_rx_bytes) ||
+                        likely(!list_empty(&dev->rx_buffers)))
+                status |= POLLIN | POLLRDNORM;
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        return status;
+}
+
+static long
+printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
+{
+        struct printer_dev      *dev = fd->private_data;
+        unsigned long           flags;
+        int                     status = 0;
+
+        DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
+
+        /* handle ioctls */
+
+        spin_lock_irqsave(&dev->lock, flags);
+
+        switch (code) {
+        case GADGET_GET_PRINTER_STATUS:
+                status = (int)dev->printer_status;
+                break;
+        case GADGET_SET_PRINTER_STATUS:
+                dev->printer_status = (u8)arg;
+                break;
+        default:
+                /* could not handle ioctl */
+                DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
+                                code);
+                status = -ENOTTY;
+        }
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        return status;
+}
+
+/* used after endpoint configuration */
+static const struct file_operations printer_io_operations = {
+        .owner =        THIS_MODULE,
+        .open =         printer_open,
+        .read =         printer_read,
+        .write =        printer_write,
+        .fsync =        printer_fsync,
+        .poll =         printer_poll,
+        .unlocked_ioctl = printer_ioctl,
+        .release =      printer_close,
+        .llseek =       noop_llseek,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int
+set_printer_interface(struct printer_dev *dev)
+{
+        int                     result = 0;
+
+        dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
+                                &ss_ep_in_desc);
+        dev->in_ep->driver_data = dev;
+
+        dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
+                                    &hs_ep_out_desc, &ss_ep_out_desc);
+        dev->out_ep->driver_data = dev;
+
+        result = usb_ep_enable(dev->in_ep);
+        if (result != 0) {
+                DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
+                goto done;
+        }
+
+        result = usb_ep_enable(dev->out_ep);
+        if (result != 0) {
+                DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
+                goto done;
+        }
+
+done:
+        /* on error, disable any endpoints  */
+        if (result != 0) {
+                (void) usb_ep_disable(dev->in_ep);
+                (void) usb_ep_disable(dev->out_ep);
+                dev->in_ep->desc = NULL;
+                dev->out_ep->desc = NULL;
+        }
+
+        /* caller is responsible for cleanup on error */
+        return result;
+}
+
+static void printer_reset_interface(struct printer_dev *dev)
+{
+        if (dev->interface < 0)
+                return;
+
+        DBG(dev, "%s\n", __func__);
+
+        if (dev->in_ep->desc)
+                usb_ep_disable(dev->in_ep);
+
+        if (dev->out_ep->desc)
+                usb_ep_disable(dev->out_ep);
+
+        dev->in_ep->desc = NULL;
+        dev->out_ep->desc = NULL;
+        dev->interface = -1;
+}
+
+/* Change our operational Interface. */
+static int set_interface(struct printer_dev *dev, unsigned number)
+{
+        int                     result = 0;
+
+        /* Free the current interface */
+        printer_reset_interface(dev);
+
+        result = set_printer_interface(dev);
+        if (result)
+                printer_reset_interface(dev);
+        else
+                dev->interface = number;
+
+        if (!result)
+                INFO(dev, "Using interface %x\n", number);
+
+        return result;
+}
+
+static void printer_soft_reset(struct printer_dev *dev)
+{
+        struct usb_request      *req;
+
+        INFO(dev, "Received Printer Reset Request\n");
+
+        if (usb_ep_disable(dev->in_ep))
+                DBG(dev, "Failed to disable USB in_ep\n");
+        if (usb_ep_disable(dev->out_ep))
+                DBG(dev, "Failed to disable USB out_ep\n");
+
+        if (dev->current_rx_req != NULL) {
+                list_add(&dev->current_rx_req->list, &dev->rx_reqs);
+                dev->current_rx_req = NULL;
+        }
+        dev->current_rx_bytes = 0;
+        dev->current_rx_buf = NULL;
+        dev->reset_printer = 1;
+
+        while (likely(!(list_empty(&dev->rx_buffers)))) {
+                req = container_of(dev->rx_buffers.next, struct usb_request,
+                                list);
+                list_del_init(&req->list);
+                list_add(&req->list, &dev->rx_reqs);
+        }
+
+        while (likely(!(list_empty(&dev->rx_reqs_active)))) {
+                req = container_of(dev->rx_buffers.next, struct usb_request,
+                                list);
+                list_del_init(&req->list);
+                list_add(&req->list, &dev->rx_reqs);
+        }
+
+        while (likely(!(list_empty(&dev->tx_reqs_active)))) {
+                req = container_of(dev->tx_reqs_active.next,
+                                struct usb_request, list);
+                list_del_init(&req->list);
+                list_add(&req->list, &dev->tx_reqs);
+        }
+
+        if (usb_ep_enable(dev->in_ep))
+                DBG(dev, "Failed to enable USB in_ep\n");
+        if (usb_ep_enable(dev->out_ep))
+                DBG(dev, "Failed to enable USB out_ep\n");
+
+        wake_up_interruptible(&dev->rx_wait);
+        wake_up_interruptible(&dev->tx_wait);
+        wake_up_interruptible(&dev->tx_flush_wait);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static bool gprinter_req_match(struct usb_function *f,
+                               const struct usb_ctrlrequest *ctrl)
+{
+        struct printer_dev      *dev = func_to_printer(f);
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        if ((ctrl->bRequestType & USB_RECIP_MASK) != USB_RECIP_INTERFACE ||
+            (ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
+                return false;
+
+        switch (ctrl->bRequest) {
+        case GET_DEVICE_ID:
+                w_index >>= 8;
+                if (w_length <= PNP_STRING_LEN &&
+                    (USB_DIR_IN & ctrl->bRequestType))
+                        break;
+                return false;
+        case GET_PORT_STATUS:
+                if (!w_value && w_length == 1 &&
+                    (USB_DIR_IN & ctrl->bRequestType))
+                        break;
+                return false;
+        case SOFT_RESET:
+                if (!w_value && !w_length &&
+                   !(USB_DIR_IN & ctrl->bRequestType))
+                        break;
+                /* fall through */
+        default:
+                return false;
+        }
+        return w_index == dev->interface;
+}
+
+/*
+ * The setup() callback implements all the ep0 functionality that's not
+ * handled lower down.
+ */
+static int printer_func_setup(struct usb_function *f,
+                const struct usb_ctrlrequest *ctrl)
+{
+        struct printer_dev *dev = func_to_printer(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     wIndex = le16_to_cpu(ctrl->wIndex);
+        u16                     wValue = le16_to_cpu(ctrl->wValue);
+        u16                     wLength = le16_to_cpu(ctrl->wLength);
+
+        DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
+                ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength);
+
+        switch (ctrl->bRequestType&USB_TYPE_MASK) {
+        case USB_TYPE_CLASS:
+                switch (ctrl->bRequest) {
+                case GET_DEVICE_ID: /* Get the IEEE-1284 PNP String */
+                        /* Only one printer interface is supported. */
+                        if ((wIndex>>8) != dev->interface)
+                                break;
+
+                        value = (dev->pnp_string[0] << 8) | dev->pnp_string[1];
+                        memcpy(req->buf, dev->pnp_string, value);
+                        DBG(dev, "1284 PNP String: %x %s\n", value,
+                                        &dev->pnp_string[2]);
+                        break;
+
+                case GET_PORT_STATUS: /* Get Port Status */
+                        /* Only one printer interface is supported. */
+                        if (wIndex != dev->interface)
+                                break;
+
+                        *(u8 *)req->buf = dev->printer_status;
+                        value = min_t(u16, wLength, 1);
+                        break;
+
+                case SOFT_RESET: /* Soft Reset */
+                        /* Only one printer interface is supported. */
+                        if (wIndex != dev->interface)
+                                break;
+
+                        printer_soft_reset(dev);
+
+                        value = 0;
+                        break;
+
+                default:
+                        goto unknown;
+                }
+                break;
+
+        default:
+unknown:
+                VDBG(dev,
+                        "unknown ctrl req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        wValue, wIndex, wLength);
+                break;
+        }
+        /* host either stalls (value < 0) or reports success */
+        if (value >= 0) {
+                req->length = value;
+                req->zero = value < wLength;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0) {
+                        ERROR(dev, "%s:%d Error!\n", __func__, __LINE__);
+                        req->status = 0;
+                }
+        }
+        return value;
+}
+
+static int printer_func_bind(struct usb_configuration *c,
+                struct usb_function *f)
+{
+        struct usb_gadget *gadget = c->cdev->gadget;
+        struct printer_dev *dev = func_to_printer(f);
+        struct device *pdev;
+        struct usb_composite_dev *cdev = c->cdev;
+        struct usb_ep *in_ep;
+        struct usb_ep *out_ep = NULL;
+        struct usb_request *req;
+        dev_t devt;
+        int id;
+        int ret;
+        u32 i;
+
+        id = usb_interface_id(c, f);
+        if (id < 0)
+                return id;
+        intf_desc.bInterfaceNumber = id;
+
+        /* finish hookup to lower layer ... */
+        dev->gadget = gadget;
+
+        /* all we really need is bulk IN/OUT */
+        in_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_in_desc);
+        if (!in_ep) {
+autoconf_fail:
+                dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
+                        cdev->gadget->name);
+                return -ENODEV;
+        }
+        in_ep->driver_data = in_ep;     /* claim */
+
+        out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc);
+        if (!out_ep)
+                goto autoconf_fail;
+        out_ep->driver_data = out_ep;   /* claim */
+
+        /* assumes that all endpoints are dual-speed */
+        hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
+        hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
+        ss_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
+        ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
+
+        ret = usb_assign_descriptors(f, fs_printer_function,
+                        hs_printer_function, ss_printer_function);
+        if (ret)
+                return ret;
+
+        dev->in_ep = in_ep;
+        dev->out_ep = out_ep;
+
+        ret = -ENOMEM;
+        for (i = 0; i < dev->q_len; i++) {
+                req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
+                if (!req)
+                        goto fail_tx_reqs;
+                list_add(&req->list, &dev->tx_reqs);
+        }
+
+        for (i = 0; i < dev->q_len; i++) {
+                req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
+                if (!req)
+                        goto fail_rx_reqs;
+                list_add(&req->list, &dev->rx_reqs);
+        }
+
+        /* Setup the sysfs files for the printer gadget. */
+        devt = MKDEV(major, dev->minor);
+        pdev = device_create(usb_gadget_class, NULL, devt,
+                                  NULL, "g_printer%d", dev->minor);
+        if (IS_ERR(pdev)) {
+                ERROR(dev, "Failed to create device: g_printer\n");
+                ret = PTR_ERR(pdev);
+                goto fail_rx_reqs;
+        }
+
+        /*
+         * Register a character device as an interface to a user mode
+         * program that handles the printer specific functionality.
+         */
+        cdev_init(&dev->printer_cdev, &printer_io_operations);
+        dev->printer_cdev.owner = THIS_MODULE;
+        ret = cdev_add(&dev->printer_cdev, devt, 1);
+        if (ret) {
+                ERROR(dev, "Failed to open char device\n");
+                goto fail_cdev_add;
+        }
+
+        return 0;
+
+fail_cdev_add:
+        device_destroy(usb_gadget_class, devt);
+
+fail_rx_reqs:
+        while (!list_empty(&dev->rx_reqs)) {
+                req = container_of(dev->rx_reqs.next, struct usb_request, list);
+                list_del(&req->list);
+                printer_req_free(dev->out_ep, req);
+        }
+
+fail_tx_reqs:
+        while (!list_empty(&dev->tx_reqs)) {
+                req = container_of(dev->tx_reqs.next, struct usb_request, list);
+                list_del(&req->list);
+                printer_req_free(dev->in_ep, req);
+        }
+
+        return ret;
+
+}
+
+static int printer_func_set_alt(struct usb_function *f,
+                unsigned intf, unsigned alt)
+{
+        struct printer_dev *dev = func_to_printer(f);
+        int ret = -ENOTSUPP;
+
+        if (!alt)
+                ret = set_interface(dev, intf);
+
+        return ret;
+}
+
+static void printer_func_disable(struct usb_function *f)
+{
+        struct printer_dev *dev = func_to_printer(f);
+        unsigned long           flags;
+
+        DBG(dev, "%s\n", __func__);
+
+        spin_lock_irqsave(&dev->lock, flags);
+        printer_reset_interface(dev);
+        spin_unlock_irqrestore(&dev->lock, flags);
+}
+
+static inline struct f_printer_opts
+*to_f_printer_opts(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct f_printer_opts,
+                            func_inst.group);
+}
+
+CONFIGFS_ATTR_STRUCT(f_printer_opts);
+CONFIGFS_ATTR_OPS(f_printer_opts);
+
+static void printer_attr_release(struct config_item *item)
+{
+        struct f_printer_opts *opts = to_f_printer_opts(item);
+
+        usb_put_function_instance(&opts->func_inst);
+}
+
+static struct configfs_item_operations printer_item_ops = {
+        .release        = printer_attr_release,
+        .show_attribute = f_printer_opts_attr_show,
+        .store_attribute = f_printer_opts_attr_store,
+};
+
+static ssize_t f_printer_opts_pnp_string_show(struct f_printer_opts *opts,
+                                              char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = strlcpy(page, opts->pnp_string + 2, PNP_STRING_LEN - 2);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_printer_opts_pnp_string_store(struct f_printer_opts *opts,
+                                               const char *page, size_t len)
+{
+        int result, l;
+
+        mutex_lock(&opts->lock);
+        result = strlcpy(opts->pnp_string + 2, page, PNP_STRING_LEN - 2);
+        l = strlen(opts->pnp_string + 2) + 2;
+        opts->pnp_string[0] = (l >> 8) & 0xFF;
+        opts->pnp_string[1] = l & 0xFF;
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static struct f_printer_opts_attribute f_printer_opts_pnp_string =
+        __CONFIGFS_ATTR(pnp_string, S_IRUGO | S_IWUSR,
+                        f_printer_opts_pnp_string_show,
+                        f_printer_opts_pnp_string_store);
+
+static ssize_t f_printer_opts_q_len_show(struct f_printer_opts *opts,
+                                         char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d\n", opts->q_len);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_printer_opts_q_len_store(struct f_printer_opts *opts,
+                                          const char *page, size_t len)
+{
+        int ret;
+        u16 num;
+
+        mutex_lock(&opts->lock);
+        if (opts->refcnt) {
+                ret = -EBUSY;
+                goto end;
+        }
+
+        ret = kstrtou16(page, 0, &num);
+        if (ret)
+                goto end;
+
+        opts->q_len = (unsigned)num;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_printer_opts_attribute f_printer_opts_q_len =
+        __CONFIGFS_ATTR(q_len, S_IRUGO | S_IWUSR, f_printer_opts_q_len_show,
+                        f_printer_opts_q_len_store);
+
+static struct configfs_attribute *printer_attrs[] = {
+        &f_printer_opts_pnp_string.attr,
+        &f_printer_opts_q_len.attr,
+        NULL,
+};
+
+static struct config_item_type printer_func_type = {
+        .ct_item_ops    = &printer_item_ops,
+        .ct_attrs       = printer_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static inline int gprinter_get_minor(void)
+{
+        return ida_simple_get(&printer_ida, 0, 0, GFP_KERNEL);
+}
+
+static inline void gprinter_put_minor(int minor)
+{
+        ida_simple_remove(&printer_ida, minor);
+}
+
+static int gprinter_setup(int);
+static void gprinter_cleanup(void);
+
+static void gprinter_free_inst(struct usb_function_instance *f)
+{
+        struct f_printer_opts *opts;
+
+        opts = container_of(f, struct f_printer_opts, func_inst);
+
+        mutex_lock(&printer_ida_lock);
+
+        gprinter_put_minor(opts->minor);
+        if (idr_is_empty(&printer_ida.idr))
+                gprinter_cleanup();
+
+        mutex_unlock(&printer_ida_lock);
+
+        kfree(opts);
+}
+
+static struct usb_function_instance *gprinter_alloc_inst(void)
+{
+        struct f_printer_opts *opts;
+        struct usb_function_instance *ret;
+        int status = 0;
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+
+        mutex_init(&opts->lock);
+        opts->func_inst.free_func_inst = gprinter_free_inst;
+        ret = &opts->func_inst;
+
+        mutex_lock(&printer_ida_lock);
+
+        if (idr_is_empty(&printer_ida.idr)) {
+                status = gprinter_setup(PRINTER_MINORS);
+                if (status) {
+                        ret = ERR_PTR(status);
+                        kfree(opts);
+                        goto unlock;
+                }
+        }
+
+        opts->minor = gprinter_get_minor();
+        if (opts->minor < 0) {
+                ret = ERR_PTR(opts->minor);
+                kfree(opts);
+                if (idr_is_empty(&printer_ida.idr))
+                        gprinter_cleanup();
+                goto unlock;
+        }
+        config_group_init_type_name(&opts->func_inst.group, "",
+                                    &printer_func_type);
+
+unlock:
+        mutex_unlock(&printer_ida_lock);
+        return ret;
+}
+
+static void gprinter_free(struct usb_function *f)
+{
+        struct printer_dev *dev = func_to_printer(f);
+        struct f_printer_opts *opts;
+
+        opts = container_of(f->fi, struct f_printer_opts, func_inst);
+        kfree(dev);
+        mutex_lock(&opts->lock);
+        --opts->refcnt;
+        mutex_unlock(&opts->lock);
+}
+
+static void printer_func_unbind(struct usb_configuration *c,
+                struct usb_function *f)
+{
+        struct printer_dev      *dev;
+        struct usb_request      *req;
+
+        dev = func_to_printer(f);
+
+        device_destroy(usb_gadget_class, MKDEV(major, dev->minor));
+
+        /* Remove Character Device */
+        cdev_del(&dev->printer_cdev);
+
+        /* we must already have been disconnected ... no i/o may be active */
+        WARN_ON(!list_empty(&dev->tx_reqs_active));
+        WARN_ON(!list_empty(&dev->rx_reqs_active));
+
+        /* Free all memory for this driver. */
+        while (!list_empty(&dev->tx_reqs)) {
+                req = container_of(dev->tx_reqs.next, struct usb_request,
+                                list);
+                list_del(&req->list);
+                printer_req_free(dev->in_ep, req);
+        }
+
+        if (dev->current_rx_req != NULL)
+                printer_req_free(dev->out_ep, dev->current_rx_req);
+
+        while (!list_empty(&dev->rx_reqs)) {
+                req = container_of(dev->rx_reqs.next,
+                                struct usb_request, list);
+                list_del(&req->list);
+                printer_req_free(dev->out_ep, req);
+        }
+
+        while (!list_empty(&dev->rx_buffers)) {
+                req = container_of(dev->rx_buffers.next,
+                                struct usb_request, list);
+                list_del(&req->list);
+                printer_req_free(dev->out_ep, req);
+        }
+        usb_free_all_descriptors(f);
+}
+
+static struct usb_function *gprinter_alloc(struct usb_function_instance *fi)
+{
+        struct printer_dev      *dev;
+        struct f_printer_opts   *opts;
+
+        opts = container_of(fi, struct f_printer_opts, func_inst);
+
+        mutex_lock(&opts->lock);
+        if (opts->minor >= minors) {
+                mutex_unlock(&opts->lock);
+                return ERR_PTR(-ENOENT);
+        }
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev) {
+                mutex_unlock(&opts->lock);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        ++opts->refcnt;
+        dev->minor = opts->minor;
+        dev->pnp_string = opts->pnp_string;
+        dev->q_len = opts->q_len;
+        mutex_unlock(&opts->lock);
+
+        dev->function.name = "printer";
+        dev->function.bind = printer_func_bind;
+        dev->function.setup = printer_func_setup;
+        dev->function.unbind = printer_func_unbind;
+        dev->function.set_alt = printer_func_set_alt;
+        dev->function.disable = printer_func_disable;
+        dev->function.req_match = gprinter_req_match;
+        dev->function.free_func = gprinter_free;
+
+        INIT_LIST_HEAD(&dev->tx_reqs);
+        INIT_LIST_HEAD(&dev->rx_reqs);
+        INIT_LIST_HEAD(&dev->rx_buffers);
+        INIT_LIST_HEAD(&dev->tx_reqs_active);
+        INIT_LIST_HEAD(&dev->rx_reqs_active);
+
+        spin_lock_init(&dev->lock);
+        mutex_init(&dev->lock_printer_io);
+        init_waitqueue_head(&dev->rx_wait);
+        init_waitqueue_head(&dev->tx_wait);
+        init_waitqueue_head(&dev->tx_flush_wait);
+
+        dev->interface = -1;
+        dev->printer_cdev_open = 0;
+        dev->printer_status = PRINTER_NOT_ERROR;
+        dev->current_rx_req = NULL;
+        dev->current_rx_bytes = 0;
+        dev->current_rx_buf = NULL;
+
+        return &dev->function;
+}
+
+DECLARE_USB_FUNCTION_INIT(printer, gprinter_alloc_inst, gprinter_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Craig Nadler");
+
+static int gprinter_setup(int count)
+{
+        int status;
+        dev_t devt;
+
+        usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget");
+        if (IS_ERR(usb_gadget_class)) {
+                status = PTR_ERR(usb_gadget_class);
+                usb_gadget_class = NULL;
+                pr_err("unable to create usb_gadget class %d\n", status);
+                return status;
+        }
+
+        status = alloc_chrdev_region(&devt, 0, count, "USB printer gadget");
+        if (status) {
+                pr_err("alloc_chrdev_region %d\n", status);
+                class_destroy(usb_gadget_class);
+                usb_gadget_class = NULL;
+                return status;
+        }
+
+        major = MAJOR(devt);
+        minors = count;
+
+        return status;
+}
+
+static void gprinter_cleanup(void)
+{
+        if (major) {
+                unregister_chrdev_region(MKDEV(major, 0), minors);
+                major = minors = 0;
+        }
+        class_destroy(usb_gadget_class);
+        usb_gadget_class = NULL;
+}
diff --git a/drivers/usb/gadget/function/f_sourcesink.c b/drivers/usb/gadget/function/f_sourcesink.c
index e3dae47baef3..3a5ae9900b1e 100644
--- a/drivers/usb/gadget/function/f_sourcesink.c
+++ b/drivers/usb/gadget/function/f_sourcesink.c
@@ -23,15 +23,6 @@
 #include "gadget_chips.h"
 #include "u_f.h"
 
-#define USB_MS_TO_SS_INTERVAL(x) USB_MS_TO_HS_INTERVAL(x)
-
-enum eptype {
-        EP_CONTROL = 0,
-        EP_BULK,
-        EP_ISOC,
-        EP_INTERRUPT,
-};
-
 /*
  * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
  * controller drivers.
@@ -64,8 +55,6 @@ struct f_sourcesink {
         struct usb_ep           *out_ep;
         struct usb_ep           *iso_in_ep;
         struct usb_ep           *iso_out_ep;
-        struct usb_ep           *int_in_ep;
-        struct usb_ep           *int_out_ep;
         int                     cur_alt;
 };
 
@@ -79,10 +68,6 @@ static unsigned isoc_interval;
 static unsigned isoc_maxpacket;
 static unsigned isoc_mult;
 static unsigned isoc_maxburst;
-static unsigned int_interval; /* In ms */
-static unsigned int_maxpacket;
-static unsigned int_mult;
-static unsigned int_maxburst;
 static unsigned buflen;
 
 /*-------------------------------------------------------------------------*/
@@ -107,16 +92,6 @@ static struct usb_interface_descriptor source_sink_intf_alt1 = {
         /* .iInterface          = DYNAMIC */
 };
 
-static struct usb_interface_descriptor source_sink_intf_alt2 = {
-        .bLength =              USB_DT_INTERFACE_SIZE,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bAlternateSetting =    2,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
-        /* .iInterface          = DYNAMIC */
-};
-
 /* full speed support: */
 
 static struct usb_endpoint_descriptor fs_source_desc = {
@@ -155,26 +130,6 @@ static struct usb_endpoint_descriptor fs_iso_sink_desc = {
         .bInterval =            4,
 };
 
-static struct usb_endpoint_descriptor fs_int_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(64),
-        .bInterval =            GZERO_INT_INTERVAL,
-};
-
-static struct usb_endpoint_descriptor fs_int_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(64),
-        .bInterval =            GZERO_INT_INTERVAL,
-};
-
 static struct usb_descriptor_header *fs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &fs_sink_desc,
@@ -185,10 +140,6 @@ static struct usb_descriptor_header *fs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &fs_source_desc,
         (struct usb_descriptor_header *) &fs_iso_sink_desc,
         (struct usb_descriptor_header *) &fs_iso_source_desc,
-        (struct usb_descriptor_header *) &source_sink_intf_alt2,
-#define FS_ALT_IFC_2_OFFSET     8
-        (struct usb_descriptor_header *) &fs_int_sink_desc,
-        (struct usb_descriptor_header *) &fs_int_source_desc,
         NULL,
 };
 
@@ -228,24 +179,6 @@ static struct usb_endpoint_descriptor hs_iso_sink_desc = {
         .bInterval =            4,
 };
 
-static struct usb_endpoint_descriptor hs_int_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-        .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
-};
-
-static struct usb_endpoint_descriptor hs_int_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-        .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
-};
-
 static struct usb_descriptor_header *hs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &hs_source_desc,
@@ -256,10 +189,6 @@ static struct usb_descriptor_header *hs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &hs_sink_desc,
         (struct usb_descriptor_header *) &hs_iso_source_desc,
         (struct usb_descriptor_header *) &hs_iso_sink_desc,
-        (struct usb_descriptor_header *) &source_sink_intf_alt2,
-#define HS_ALT_IFC_2_OFFSET     8
-        (struct usb_descriptor_header *) &hs_int_source_desc,
-        (struct usb_descriptor_header *) &hs_int_sink_desc,
         NULL,
 };
 
@@ -335,42 +264,6 @@ static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = {
         .wBytesPerInterval =    cpu_to_le16(1024),
 };
 
-static struct usb_endpoint_descriptor ss_int_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-        .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
-};
-
-static struct usb_ss_ep_comp_descriptor ss_int_source_comp_desc = {
-        .bLength =              USB_DT_SS_EP_COMP_SIZE,
-        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
-
-        .bMaxBurst =            0,
-        .bmAttributes =         0,
-        .wBytesPerInterval =    cpu_to_le16(1024),
-};
-
-static struct usb_endpoint_descriptor ss_int_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-        .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
-};
-
-static struct usb_ss_ep_comp_descriptor ss_int_sink_comp_desc = {
-        .bLength =              USB_DT_SS_EP_COMP_SIZE,
-        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
-
-        .bMaxBurst =            0,
-        .bmAttributes =         0,
-        .wBytesPerInterval =    cpu_to_le16(1024),
-};
-
 static struct usb_descriptor_header *ss_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &ss_source_desc,
@@ -387,12 +280,6 @@ static struct usb_descriptor_header *ss_source_sink_descs[] = {
         (struct usb_descriptor_header *) &ss_iso_source_comp_desc,
         (struct usb_descriptor_header *) &ss_iso_sink_desc,
         (struct usb_descriptor_header *) &ss_iso_sink_comp_desc,
-        (struct usb_descriptor_header *) &source_sink_intf_alt2,
-#define SS_ALT_IFC_2_OFFSET     14
-        (struct usb_descriptor_header *) &ss_int_source_desc,
-        (struct usb_descriptor_header *) &ss_int_source_comp_desc,
-        (struct usb_descriptor_header *) &ss_int_sink_desc,
-        (struct usb_descriptor_header *) &ss_int_sink_comp_desc,
         NULL,
 };
 
@@ -414,21 +301,6 @@ static struct usb_gadget_strings *sourcesink_strings[] = {
 };
 
 /*-------------------------------------------------------------------------*/
-static const char *get_ep_string(enum eptype ep_type)
-{
-        switch (ep_type) {
-        case EP_ISOC:
-                return "ISOC-";
-        case EP_INTERRUPT:
-                return "INTERRUPT-";
-        case EP_CONTROL:
-                return "CTRL-";
-        case EP_BULK:
-                return "BULK-";
-        default:
-                return "UNKNOWN-";
-        }
-}
 
 static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len)
 {
@@ -456,8 +328,7 @@ static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
 
 void disable_endpoints(struct usb_composite_dev *cdev,
                 struct usb_ep *in, struct usb_ep *out,
-                struct usb_ep *iso_in, struct usb_ep *iso_out,
-                struct usb_ep *int_in, struct usb_ep *int_out)
+                struct usb_ep *iso_in, struct usb_ep *iso_out)
 {
         disable_ep(cdev, in);
         disable_ep(cdev, out);
@@ -465,10 +336,6 @@ void disable_endpoints(struct usb_composite_dev *cdev,
                 disable_ep(cdev, iso_in);
         if (iso_out)
                 disable_ep(cdev, iso_out);
-        if (int_in)
-                disable_ep(cdev, int_in);
-        if (int_out)
-                disable_ep(cdev, int_out);
 }
 
 static int
@@ -485,7 +352,6 @@ sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
                 return id;
         source_sink_intf_alt0.bInterfaceNumber = id;
         source_sink_intf_alt1.bInterfaceNumber = id;
-        source_sink_intf_alt2.bInterfaceNumber = id;
 
         /* allocate bulk endpoints */
         ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
@@ -546,55 +412,14 @@ no_iso:
         if (isoc_maxpacket > 1024)
                 isoc_maxpacket = 1024;
 
-        /* sanity check the interrupt module parameters */
-        if (int_interval < 1)
-                int_interval = 1;
-        if (int_interval > 4096)
-                int_interval = 4096;
-        if (int_mult > 2)
-                int_mult = 2;
-        if (int_maxburst > 15)
-                int_maxburst = 15;
-
-        /* fill in the FS interrupt descriptors from the module parameters */
-        fs_int_source_desc.wMaxPacketSize = int_maxpacket > 64 ?
-                                                64 : int_maxpacket;
-        fs_int_source_desc.bInterval = int_interval > 255 ?
-                                                255 : int_interval;
-        fs_int_sink_desc.wMaxPacketSize = int_maxpacket > 64 ?
-                                                64 : int_maxpacket;
-        fs_int_sink_desc.bInterval = int_interval > 255 ?
-                                                255 : int_interval;
-
-        /* allocate int endpoints */
-        ss->int_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_source_desc);
-        if (!ss->int_in_ep)
-                goto no_int;
-        ss->int_in_ep->driver_data = cdev;      /* claim */
-
-        ss->int_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_sink_desc);
-        if (ss->int_out_ep) {
-                ss->int_out_ep->driver_data = cdev;     /* claim */
-        } else {
-                ss->int_in_ep->driver_data = NULL;
-                ss->int_in_ep = NULL;
-no_int:
-                fs_source_sink_descs[FS_ALT_IFC_2_OFFSET] = NULL;
-                hs_source_sink_descs[HS_ALT_IFC_2_OFFSET] = NULL;
-                ss_source_sink_descs[SS_ALT_IFC_2_OFFSET] = NULL;
-        }
-
-        if (int_maxpacket > 1024)
-                int_maxpacket = 1024;
-
         /* support high speed hardware */
         hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
         hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
 
         /*
-         * Fill in the HS isoc and interrupt descriptors from the module
-         * parameters. We assume that the user knows what they are doing and
-         * won't give parameters that their UDC doesn't support.
+         * Fill in the HS isoc descriptors from the module parameters.
+         * We assume that the user knows what they are doing and won't
+         * give parameters that their UDC doesn't support.
          */
         hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
         hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
@@ -607,17 +432,6 @@ no_int:
         hs_iso_sink_desc.bInterval = isoc_interval;
         hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 
-        hs_int_source_desc.wMaxPacketSize = int_maxpacket;
-        hs_int_source_desc.wMaxPacketSize |= int_mult << 11;
-        hs_int_source_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
-        hs_int_source_desc.bEndpointAddress =
-                fs_int_source_desc.bEndpointAddress;
-
-        hs_int_sink_desc.wMaxPacketSize = int_maxpacket;
-        hs_int_sink_desc.wMaxPacketSize |= int_mult << 11;
-        hs_int_sink_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
-        hs_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
-
         /* support super speed hardware */
         ss_source_desc.bEndpointAddress =
                 fs_source_desc.bEndpointAddress;
@@ -625,9 +439,9 @@ no_int:
                 fs_sink_desc.bEndpointAddress;
 
         /*
-         * Fill in the SS isoc and interrupt descriptors from the module
-         * parameters. We assume that the user knows what they are doing and
-         * won't give parameters that their UDC doesn't support.
+         * Fill in the SS isoc descriptors from the module parameters.
+         * We assume that the user knows what they are doing and won't
+         * give parameters that their UDC doesn't support.
          */
         ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
         ss_iso_source_desc.bInterval = isoc_interval;
@@ -646,37 +460,17 @@ no_int:
                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
         ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 
-        ss_int_source_desc.wMaxPacketSize = int_maxpacket;
-        ss_int_source_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
-        ss_int_source_comp_desc.bmAttributes = int_mult;
-        ss_int_source_comp_desc.bMaxBurst = int_maxburst;
-        ss_int_source_comp_desc.wBytesPerInterval =
-                int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
-        ss_int_source_desc.bEndpointAddress =
-                fs_int_source_desc.bEndpointAddress;
-
-        ss_int_sink_desc.wMaxPacketSize = int_maxpacket;
-        ss_int_sink_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
-        ss_int_sink_comp_desc.bmAttributes = int_mult;
-        ss_int_sink_comp_desc.bMaxBurst = int_maxburst;
-        ss_int_sink_comp_desc.wBytesPerInterval =
-                int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
-        ss_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
-
         ret = usb_assign_descriptors(f, fs_source_sink_descs,
                         hs_source_sink_descs, ss_source_sink_descs);
         if (ret)
                 return ret;
 
-        DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s, "
-                        "INT-IN/%s, INT-OUT/%s\n",
+        DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n",
             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
                         f->name, ss->in_ep->name, ss->out_ep->name,
                         ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
-                        ss->iso_out_ep ? ss->iso_out_ep->name : "<none>",
-                        ss->int_in_ep ? ss->int_in_ep->name : "<none>",
-                        ss->int_out_ep ? ss->int_out_ep->name : "<none>");
+                        ss->iso_out_ep ? ss->iso_out_ep->name : "<none>");
         return 0;
 }
 
@@ -807,15 +601,14 @@ static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 }
 
 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
-                enum eptype ep_type, int speed)
+                bool is_iso, int speed)
 {
         struct usb_ep           *ep;
         struct usb_request      *req;
         int                     i, size, status;
 
         for (i = 0; i < 8; i++) {
-                switch (ep_type) {
-                case EP_ISOC:
+                if (is_iso) {
                         switch (speed) {
                         case USB_SPEED_SUPER:
                                 size = isoc_maxpacket * (isoc_mult + 1) *
@@ -831,28 +624,9 @@ static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
                         }
                         ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
                         req = ss_alloc_ep_req(ep, size);
-                        break;
-                case EP_INTERRUPT:
-                        switch (speed) {
-                        case USB_SPEED_SUPER:
-                                size = int_maxpacket * (int_mult + 1) *
-                                                (int_maxburst + 1);
-                                break;
-                        case USB_SPEED_HIGH:
-                                size = int_maxpacket * (int_mult + 1);
-                                break;
-                        default:
-                                size = int_maxpacket > 1023 ?
-                                                1023 : int_maxpacket;
-                                break;
-                        }
-                        ep = is_in ? ss->int_in_ep : ss->int_out_ep;
-                        req = ss_alloc_ep_req(ep, size);
-                        break;
-                default:
+                } else {
                         ep = is_in ? ss->in_ep : ss->out_ep;
                         req = ss_alloc_ep_req(ep, 0);
-                        break;
                 }
 
                 if (!req)
@@ -870,12 +644,12 @@ static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
 
                         cdev = ss->function.config->cdev;
                         ERROR(cdev, "start %s%s %s --> %d\n",
-                                get_ep_string(ep_type), is_in ? "IN" : "OUT",
-                                ep->name, status);
+                              is_iso ? "ISO-" : "", is_in ? "IN" : "OUT",
+                              ep->name, status);
                         free_ep_req(ep, req);
                 }
 
-                if (!(ep_type == EP_ISOC))
+                if (!is_iso)
                         break;
         }
 
@@ -888,7 +662,7 @@ static void disable_source_sink(struct f_sourcesink *ss)
 
         cdev = ss->function.config->cdev;
         disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
-                        ss->iso_out_ep, ss->int_in_ep, ss->int_out_ep);
+                        ss->iso_out_ep);
         VDBG(cdev, "%s disabled\n", ss->function.name);
 }
 
@@ -900,62 +674,6 @@ enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
         int                                     speed = cdev->gadget->speed;
         struct usb_ep                           *ep;
 
-        if (alt == 2) {
-                /* Configure for periodic interrupt endpoint */
-                ep = ss->int_in_ep;
-                if (ep) {
-                        result = config_ep_by_speed(cdev->gadget,
-                                        &(ss->function), ep);
-                        if (result)
-                                return result;
-
-                        result = usb_ep_enable(ep);
-                        if (result < 0)
-                                return result;
-
-                        ep->driver_data = ss;
-                        result = source_sink_start_ep(ss, true, EP_INTERRUPT,
-                                        speed);
-                        if (result < 0) {
-fail1:
-                                ep = ss->int_in_ep;
-                                if (ep) {
-                                        usb_ep_disable(ep);
-                                        ep->driver_data = NULL;
-                                }
-                                return result;
-                        }
-                }
-
-                /*
-                 * one interrupt endpoint reads (sinks) anything OUT (from the
-                 * host)
-                 */
-                ep = ss->int_out_ep;
-                if (ep) {
-                        result = config_ep_by_speed(cdev->gadget,
-                                        &(ss->function), ep);
-                        if (result)
-                                goto fail1;
-
-                        result = usb_ep_enable(ep);
-                        if (result < 0)
-                                goto fail1;
-
-                        ep->driver_data = ss;
-                        result = source_sink_start_ep(ss, false, EP_INTERRUPT,
-                                        speed);
-                        if (result < 0) {
-                                ep = ss->int_out_ep;
-                                usb_ep_disable(ep);
-                                ep->driver_data = NULL;
-                                goto fail1;
-                        }
-                }
-
-                goto out;
-        }
-
         /* one bulk endpoint writes (sources) zeroes IN (to the host) */
         ep = ss->in_ep;
         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
@@ -966,7 +684,7 @@ fail1:
                 return result;
         ep->driver_data = ss;
 
-        result = source_sink_start_ep(ss, true, EP_BULK, speed);
+        result = source_sink_start_ep(ss, true, false, speed);
         if (result < 0) {
 fail:
                 ep = ss->in_ep;
@@ -985,7 +703,7 @@ fail:
                 goto fail;
         ep->driver_data = ss;
 
-        result = source_sink_start_ep(ss, false, EP_BULK, speed);
+        result = source_sink_start_ep(ss, false, false, speed);
         if (result < 0) {
 fail2:
                 ep = ss->out_ep;
@@ -1008,7 +726,7 @@ fail2:
                         goto fail2;
                 ep->driver_data = ss;
 
-                result = source_sink_start_ep(ss, true, EP_ISOC, speed);
+                result = source_sink_start_ep(ss, true, true, speed);
                 if (result < 0) {
 fail3:
                         ep = ss->iso_in_ep;
@@ -1031,14 +749,13 @@ fail3:
                         goto fail3;
                 ep->driver_data = ss;
 
-                result = source_sink_start_ep(ss, false, EP_ISOC, speed);
+                result = source_sink_start_ep(ss, false, true, speed);
                 if (result < 0) {
                         usb_ep_disable(ep);
                         ep->driver_data = NULL;
                         goto fail3;
                 }
         }
-
 out:
         ss->cur_alt = alt;
 
@@ -1054,8 +771,6 @@ static int sourcesink_set_alt(struct usb_function *f,
 
         if (ss->in_ep->driver_data)
                 disable_source_sink(ss);
-        else if (alt == 2 && ss->int_in_ep->driver_data)
-                disable_source_sink(ss);
         return enable_source_sink(cdev, ss, alt);
 }
 
@@ -1168,10 +883,6 @@ static struct usb_function *source_sink_alloc_func(
         isoc_maxpacket = ss_opts->isoc_maxpacket;
         isoc_mult = ss_opts->isoc_mult;
         isoc_maxburst = ss_opts->isoc_maxburst;
-        int_interval = ss_opts->int_interval;
-        int_maxpacket = ss_opts->int_maxpacket;
-        int_mult = ss_opts->int_mult;
-        int_maxburst = ss_opts->int_maxburst;
         buflen = ss_opts->bulk_buflen;
 
         ss->function.name = "source/sink";
@@ -1468,182 +1179,6 @@ static struct f_ss_opts_attribute f_ss_opts_bulk_buflen =
                         f_ss_opts_bulk_buflen_show,
                         f_ss_opts_bulk_buflen_store);
 
-static ssize_t f_ss_opts_int_interval_show(struct f_ss_opts *opts, char *page)
-{
-        int result;
-
-        mutex_lock(&opts->lock);
-        result = sprintf(page, "%u", opts->int_interval);
-        mutex_unlock(&opts->lock);
-
-        return result;
-}
-
-static ssize_t f_ss_opts_int_interval_store(struct f_ss_opts *opts,
-                                       const char *page, size_t len)
-{
-        int ret;
-        u32 num;
-
-        mutex_lock(&opts->lock);
-        if (opts->refcnt) {
-                ret = -EBUSY;
-                goto end;
-        }
-
-        ret = kstrtou32(page, 0, &num);
-        if (ret)
-                goto end;
-
-        if (num > 4096) {
-                ret = -EINVAL;
-                goto end;
-        }
-
-        opts->int_interval = num;
-        ret = len;
-end:
-        mutex_unlock(&opts->lock);
-        return ret;
-}
-
-static struct f_ss_opts_attribute f_ss_opts_int_interval =
-        __CONFIGFS_ATTR(int_interval, S_IRUGO | S_IWUSR,
-                        f_ss_opts_int_interval_show,
-                        f_ss_opts_int_interval_store);
-
-static ssize_t f_ss_opts_int_maxpacket_show(struct f_ss_opts *opts, char *page)
-{
-        int result;
-
-        mutex_lock(&opts->lock);
-        result = sprintf(page, "%u", opts->int_maxpacket);
-        mutex_unlock(&opts->lock);
-
-        return result;
-}
-
-static ssize_t f_ss_opts_int_maxpacket_store(struct f_ss_opts *opts,
-                                       const char *page, size_t len)
-{
-        int ret;
-        u16 num;
-
-        mutex_lock(&opts->lock);
-        if (opts->refcnt) {
-                ret = -EBUSY;
-                goto end;
-        }
-
-        ret = kstrtou16(page, 0, &num);
-        if (ret)
-                goto end;
-
-        if (num > 1024) {
-                ret = -EINVAL;
-                goto end;
-        }
-
-        opts->int_maxpacket = num;
-        ret = len;
-end:
-        mutex_unlock(&opts->lock);
-        return ret;
-}
-
-static struct f_ss_opts_attribute f_ss_opts_int_maxpacket =
-        __CONFIGFS_ATTR(int_maxpacket, S_IRUGO | S_IWUSR,
-                        f_ss_opts_int_maxpacket_show,
-                        f_ss_opts_int_maxpacket_store);
-
-static ssize_t f_ss_opts_int_mult_show(struct f_ss_opts *opts, char *page)
-{
-        int result;
-
-        mutex_lock(&opts->lock);
-        result = sprintf(page, "%u", opts->int_mult);
-        mutex_unlock(&opts->lock);
-
-        return result;
-}
-
-static ssize_t f_ss_opts_int_mult_store(struct f_ss_opts *opts,
-                                       const char *page, size_t len)
-{
-        int ret;
-        u8 num;
-
-        mutex_lock(&opts->lock);
-        if (opts->refcnt) {
-                ret = -EBUSY;
-                goto end;
-        }
-
-        ret = kstrtou8(page, 0, &num);
-        if (ret)
-                goto end;
-
-        if (num > 2) {
-                ret = -EINVAL;
-                goto end;
-        }
-
-        opts->int_mult = num;
-        ret = len;
-end:
-        mutex_unlock(&opts->lock);
-        return ret;
-}
-
-static struct f_ss_opts_attribute f_ss_opts_int_mult =
-        __CONFIGFS_ATTR(int_mult, S_IRUGO | S_IWUSR,
-                        f_ss_opts_int_mult_show,
-                        f_ss_opts_int_mult_store);
-
-static ssize_t f_ss_opts_int_maxburst_show(struct f_ss_opts *opts, char *page)
-{
-        int result;
-
-        mutex_lock(&opts->lock);
-        result = sprintf(page, "%u", opts->int_maxburst);
-        mutex_unlock(&opts->lock);
-
-        return result;
-}
-
-static ssize_t f_ss_opts_int_maxburst_store(struct f_ss_opts *opts,
-                                       const char *page, size_t len)
-{
-        int ret;
-        u8 num;
-
-        mutex_lock(&opts->lock);
-        if (opts->refcnt) {
-                ret = -EBUSY;
-                goto end;
-        }
-
-        ret = kstrtou8(page, 0, &num);
-        if (ret)
-                goto end;
-
-        if (num > 15) {
-                ret = -EINVAL;
-                goto end;
-        }
-
-        opts->int_maxburst = num;
-        ret = len;
-end:
-        mutex_unlock(&opts->lock);
-        return ret;
-}
-
-static struct f_ss_opts_attribute f_ss_opts_int_maxburst =
-        __CONFIGFS_ATTR(int_maxburst, S_IRUGO | S_IWUSR,
-                        f_ss_opts_int_maxburst_show,
-                        f_ss_opts_int_maxburst_store);
-
 static struct configfs_attribute *ss_attrs[] = {
         &f_ss_opts_pattern.attr,
         &f_ss_opts_isoc_interval.attr,
@@ -1651,10 +1186,6 @@ static struct configfs_attribute *ss_attrs[] = {
         &f_ss_opts_isoc_mult.attr,
         &f_ss_opts_isoc_maxburst.attr,
         &f_ss_opts_bulk_buflen.attr,
-        &f_ss_opts_int_interval.attr,
-        &f_ss_opts_int_maxpacket.attr,
-        &f_ss_opts_int_mult.attr,
-        &f_ss_opts_int_maxburst.attr,
         NULL,
 };
 
@@ -1684,8 +1215,6 @@ static struct usb_function_instance *source_sink_alloc_inst(void)
         ss_opts->isoc_interval = GZERO_ISOC_INTERVAL;
         ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET;
         ss_opts->bulk_buflen = GZERO_BULK_BUFLEN;
-        ss_opts->int_interval = GZERO_INT_INTERVAL;
-        ss_opts->int_maxpacket = GZERO_INT_MAXPACKET;
 
         config_group_init_type_name(&ss_opts->func_inst.group, "",
                                     &ss_func_type);
diff --git a/drivers/usb/gadget/function/g_zero.h b/drivers/usb/gadget/function/g_zero.h
index 2ce28b9d97cc..15f180904f8a 100644
--- a/drivers/usb/gadget/function/g_zero.h
+++ b/drivers/usb/gadget/function/g_zero.h
@@ -10,8 +10,6 @@
 #define GZERO_QLEN              32
 #define GZERO_ISOC_INTERVAL     4
 #define GZERO_ISOC_MAXPACKET    1024
-#define GZERO_INT_INTERVAL      1 /* Default interrupt interval = 1 ms */
-#define GZERO_INT_MAXPACKET     1024
 
 struct usb_zero_options {
         unsigned pattern;
@@ -19,10 +17,6 @@ struct usb_zero_options {
         unsigned isoc_maxpacket;
         unsigned isoc_mult;
         unsigned isoc_maxburst;
-        unsigned int_interval; /* In ms */
-        unsigned int_maxpacket;
-        unsigned int_mult;
-        unsigned int_maxburst;
         unsigned bulk_buflen;
         unsigned qlen;
 };
@@ -34,10 +28,6 @@ struct f_ss_opts {
         unsigned isoc_maxpacket;
         unsigned isoc_mult;
         unsigned isoc_maxburst;
-        unsigned int_interval; /* In ms */
-        unsigned int_maxpacket;
-        unsigned int_mult;
-        unsigned int_maxburst;
         unsigned bulk_buflen;
 
         /*
@@ -72,7 +62,6 @@ int lb_modinit(void);
 void free_ep_req(struct usb_ep *ep, struct usb_request *req);
 void disable_endpoints(struct usb_composite_dev *cdev,
                 struct usb_ep *in, struct usb_ep *out,
-                struct usb_ep *iso_in, struct usb_ep *iso_out,
-                struct usb_ep *int_in, struct usb_ep *int_out);
+                struct usb_ep *iso_in, struct usb_ep *iso_out);
 
 #endif /* __G_ZERO_H */
diff --git a/drivers/usb/gadget/function/u_printer.h b/drivers/usb/gadget/function/u_printer.h
new file mode 100644
index 000000000000..0e2c49d4274e
--- /dev/null
+++ b/drivers/usb/gadget/function/u_printer.h
@@ -0,0 +1,37 @@
+/*
+ * u_printer.h
+ *
+ * Utility definitions for the printer function
+ *
+ * Copyright (c) 2015 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_PRINTER_H
+#define U_PRINTER_H
+
+#include <linux/usb/composite.h>
+
+#define PNP_STRING_LEN                  1024
+
+struct f_printer_opts {
+        struct usb_function_instance    func_inst;
+        int                             minor;
+        char                            pnp_string[PNP_STRING_LEN];
+        unsigned                        q_len;
+
+        /*
+         * Protect the data from concurrent access by read/write
+         * and create symlink/remove symlink
+         */
+        struct mutex                    lock;
+        int                             refcnt;
+};
+
+#endif /* U_PRINTER_H */
diff --git a/drivers/usb/gadget/function/u_serial.c b/drivers/usb/gadget/function/u_serial.c
index 491082aaf103..89179ab20c10 100644
--- a/drivers/usb/gadget/function/u_serial.c
+++ b/drivers/usb/gadget/function/u_serial.c
@@ -912,7 +912,7 @@ static int gs_put_char(struct tty_struct *tty, unsigned char ch)
         unsigned long   flags;
         int             status;
 
-        pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n",
+        pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n",
                 port->port_num, tty, ch, __builtin_return_address(0));
 
         spin_lock_irqsave(&port->port_lock, flags);
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index 113c87e22117..d5a7102de696 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -301,6 +301,7 @@ config USB_MIDI_GADGET
 config USB_G_PRINTER
         tristate "Printer Gadget"
         select USB_LIBCOMPOSITE
+        select USB_F_PRINTER
         help
           The Printer Gadget channels data between the USB host and a
           userspace program driving the print engine. The user space
diff --git a/drivers/usb/gadget/legacy/printer.c b/drivers/usb/gadget/legacy/printer.c
index 90545980542f..d5b6ee725a2a 100644
--- a/drivers/usb/gadget/legacy/printer.c
+++ b/drivers/usb/gadget/legacy/printer.c
@@ -12,29 +12,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/mutex.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
-#include <linux/device.h>
-#include <linux/moduleparam.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/types.h>
-#include <linux/ctype.h>
-#include <linux/cdev.h>
-
 #include <asm/byteorder.h>
-#include <linux/io.h>
-#include <linux/irq.h>
-#include <linux/uaccess.h>
-#include <asm/unaligned.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/composite.h>
@@ -46,50 +24,12 @@
 USB_GADGET_COMPOSITE_OPTIONS();
 
 #define DRIVER_DESC             "Printer Gadget"
-#define DRIVER_VERSION          "2007 OCT 06"
+#define DRIVER_VERSION          "2015 FEB 17"
 
-static DEFINE_MUTEX(printer_mutex);
 static const char shortname [] = "printer";
 static const char driver_desc [] = DRIVER_DESC;
 
-static dev_t g_printer_devno;
-
-static struct class *usb_gadget_class;
-
-/*-------------------------------------------------------------------------*/
-
-struct printer_dev {
-        spinlock_t              lock;           /* lock this structure */
-        /* lock buffer lists during read/write calls */
-        struct mutex            lock_printer_io;
-        struct usb_gadget       *gadget;
-        s8                      interface;
-        struct usb_ep           *in_ep, *out_ep;
-
-        struct list_head        rx_reqs;        /* List of free RX structs */
-        struct list_head        rx_reqs_active; /* List of Active RX xfers */
-        struct list_head        rx_buffers;     /* List of completed xfers */
-        /* wait until there is data to be read. */
-        wait_queue_head_t       rx_wait;
-        struct list_head        tx_reqs;        /* List of free TX structs */
-        struct list_head        tx_reqs_active; /* List of Active TX xfers */
-        /* Wait until there are write buffers available to use. */
-        wait_queue_head_t       tx_wait;
-        /* Wait until all write buffers have been sent. */
-        wait_queue_head_t       tx_flush_wait;
-        struct usb_request      *current_rx_req;
-        size_t                  current_rx_bytes;
-        u8                      *current_rx_buf;
-        u8                      printer_status;
-        u8                      reset_printer;
-        struct cdev             printer_cdev;
-        struct device           *pdev;
-        u8                      printer_cdev_open;
-        wait_queue_head_t       wait;
-        struct usb_function     function;
-};
-
-static struct printer_dev usb_printer_gadget;
+#include "u_printer.h"
 
 /*-------------------------------------------------------------------------*/
 
@@ -120,6 +60,9 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR);
 
 #define QLEN    qlen
 
+static struct usb_function_instance *fi_printer;
+static struct usb_function *f_printer;
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -127,10 +70,6 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR);
  * descriptors are built on demand.
  */
 
-/* holds our biggest descriptor */
-#define USB_DESC_BUFSIZE                256
-#define USB_BUFSIZE                     8192
-
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
         .bDescriptorType =      USB_DT_DEVICE,
@@ -143,108 +82,6 @@ static struct usb_device_descriptor device_desc = {
         .bNumConfigurations =   1
 };
 
-static struct usb_interface_descriptor intf_desc = {
-        .bLength =              sizeof intf_desc,
-        .bDescriptorType =      USB_DT_INTERFACE,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_PRINTER,
-        .bInterfaceSubClass =   1,      /* Printer Sub-Class */
-        .bInterfaceProtocol =   2,      /* Bi-Directional */
-        .iInterface =           0
-};
-
-static struct usb_endpoint_descriptor fs_ep_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK
-};
-
-static struct usb_endpoint_descriptor fs_ep_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK
-};
-
-static struct usb_descriptor_header *fs_printer_function[] = {
-        (struct usb_descriptor_header *) &intf_desc,
-        (struct usb_descriptor_header *) &fs_ep_in_desc,
-        (struct usb_descriptor_header *) &fs_ep_out_desc,
-        NULL
-};
-
-/*
- * usb 2.0 devices need to expose both high speed and full speed
- * descriptors, unless they only run at full speed.
- */
-
-static struct usb_endpoint_descriptor hs_ep_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(512)
-};
-
-static struct usb_endpoint_descriptor hs_ep_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(512)
-};
-
-static struct usb_qualifier_descriptor dev_qualifier = {
-        .bLength =              sizeof dev_qualifier,
-        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
-        .bcdUSB =               cpu_to_le16(0x0200),
-        .bDeviceClass =         USB_CLASS_PRINTER,
-        .bNumConfigurations =   1
-};
-
-static struct usb_descriptor_header *hs_printer_function[] = {
-        (struct usb_descriptor_header *) &intf_desc,
-        (struct usb_descriptor_header *) &hs_ep_in_desc,
-        (struct usb_descriptor_header *) &hs_ep_out_desc,
-        NULL
-};
-
-/*
- * Added endpoint descriptors for 3.0 devices
- */
-
-static struct usb_endpoint_descriptor ss_ep_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-};
-
-static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = {
-        .bLength =              sizeof(ss_ep_in_comp_desc),
-        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
-};
-
-static struct usb_endpoint_descriptor ss_ep_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(1024),
-};
-
-static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = {
-        .bLength =              sizeof(ss_ep_out_comp_desc),
-        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
-};
-
-static struct usb_descriptor_header *ss_printer_function[] = {
-        (struct usb_descriptor_header *) &intf_desc,
-        (struct usb_descriptor_header *) &ss_ep_in_desc,
-        (struct usb_descriptor_header *) &ss_ep_in_comp_desc,
-        (struct usb_descriptor_header *) &ss_ep_out_desc,
-        (struct usb_descriptor_header *) &ss_ep_out_comp_desc,
-        NULL
-};
-
 static struct usb_otg_descriptor otg_descriptor = {
         .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
@@ -256,29 +93,13 @@ static const struct usb_descriptor_header *otg_desc[] = {
         NULL,
 };
 
-/* maxpacket and other transfer characteristics vary by speed. */
-static inline struct usb_endpoint_descriptor *ep_desc(struct usb_gadget *gadget,
-                                        struct usb_endpoint_descriptor *fs,
-                                        struct usb_endpoint_descriptor *hs,
-                                        struct usb_endpoint_descriptor *ss)
-{
-        switch (gadget->speed) {
-        case USB_SPEED_SUPER:
-                return ss;
-        case USB_SPEED_HIGH:
-                return hs;
-        default:
-                return fs;
-        }
-}
-
 /*-------------------------------------------------------------------------*/
 
 /* descriptors that are built on-demand */
 
 static char                             product_desc [40] = DRIVER_DESC;
 static char                             serial_num [40] = "1";
-static char                             pnp_string [1024] =
+static char                             pnp_string[PNP_STRING_LEN] =
         "XXMFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;";
 
 /* static strings, in UTF-8 */
@@ -299,921 +120,19 @@ static struct usb_gadget_strings *dev_strings[] = {
         NULL,
 };
 
-/*-------------------------------------------------------------------------*/
-
-static struct usb_request *
-printer_req_alloc(struct usb_ep *ep, unsigned len, gfp_t gfp_flags)
-{
-        struct usb_request      *req;
-
-        req = usb_ep_alloc_request(ep, gfp_flags);
-
-        if (req != NULL) {
-                req->length = len;
-                req->buf = kmalloc(len, gfp_flags);
-                if (req->buf == NULL) {
-                        usb_ep_free_request(ep, req);
-                        return NULL;
-                }
-        }
-
-        return req;
-}
-
-static void
-printer_req_free(struct usb_ep *ep, struct usb_request *req)
-{
-        if (ep != NULL && req != NULL) {
-                kfree(req->buf);
-                usb_ep_free_request(ep, req);
-        }
-}
-
-/*-------------------------------------------------------------------------*/
-
-static void rx_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        struct printer_dev      *dev = ep->driver_data;
-        int                     status = req->status;
-        unsigned long           flags;
-
-        spin_lock_irqsave(&dev->lock, flags);
-
-        list_del_init(&req->list);      /* Remode from Active List */
-
-        switch (status) {
-
-        /* normal completion */
-        case 0:
-                if (req->actual > 0) {
-                        list_add_tail(&req->list, &dev->rx_buffers);
-                        DBG(dev, "G_Printer : rx length %d\n", req->actual);
-                } else {
-                        list_add(&req->list, &dev->rx_reqs);
-                }
-                break;
-
-        /* software-driven interface shutdown */
-        case -ECONNRESET:               /* unlink */
-        case -ESHUTDOWN:                /* disconnect etc */
-                VDBG(dev, "rx shutdown, code %d\n", status);
-                list_add(&req->list, &dev->rx_reqs);
-                break;
-
-        /* for hardware automagic (such as pxa) */
-        case -ECONNABORTED:             /* endpoint reset */
-                DBG(dev, "rx %s reset\n", ep->name);
-                list_add(&req->list, &dev->rx_reqs);
-                break;
-
-        /* data overrun */
-        case -EOVERFLOW:
-                /* FALLTHROUGH */
-
-        default:
-                DBG(dev, "rx status %d\n", status);
-                list_add(&req->list, &dev->rx_reqs);
-                break;
-        }
-
-        wake_up_interruptible(&dev->rx_wait);
-        spin_unlock_irqrestore(&dev->lock, flags);
-}
-
-static void tx_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        struct printer_dev      *dev = ep->driver_data;
-
-        switch (req->status) {
-        default:
-                VDBG(dev, "tx err %d\n", req->status);
-                /* FALLTHROUGH */
-        case -ECONNRESET:               /* unlink */
-        case -ESHUTDOWN:                /* disconnect etc */
-                break;
-        case 0:
-                break;
-        }
-
-        spin_lock(&dev->lock);
-        /* Take the request struct off the active list and put it on the
-         * free list.
-         */
-        list_del_init(&req->list);
-        list_add(&req->list, &dev->tx_reqs);
-        wake_up_interruptible(&dev->tx_wait);
-        if (likely(list_empty(&dev->tx_reqs_active)))
-                wake_up_interruptible(&dev->tx_flush_wait);
-
-        spin_unlock(&dev->lock);
-}
-
-/*-------------------------------------------------------------------------*/
-
-static int
-printer_open(struct inode *inode, struct file *fd)
-{
-        struct printer_dev      *dev;
-        unsigned long           flags;
-        int                     ret = -EBUSY;
-
-        mutex_lock(&printer_mutex);
-        dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
-
-        spin_lock_irqsave(&dev->lock, flags);
-
-        if (!dev->printer_cdev_open) {
-                dev->printer_cdev_open = 1;
-                fd->private_data = dev;
-                ret = 0;
-                /* Change the printer status to show that it's on-line. */
-                dev->printer_status |= PRINTER_SELECTED;
-        }
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        DBG(dev, "printer_open returned %x\n", ret);
-        mutex_unlock(&printer_mutex);
-        return ret;
-}
-
-static int
-printer_close(struct inode *inode, struct file *fd)
-{
-        struct printer_dev      *dev = fd->private_data;
-        unsigned long           flags;
-
-        spin_lock_irqsave(&dev->lock, flags);
-        dev->printer_cdev_open = 0;
-        fd->private_data = NULL;
-        /* Change printer status to show that the printer is off-line. */
-        dev->printer_status &= ~PRINTER_SELECTED;
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        DBG(dev, "printer_close\n");
-
-        return 0;
-}
-
-/* This function must be called with interrupts turned off. */
-static void
-setup_rx_reqs(struct printer_dev *dev)
-{
-        struct usb_request              *req;
-
-        while (likely(!list_empty(&dev->rx_reqs))) {
-                int error;
-
-                req = container_of(dev->rx_reqs.next,
-                                struct usb_request, list);
-                list_del_init(&req->list);
-
-                /* The USB Host sends us whatever amount of data it wants to
-                 * so we always set the length field to the full USB_BUFSIZE.
-                 * If the amount of data is more than the read() caller asked
-                 * for it will be stored in the request buffer until it is
-                 * asked for by read().
-                 */
-                req->length = USB_BUFSIZE;
-                req->complete = rx_complete;
-
-                /* here, we unlock, and only unlock, to avoid deadlock. */
-                spin_unlock(&dev->lock);
-                error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
-                spin_lock(&dev->lock);
-                if (error) {
-                        DBG(dev, "rx submit --> %d\n", error);
-                        list_add(&req->list, &dev->rx_reqs);
-                        break;
-                }
-                /* if the req is empty, then add it into dev->rx_reqs_active. */
-                else if (list_empty(&req->list)) {
-                        list_add(&req->list, &dev->rx_reqs_active);
-                }
-        }
-}
-
-static ssize_t
-printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
-{
-        struct printer_dev              *dev = fd->private_data;
-        unsigned long                   flags;
-        size_t                          size;
-        size_t                          bytes_copied;
-        struct usb_request              *req;
-        /* This is a pointer to the current USB rx request. */
-        struct usb_request              *current_rx_req;
-        /* This is the number of bytes in the current rx buffer. */
-        size_t                          current_rx_bytes;
-        /* This is a pointer to the current rx buffer. */
-        u8                              *current_rx_buf;
-
-        if (len == 0)
-                return -EINVAL;
-
-        DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
-
-        mutex_lock(&dev->lock_printer_io);
-        spin_lock_irqsave(&dev->lock, flags);
-
-        /* We will use this flag later to check if a printer reset happened
-         * after we turn interrupts back on.
-         */
-        dev->reset_printer = 0;
-
-        setup_rx_reqs(dev);
-
-        bytes_copied = 0;
-        current_rx_req = dev->current_rx_req;
-        current_rx_bytes = dev->current_rx_bytes;
-        current_rx_buf = dev->current_rx_buf;
-        dev->current_rx_req = NULL;
-        dev->current_rx_bytes = 0;
-        dev->current_rx_buf = NULL;
-
-        /* Check if there is any data in the read buffers. Please note that
-         * current_rx_bytes is the number of bytes in the current rx buffer.
-         * If it is zero then check if there are any other rx_buffers that
-         * are on the completed list. We are only out of data if all rx
-         * buffers are empty.
-         */
-        if ((current_rx_bytes == 0) &&
-                        (likely(list_empty(&dev->rx_buffers)))) {
-                /* Turn interrupts back on before sleeping. */
-                spin_unlock_irqrestore(&dev->lock, flags);
-
-                /*
-                 * If no data is available check if this is a NON-Blocking
-                 * call or not.
-                 */
-                if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
-                        mutex_unlock(&dev->lock_printer_io);
-                        return -EAGAIN;
-                }
-
-                /* Sleep until data is available */
-                wait_event_interruptible(dev->rx_wait,
-                                (likely(!list_empty(&dev->rx_buffers))));
-                spin_lock_irqsave(&dev->lock, flags);
-        }
-
-        /* We have data to return then copy it to the caller's buffer.*/
-        while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
-                        && len) {
-                if (current_rx_bytes == 0) {
-                        req = container_of(dev->rx_buffers.next,
-                                        struct usb_request, list);
-                        list_del_init(&req->list);
-
-                        if (req->actual && req->buf) {
-                                current_rx_req = req;
-                                current_rx_bytes = req->actual;
-                                current_rx_buf = req->buf;
-                        } else {
-                                list_add(&req->list, &dev->rx_reqs);
-                                continue;
-                        }
-                }
-
-                /* Don't leave irqs off while doing memory copies */
-                spin_unlock_irqrestore(&dev->lock, flags);
-
-                if (len > current_rx_bytes)
-                        size = current_rx_bytes;
-                else
-                        size = len;
-
-                size -= copy_to_user(buf, current_rx_buf, size);
-                bytes_copied += size;
-                len -= size;
-                buf += size;
-
-                spin_lock_irqsave(&dev->lock, flags);
-
-                /* We've disconnected or reset so return. */
-                if (dev->reset_printer) {
-                        list_add(&current_rx_req->list, &dev->rx_reqs);
-                        spin_unlock_irqrestore(&dev->lock, flags);
-                        mutex_unlock(&dev->lock_printer_io);
-                        return -EAGAIN;
-                }
-
-                /* If we not returning all the data left in this RX request
-                 * buffer then adjust the amount of data left in the buffer.
-                 * Othewise if we are done with this RX request buffer then
-                 * requeue it to get any incoming data from the USB host.
-                 */
-                if (size < current_rx_bytes) {
-                        current_rx_bytes -= size;
-                        current_rx_buf += size;
-                } else {
-                        list_add(&current_rx_req->list, &dev->rx_reqs);
-                        current_rx_bytes = 0;
-                        current_rx_buf = NULL;
-                        current_rx_req = NULL;
-                }
-        }
-
-        dev->current_rx_req = current_rx_req;
-        dev->current_rx_bytes = current_rx_bytes;
-        dev->current_rx_buf = current_rx_buf;
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-        mutex_unlock(&dev->lock_printer_io);
-
-        DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied);
-
-        if (bytes_copied)
-                return bytes_copied;
-        else
-                return -EAGAIN;
-}
-
-static ssize_t
-printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
-{
-        struct printer_dev      *dev = fd->private_data;
-        unsigned long           flags;
-        size_t                  size;   /* Amount of data in a TX request. */
-        size_t                  bytes_copied = 0;
-        struct usb_request      *req;
-
-        DBG(dev, "printer_write trying to send %d bytes\n", (int)len);
-
-        if (len == 0)
-                return -EINVAL;
-
-        mutex_lock(&dev->lock_printer_io);
-        spin_lock_irqsave(&dev->lock, flags);
-
-        /* Check if a printer reset happens while we have interrupts on */
-        dev->reset_printer = 0;
-
-        /* Check if there is any available write buffers */
-        if (likely(list_empty(&dev->tx_reqs))) {
-                /* Turn interrupts back on before sleeping. */
-                spin_unlock_irqrestore(&dev->lock, flags);
-
-                /*
-                 * If write buffers are available check if this is
-                 * a NON-Blocking call or not.
-                 */
-                if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
-                        mutex_unlock(&dev->lock_printer_io);
-                        return -EAGAIN;
-                }
-
-                /* Sleep until a write buffer is available */
-                wait_event_interruptible(dev->tx_wait,
-                                (likely(!list_empty(&dev->tx_reqs))));
-                spin_lock_irqsave(&dev->lock, flags);
-        }
-
-        while (likely(!list_empty(&dev->tx_reqs)) && len) {
-
-                if (len > USB_BUFSIZE)
-                        size = USB_BUFSIZE;
-                else
-                        size = len;
-
-                req = container_of(dev->tx_reqs.next, struct usb_request,
-                                list);
-                list_del_init(&req->list);
-
-                req->complete = tx_complete;
-                req->length = size;
-
-                /* Check if we need to send a zero length packet. */
-                if (len > size)
-                        /* They will be more TX requests so no yet. */
-                        req->zero = 0;
-                else
-                        /* If the data amount is not a multple of the
-                         * maxpacket size then send a zero length packet.
-                         */
-                        req->zero = ((len % dev->in_ep->maxpacket) == 0);
-
-                /* Don't leave irqs off while doing memory copies */
-                spin_unlock_irqrestore(&dev->lock, flags);
-
-                if (copy_from_user(req->buf, buf, size)) {
-                        list_add(&req->list, &dev->tx_reqs);
-                        mutex_unlock(&dev->lock_printer_io);
-                        return bytes_copied;
-                }
-
-                bytes_copied += size;
-                len -= size;
-                buf += size;
-
-                spin_lock_irqsave(&dev->lock, flags);
-
-                /* We've disconnected or reset so free the req and buffer */
-                if (dev->reset_printer) {
-                        list_add(&req->list, &dev->tx_reqs);
-                        spin_unlock_irqrestore(&dev->lock, flags);
-                        mutex_unlock(&dev->lock_printer_io);
-                        return -EAGAIN;
-                }
-
-                if (usb_ep_queue(dev->in_ep, req, GFP_ATOMIC)) {
-                        list_add(&req->list, &dev->tx_reqs);
-                        spin_unlock_irqrestore(&dev->lock, flags);
-                        mutex_unlock(&dev->lock_printer_io);
-                        return -EAGAIN;
-                }
-
-                list_add(&req->list, &dev->tx_reqs_active);
-
-        }
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-        mutex_unlock(&dev->lock_printer_io);
-
-        DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied);
-
-        if (bytes_copied) {
-                return bytes_copied;
-        } else {
-                return -EAGAIN;
-        }
-}
-
-static int
-printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync)
-{
-        struct printer_dev      *dev = fd->private_data;
-        struct inode *inode = file_inode(fd);
-        unsigned long           flags;
-        int                     tx_list_empty;
-
-        mutex_lock(&inode->i_mutex);
-        spin_lock_irqsave(&dev->lock, flags);
-        tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        if (!tx_list_empty) {
-                /* Sleep until all data has been sent */
-                wait_event_interruptible(dev->tx_flush_wait,
-                                (likely(list_empty(&dev->tx_reqs_active))));
-        }
-        mutex_unlock(&inode->i_mutex);
-
-        return 0;
-}
-
-static unsigned int
-printer_poll(struct file *fd, poll_table *wait)
-{
-        struct printer_dev      *dev = fd->private_data;
-        unsigned long           flags;
-        int                     status = 0;
-
-        mutex_lock(&dev->lock_printer_io);
-        spin_lock_irqsave(&dev->lock, flags);
-        setup_rx_reqs(dev);
-        spin_unlock_irqrestore(&dev->lock, flags);
-        mutex_unlock(&dev->lock_printer_io);
-
-        poll_wait(fd, &dev->rx_wait, wait);
-        poll_wait(fd, &dev->tx_wait, wait);
-
-        spin_lock_irqsave(&dev->lock, flags);
-        if (likely(!list_empty(&dev->tx_reqs)))
-                status |= POLLOUT | POLLWRNORM;
-
-        if (likely(dev->current_rx_bytes) ||
-                        likely(!list_empty(&dev->rx_buffers)))
-                status |= POLLIN | POLLRDNORM;
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        return status;
-}
-
-static long
-printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
-{
-        struct printer_dev      *dev = fd->private_data;
-        unsigned long           flags;
-        int                     status = 0;
-
-        DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
-
-        /* handle ioctls */
-
-        spin_lock_irqsave(&dev->lock, flags);
-
-        switch (code) {
-        case GADGET_GET_PRINTER_STATUS:
-                status = (int)dev->printer_status;
-                break;
-        case GADGET_SET_PRINTER_STATUS:
-                dev->printer_status = (u8)arg;
-                break;
-        default:
-                /* could not handle ioctl */
-                DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
-                                code);
-                status = -ENOTTY;
-        }
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        return status;
-}
-
-/* used after endpoint configuration */
-static const struct file_operations printer_io_operations = {
-        .owner =        THIS_MODULE,
-        .open =         printer_open,
-        .read =         printer_read,
-        .write =        printer_write,
-        .fsync =        printer_fsync,
-        .poll =         printer_poll,
-        .unlocked_ioctl = printer_ioctl,
-        .release =      printer_close,
-        .llseek =       noop_llseek,
-};
-
-/*-------------------------------------------------------------------------*/
-
-static int
-set_printer_interface(struct printer_dev *dev)
-{
-        int                     result = 0;
-
-        dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
-                                &ss_ep_in_desc);
-        dev->in_ep->driver_data = dev;
-
-        dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
-                                    &hs_ep_out_desc, &ss_ep_out_desc);
-        dev->out_ep->driver_data = dev;
-
-        result = usb_ep_enable(dev->in_ep);
-        if (result != 0) {
-                DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
-                goto done;
-        }
-
-        result = usb_ep_enable(dev->out_ep);
-        if (result != 0) {
-                DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
-                goto done;
-        }
-
-done:
-        /* on error, disable any endpoints  */
-        if (result != 0) {
-                (void) usb_ep_disable(dev->in_ep);
-                (void) usb_ep_disable(dev->out_ep);
-                dev->in_ep->desc = NULL;
-                dev->out_ep->desc = NULL;
-        }
-
-        /* caller is responsible for cleanup on error */
-        return result;
-}
-
-static void printer_reset_interface(struct printer_dev *dev)
-{
-        if (dev->interface < 0)
-                return;
-
-        DBG(dev, "%s\n", __func__);
-
-        if (dev->in_ep->desc)
-                usb_ep_disable(dev->in_ep);
-
-        if (dev->out_ep->desc)
-                usb_ep_disable(dev->out_ep);
-
-        dev->in_ep->desc = NULL;
-        dev->out_ep->desc = NULL;
-        dev->interface = -1;
-}
-
-/* Change our operational Interface. */
-static int set_interface(struct printer_dev *dev, unsigned number)
-{
-        int                     result = 0;
-
-        /* Free the current interface */
-        printer_reset_interface(dev);
-
-        result = set_printer_interface(dev);
-        if (result)
-                printer_reset_interface(dev);
-        else
-                dev->interface = number;
-
-        if (!result)
-                INFO(dev, "Using interface %x\n", number);
-
-        return result;
-}
-
-static void printer_soft_reset(struct printer_dev *dev)
-{
-        struct usb_request      *req;
-
-        INFO(dev, "Received Printer Reset Request\n");
-
-        if (usb_ep_disable(dev->in_ep))
-                DBG(dev, "Failed to disable USB in_ep\n");
-        if (usb_ep_disable(dev->out_ep))
-                DBG(dev, "Failed to disable USB out_ep\n");
-
-        if (dev->current_rx_req != NULL) {
-                list_add(&dev->current_rx_req->list, &dev->rx_reqs);
-                dev->current_rx_req = NULL;
-        }
-        dev->current_rx_bytes = 0;
-        dev->current_rx_buf = NULL;
-        dev->reset_printer = 1;
-
-        while (likely(!(list_empty(&dev->rx_buffers)))) {
-                req = container_of(dev->rx_buffers.next, struct usb_request,
-                                list);
-                list_del_init(&req->list);
-                list_add(&req->list, &dev->rx_reqs);
-        }
-
-        while (likely(!(list_empty(&dev->rx_reqs_active)))) {
-                req = container_of(dev->rx_buffers.next, struct usb_request,
-                                list);
-                list_del_init(&req->list);
-                list_add(&req->list, &dev->rx_reqs);
-        }
-
-        while (likely(!(list_empty(&dev->tx_reqs_active)))) {
-                req = container_of(dev->tx_reqs_active.next,
-                                struct usb_request, list);
-                list_del_init(&req->list);
-                list_add(&req->list, &dev->tx_reqs);
-        }
-
-        if (usb_ep_enable(dev->in_ep))
-                DBG(dev, "Failed to enable USB in_ep\n");
-        if (usb_ep_enable(dev->out_ep))
-                DBG(dev, "Failed to enable USB out_ep\n");
-
-        wake_up_interruptible(&dev->rx_wait);
-        wake_up_interruptible(&dev->tx_wait);
-        wake_up_interruptible(&dev->tx_flush_wait);
-}
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * The setup() callback implements all the ep0 functionality that's not
- * handled lower down.
- */
-static int printer_func_setup(struct usb_function *f,
-                const struct usb_ctrlrequest *ctrl)
-{
-        struct printer_dev *dev = container_of(f, struct printer_dev, function);
-        struct usb_composite_dev *cdev = f->config->cdev;
-        struct usb_request      *req = cdev->req;
-        int                     value = -EOPNOTSUPP;
-        u16                     wIndex = le16_to_cpu(ctrl->wIndex);
-        u16                     wValue = le16_to_cpu(ctrl->wValue);
-        u16                     wLength = le16_to_cpu(ctrl->wLength);
-
-        DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
-                ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength);
-
-        switch (ctrl->bRequestType&USB_TYPE_MASK) {
-        case USB_TYPE_CLASS:
-                switch (ctrl->bRequest) {
-                case 0: /* Get the IEEE-1284 PNP String */
-                        /* Only one printer interface is supported. */
-                        if ((wIndex>>8) != dev->interface)
-                                break;
-
-                        value = (pnp_string[0]<<8)|pnp_string[1];
-                        memcpy(req->buf, pnp_string, value);
-                        DBG(dev, "1284 PNP String: %x %s\n", value,
-                                        &pnp_string[2]);
-                        break;
-
-                case 1: /* Get Port Status */
-                        /* Only one printer interface is supported. */
-                        if (wIndex != dev->interface)
-                                break;
-
-                        *(u8 *)req->buf = dev->printer_status;
-                        value = min(wLength, (u16) 1);
-                        break;
-
-                case 2: /* Soft Reset */
-                        /* Only one printer interface is supported. */
-                        if (wIndex != dev->interface)
-                                break;
-
-                        printer_soft_reset(dev);
-
-                        value = 0;
-                        break;
-
-                default:
-                        goto unknown;
-                }
-                break;
-
-        default:
-unknown:
-                VDBG(dev,
-                        "unknown ctrl req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
-                break;
-        }
-        /* host either stalls (value < 0) or reports success */
-        return value;
-}
-
-static int __init printer_func_bind(struct usb_configuration *c,
-                struct usb_function *f)
-{
-        struct printer_dev *dev = container_of(f, struct printer_dev, function);
-        struct usb_composite_dev *cdev = c->cdev;
-        struct usb_ep *in_ep;
-        struct usb_ep *out_ep = NULL;
-        int id;
-        int ret;
-
-        id = usb_interface_id(c, f);
-        if (id < 0)
-                return id;
-        intf_desc.bInterfaceNumber = id;
-
-        /* all we really need is bulk IN/OUT */
-        in_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_in_desc);
-        if (!in_ep) {
-autoconf_fail:
-                dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
-                        cdev->gadget->name);
-                return -ENODEV;
-        }
-        in_ep->driver_data = in_ep;     /* claim */
-
-        out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc);
-        if (!out_ep)
-                goto autoconf_fail;
-        out_ep->driver_data = out_ep;   /* claim */
-
-        /* assumes that all endpoints are dual-speed */
-        hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
-        hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
-        ss_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
-        ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
-
-        ret = usb_assign_descriptors(f, fs_printer_function,
-                        hs_printer_function, ss_printer_function);
-        if (ret)
-                return ret;
-
-        dev->in_ep = in_ep;
-        dev->out_ep = out_ep;
-        return 0;
-}
-
-static void printer_func_unbind(struct usb_configuration *c,
-                struct usb_function *f)
-{
-        usb_free_all_descriptors(f);
-}
-
-static int printer_func_set_alt(struct usb_function *f,
-                unsigned intf, unsigned alt)
-{
-        struct printer_dev *dev = container_of(f, struct printer_dev, function);
-        int ret = -ENOTSUPP;
-
-        if (!alt)
-                ret = set_interface(dev, intf);
-
-        return ret;
-}
-
-static void printer_func_disable(struct usb_function *f)
-{
-        struct printer_dev *dev = container_of(f, struct printer_dev, function);
-        unsigned long           flags;
-
-        DBG(dev, "%s\n", __func__);
-
-        spin_lock_irqsave(&dev->lock, flags);
-        printer_reset_interface(dev);
-        spin_unlock_irqrestore(&dev->lock, flags);
-}
-
-static void printer_cfg_unbind(struct usb_configuration *c)
-{
-        struct printer_dev      *dev;
-        struct usb_request      *req;
-
-        dev = &usb_printer_gadget;
-
-        DBG(dev, "%s\n", __func__);
-
-        /* Remove sysfs files */
-        device_destroy(usb_gadget_class, g_printer_devno);
-
-        /* Remove Character Device */
-        cdev_del(&dev->printer_cdev);
-
-        /* we must already have been disconnected ... no i/o may be active */
-        WARN_ON(!list_empty(&dev->tx_reqs_active));
-        WARN_ON(!list_empty(&dev->rx_reqs_active));
-
-        /* Free all memory for this driver. */
-        while (!list_empty(&dev->tx_reqs)) {
-                req = container_of(dev->tx_reqs.next, struct usb_request,
-                                list);
-                list_del(&req->list);
-                printer_req_free(dev->in_ep, req);
-        }
-
-        if (dev->current_rx_req != NULL)
-                printer_req_free(dev->out_ep, dev->current_rx_req);
-
-        while (!list_empty(&dev->rx_reqs)) {
-                req = container_of(dev->rx_reqs.next,
-                                struct usb_request, list);
-                list_del(&req->list);
-                printer_req_free(dev->out_ep, req);
-        }
-
-        while (!list_empty(&dev->rx_buffers)) {
-                req = container_of(dev->rx_buffers.next,
-                                struct usb_request, list);
-                list_del(&req->list);
-                printer_req_free(dev->out_ep, req);
-        }
-}
-
 static struct usb_configuration printer_cfg_driver = {
         .label                  = "printer",
-        .unbind                 = printer_cfg_unbind,
         .bConfigurationValue    = 1,
         .bmAttributes           = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 };
 
-static int __init printer_bind_config(struct usb_configuration *c)
+static int __init printer_do_config(struct usb_configuration *c)
 {
         struct usb_gadget       *gadget = c->cdev->gadget;
-        struct printer_dev      *dev;
-        int                     status = -ENOMEM;
-        size_t                  len;
-        u32                     i;
-        struct usb_request      *req;
+        int                     status = 0;
 
         usb_ep_autoconfig_reset(gadget);
 
-        dev = &usb_printer_gadget;
-
-        dev->function.name = shortname;
-        dev->function.bind = printer_func_bind;
-        dev->function.setup = printer_func_setup;
-        dev->function.unbind = printer_func_unbind;
-        dev->function.set_alt = printer_func_set_alt;
-        dev->function.disable = printer_func_disable;
-
-        status = usb_add_function(c, &dev->function);
-        if (status)
-                return status;
-
-        /* Setup the sysfs files for the printer gadget. */
-        dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
-                                  NULL, "g_printer");
-        if (IS_ERR(dev->pdev)) {
-                ERROR(dev, "Failed to create device: g_printer\n");
-                status = PTR_ERR(dev->pdev);
-                goto fail;
-        }
-
-        /*
-         * Register a character device as an interface to a user mode
-         * program that handles the printer specific functionality.
-         */
-        cdev_init(&dev->printer_cdev, &printer_io_operations);
-        dev->printer_cdev.owner = THIS_MODULE;
-        status = cdev_add(&dev->printer_cdev, g_printer_devno, 1);
-        if (status) {
-                ERROR(dev, "Failed to open char device\n");
-                goto fail;
-        }
-
-        if (iPNPstring)
-                strlcpy(&pnp_string[2], iPNPstring, (sizeof pnp_string)-2);
-
-        len = strlen(pnp_string);
-        pnp_string[0] = (len >> 8) & 0xFF;
-        pnp_string[1] = len & 0xFF;
-
         usb_gadget_set_selfpowered(gadget);
 
         if (gadget_is_otg(gadget)) {
@@ -1222,86 +141,64 @@ static int __init printer_bind_config(struct usb_configuration *c)
                 printer_cfg_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        spin_lock_init(&dev->lock);
-        mutex_init(&dev->lock_printer_io);
-        INIT_LIST_HEAD(&dev->tx_reqs);
-        INIT_LIST_HEAD(&dev->tx_reqs_active);
-        INIT_LIST_HEAD(&dev->rx_reqs);
-        INIT_LIST_HEAD(&dev->rx_reqs_active);
-        INIT_LIST_HEAD(&dev->rx_buffers);
-        init_waitqueue_head(&dev->rx_wait);
-        init_waitqueue_head(&dev->tx_wait);
-        init_waitqueue_head(&dev->tx_flush_wait);
-
-        dev->interface = -1;
-        dev->printer_cdev_open = 0;
-        dev->printer_status = PRINTER_NOT_ERROR;
-        dev->current_rx_req = NULL;
-        dev->current_rx_bytes = 0;
-        dev->current_rx_buf = NULL;
-
-        for (i = 0; i < QLEN; i++) {
-                req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
-                if (!req) {
-                        while (!list_empty(&dev->tx_reqs)) {
-                                req = container_of(dev->tx_reqs.next,
-                                                struct usb_request, list);
-                                list_del(&req->list);
-                                printer_req_free(dev->in_ep, req);
-                        }
-                        return -ENOMEM;
-                }
-                list_add(&req->list, &dev->tx_reqs);
-        }
-
-        for (i = 0; i < QLEN; i++) {
-                req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
-                if (!req) {
-                        while (!list_empty(&dev->rx_reqs)) {
-                                req = container_of(dev->rx_reqs.next,
-                                                struct usb_request, list);
-                                list_del(&req->list);
-                                printer_req_free(dev->out_ep, req);
-                        }
-                        return -ENOMEM;
-                }
-                list_add(&req->list, &dev->rx_reqs);
-        }
-
-        /* finish hookup to lower layer ... */
-        dev->gadget = gadget;
+        f_printer = usb_get_function(fi_printer);
+        if (IS_ERR(f_printer))
+                return PTR_ERR(f_printer);
 
-        INFO(dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
-        return 0;
+        status = usb_add_function(c, f_printer);
+        if (status < 0)
+                usb_put_function(f_printer);
 
-fail:
-        printer_cfg_unbind(c);
         return status;
 }
 
-static int printer_unbind(struct usb_composite_dev *cdev)
-{
-        return 0;
-}
-
 static int __init printer_bind(struct usb_composite_dev *cdev)
 {
-        int ret;
+        struct f_printer_opts *opts;
+        int ret, len;
+
+        fi_printer = usb_get_function_instance("printer");
+        if (IS_ERR(fi_printer))
+                return PTR_ERR(fi_printer);
+
+        if (iPNPstring)
+                strlcpy(&pnp_string[2], iPNPstring, PNP_STRING_LEN - 2);
+
+        len = strlen(pnp_string);
+        pnp_string[0] = (len >> 8) & 0xFF;
+        pnp_string[1] = len & 0xFF;
+
+        opts = container_of(fi_printer, struct f_printer_opts, func_inst);
+        opts->minor = 0;
+        memcpy(opts->pnp_string, pnp_string, PNP_STRING_LEN);
+        opts->q_len = QLEN;
 
         ret = usb_string_ids_tab(cdev, strings);
-        if (ret < 0)
+        if (ret < 0) {
+                usb_put_function_instance(fi_printer);
                 return ret;
+        }
         device_desc.iManufacturer = strings[USB_GADGET_MANUFACTURER_IDX].id;
         device_desc.iProduct = strings[USB_GADGET_PRODUCT_IDX].id;
         device_desc.iSerialNumber = strings[USB_GADGET_SERIAL_IDX].id;
 
-        ret = usb_add_config(cdev, &printer_cfg_driver, printer_bind_config);
-        if (ret)
+        ret = usb_add_config(cdev, &printer_cfg_driver, printer_do_config);
+        if (ret) {
+                usb_put_function_instance(fi_printer);
                 return ret;
+        }
         usb_composite_overwrite_options(cdev, &coverwrite);
         return ret;
 }
 
+static int __exit printer_unbind(struct usb_composite_dev *cdev)
+{
+        usb_put_function(f_printer);
+        usb_put_function_instance(fi_printer);
+
+        return 0;
+}
+
 static __refdata struct usb_composite_driver printer_driver = {
         .name           = shortname,
         .dev            = &device_desc,
@@ -1311,47 +208,7 @@ static __refdata struct usb_composite_driver printer_driver = {
         .unbind         = printer_unbind,
 };
 
-static int __init
-init(void)
-{
-        int status;
-
-        usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget");
-        if (IS_ERR(usb_gadget_class)) {
-                status = PTR_ERR(usb_gadget_class);
-                pr_err("unable to create usb_gadget class %d\n", status);
-                return status;
-        }
-
-        status = alloc_chrdev_region(&g_printer_devno, 0, 1,
-                        "USB printer gadget");
-        if (status) {
-                pr_err("alloc_chrdev_region %d\n", status);
-                class_destroy(usb_gadget_class);
-                return status;
-        }
-
-        status = usb_composite_probe(&printer_driver);
-        if (status) {
-                class_destroy(usb_gadget_class);
-                unregister_chrdev_region(g_printer_devno, 1);
-                pr_err("usb_gadget_probe_driver %x\n", status);
-        }
-
-        return status;
-}
-module_init(init);
-
-static void __exit
-cleanup(void)
-{
-        mutex_lock(&usb_printer_gadget.lock_printer_io);
-        usb_composite_unregister(&printer_driver);
-        unregister_chrdev_region(g_printer_devno, 1);
-        class_destroy(usb_gadget_class);
-        mutex_unlock(&usb_printer_gadget.lock_printer_io);
-}
-module_exit(cleanup);
+module_usb_composite_driver(printer_driver);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR("Craig Nadler");
diff --git a/drivers/usb/gadget/legacy/tcm_usb_gadget.c b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
index 3a494168661e..6e0a019aad54 100644
--- a/drivers/usb/gadget/legacy/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
@@ -1740,10 +1740,9 @@ static int tcm_usbg_make_nexus(struct usbg_tpg *tpg, char *name)
                 goto err_session;
         }
         /*
-         * Now register the TCM vHost virtual I_T Nexus as active with the
-         * call to __transport_register_session()
+         * Now register the TCM vHost virtual I_T Nexus as active.
          */
-        __transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
+        transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
                         tv_nexus->tvn_se_sess, tv_nexus);
         tpg->tpg_nexus = tv_nexus;
         mutex_unlock(&tpg->tpg_mutex);
diff --git a/drivers/usb/gadget/legacy/zero.c b/drivers/usb/gadget/legacy/zero.c
index ff97ac93ac03..5ee95152493c 100644
--- a/drivers/usb/gadget/legacy/zero.c
+++ b/drivers/usb/gadget/legacy/zero.c
@@ -68,8 +68,6 @@ static struct usb_zero_options gzero_options = {
         .isoc_maxpacket = GZERO_ISOC_MAXPACKET,
         .bulk_buflen = GZERO_BULK_BUFLEN,
         .qlen = GZERO_QLEN,
-        .int_interval = GZERO_INT_INTERVAL,
-        .int_maxpacket = GZERO_INT_MAXPACKET,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -268,21 +266,6 @@ module_param_named(isoc_maxburst, gzero_options.isoc_maxburst, uint,
                 S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)");
 
-module_param_named(int_interval, gzero_options.int_interval, uint,
-                S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(int_interval, "1 - 16");
-
-module_param_named(int_maxpacket, gzero_options.int_maxpacket, uint,
-                S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(int_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
-
-module_param_named(int_mult, gzero_options.int_mult, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(int_mult, "0 - 2 (hs/ss only)");
-
-module_param_named(int_maxburst, gzero_options.int_maxburst, uint,
-                S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(int_maxburst, "0 - 15 (ss only)");
-
 static struct usb_function *func_lb;
 static struct usb_function_instance *func_inst_lb;
 
@@ -318,10 +301,6 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
         ss_opts->isoc_maxpacket = gzero_options.isoc_maxpacket;
         ss_opts->isoc_mult = gzero_options.isoc_mult;
         ss_opts->isoc_maxburst = gzero_options.isoc_maxburst;
-        ss_opts->int_interval = gzero_options.int_interval;
-        ss_opts->int_maxpacket = gzero_options.int_maxpacket;
-        ss_opts->int_mult = gzero_options.int_mult;
-        ss_opts->int_maxburst = gzero_options.int_maxburst;
         ss_opts->bulk_buflen = gzero_options.bulk_buflen;
 
         func_ss = usb_get_function(func_inst_ss);
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index d79cb35dbf8a..4c01953a0869 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -152,7 +152,7 @@ static int regs_dbg_open(struct inode *inode, struct file *file)
 
         spin_lock_irq(&udc->lock);
         for (i = 0; i < inode->i_size / 4; i++)
-                data[i] = __raw_readl(udc->regs + i * 4);
+                data[i] = usba_io_readl(udc->regs + i * 4);
         spin_unlock_irq(&udc->lock);
 
         file->private_data = data;
@@ -1249,7 +1249,7 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                 if (crq->wLength != cpu_to_le16(sizeof(status)))
                         goto stall;
                 ep->state = DATA_STAGE_IN;
-                __raw_writew(status, ep->fifo);
+                usba_io_writew(status, ep->fifo);
                 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
                 break;
         }
@@ -1739,7 +1739,72 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t usba_vbus_irq(int irq, void *devid)
+static int start_clock(struct usba_udc *udc)
+{
+        int ret;
+
+        if (udc->clocked)
+                return 0;
+
+        ret = clk_prepare_enable(udc->pclk);
+        if (ret)
+                return ret;
+        ret = clk_prepare_enable(udc->hclk);
+        if (ret) {
+                clk_disable_unprepare(udc->pclk);
+                return ret;
+        }
+
+        udc->clocked = true;
+        return 0;
+}
+
+static void stop_clock(struct usba_udc *udc)
+{
+        if (!udc->clocked)
+                return;
+
+        clk_disable_unprepare(udc->hclk);
+        clk_disable_unprepare(udc->pclk);
+
+        udc->clocked = false;
+}
+
+static int usba_start(struct usba_udc *udc)
+{
+        unsigned long flags;
+        int ret;
+
+        ret = start_clock(udc);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        toggle_bias(udc, 1);
+        usba_writel(udc, CTRL, USBA_ENABLE_MASK);
+        usba_int_enb_set(udc, USBA_END_OF_RESET);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static void usba_stop(struct usba_udc *udc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        reset_all_endpoints(udc);
+
+        /* This will also disable the DP pullup */
+        toggle_bias(udc, 0);
+        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        stop_clock(udc);
+}
+
+static irqreturn_t usba_vbus_irq_thread(int irq, void *devid)
 {
         struct usba_udc *udc = devid;
         int vbus;
@@ -1747,35 +1812,22 @@ static irqreturn_t usba_vbus_irq(int irq, void *devid)
         /* debounce */
         udelay(10);
 
-        spin_lock(&udc->lock);
-
-        /* May happen if Vbus pin toggles during probe() */
-        if (!udc->driver)
-                goto out;
+        mutex_lock(&udc->vbus_mutex);
 
         vbus = vbus_is_present(udc);
         if (vbus != udc->vbus_prev) {
                 if (vbus) {
-                        toggle_bias(udc, 1);
-                        usba_writel(udc, CTRL, USBA_ENABLE_MASK);
-                        usba_int_enb_set(udc, USBA_END_OF_RESET);
+                        usba_start(udc);
                 } else {
-                        udc->gadget.speed = USB_SPEED_UNKNOWN;
-                        reset_all_endpoints(udc);
-                        toggle_bias(udc, 0);
-                        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
-                        if (udc->driver->disconnect) {
-                                spin_unlock(&udc->lock);
+                        usba_stop(udc);
+
+                        if (udc->driver->disconnect)
                                 udc->driver->disconnect(&udc->gadget);
-                                spin_lock(&udc->lock);
-                        }
                 }
                 udc->vbus_prev = vbus;
         }
 
-out:
-        spin_unlock(&udc->lock);
-
+        mutex_unlock(&udc->vbus_mutex);
         return IRQ_HANDLED;
 }
 
@@ -1787,55 +1839,47 @@ static int atmel_usba_start(struct usb_gadget *gadget,
         unsigned long flags;
 
         spin_lock_irqsave(&udc->lock, flags);
-
         udc->devstatus = 1 << USB_DEVICE_SELF_POWERED;
         udc->driver = driver;
         spin_unlock_irqrestore(&udc->lock, flags);
 
-        ret = clk_prepare_enable(udc->pclk);
-        if (ret)
-                return ret;
-        ret = clk_prepare_enable(udc->hclk);
-        if (ret) {
-                clk_disable_unprepare(udc->pclk);
-                return ret;
-        }
+        mutex_lock(&udc->vbus_mutex);
 
-        udc->vbus_prev = 0;
         if (gpio_is_valid(udc->vbus_pin))
                 enable_irq(gpio_to_irq(udc->vbus_pin));
 
         /* If Vbus is present, enable the controller and wait for reset */
-        spin_lock_irqsave(&udc->lock, flags);
-        if (vbus_is_present(udc) && udc->vbus_prev == 0) {
-                toggle_bias(udc, 1);
-                usba_writel(udc, CTRL, USBA_ENABLE_MASK);
-                usba_int_enb_set(udc, USBA_END_OF_RESET);
+        udc->vbus_prev = vbus_is_present(udc);
+        if (udc->vbus_prev) {
+                ret = usba_start(udc);
+                if (ret)
+                        goto err;
         }
-        spin_unlock_irqrestore(&udc->lock, flags);
 
+        mutex_unlock(&udc->vbus_mutex);
         return 0;
+
+err:
+        if (gpio_is_valid(udc->vbus_pin))
+                disable_irq(gpio_to_irq(udc->vbus_pin));
+
+        mutex_unlock(&udc->vbus_mutex);
+
+        spin_lock_irqsave(&udc->lock, flags);
+        udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
+        udc->driver = NULL;
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return ret;
 }
 
 static int atmel_usba_stop(struct usb_gadget *gadget)
 {
         struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget);
-        unsigned long flags;
 
         if (gpio_is_valid(udc->vbus_pin))
                 disable_irq(gpio_to_irq(udc->vbus_pin));
 
-        spin_lock_irqsave(&udc->lock, flags);
-        udc->gadget.speed = USB_SPEED_UNKNOWN;
-        reset_all_endpoints(udc);
-        spin_unlock_irqrestore(&udc->lock, flags);
-
-        /* This will also disable the DP pullup */
-        toggle_bias(udc, 0);
-        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
-
-        clk_disable_unprepare(udc->hclk);
-        clk_disable_unprepare(udc->pclk);
+        usba_stop(udc);
 
         udc->driver = NULL;
 
@@ -2057,6 +2101,7 @@ static int usba_udc_probe(struct platform_device *pdev)
                 return PTR_ERR(hclk);
 
         spin_lock_init(&udc->lock);
+        mutex_init(&udc->vbus_mutex);
         udc->pdev = pdev;
         udc->pclk = pclk;
         udc->hclk = hclk;
@@ -2111,17 +2156,17 @@ static int usba_udc_probe(struct platform_device *pdev)
 
         if (gpio_is_valid(udc->vbus_pin)) {
                 if (!devm_gpio_request(&pdev->dev, udc->vbus_pin, "atmel_usba_udc")) {
-                        ret = devm_request_irq(&pdev->dev,
-                                        gpio_to_irq(udc->vbus_pin),
-                                        usba_vbus_irq, 0,
+                        irq_set_status_flags(gpio_to_irq(udc->vbus_pin),
+                                        IRQ_NOAUTOEN);
+                        ret = devm_request_threaded_irq(&pdev->dev,
+                                        gpio_to_irq(udc->vbus_pin), NULL,
+                                        usba_vbus_irq_thread, IRQF_ONESHOT,
                                         "atmel_usba_udc", udc);
                         if (ret) {
                                 udc->vbus_pin = -ENODEV;
                                 dev_warn(&udc->pdev->dev,
                                          "failed to request vbus irq; "
                                          "assuming always on\n");
-                        } else {
-                                disable_irq(gpio_to_irq(udc->vbus_pin));
                         }
                 } else {
                         /* gpio_request fail so use -EINVAL for gpio_is_valid */
@@ -2132,6 +2177,7 @@ static int usba_udc_probe(struct platform_device *pdev)
         ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
         if (ret)
                 return ret;
+        device_init_wakeup(&pdev->dev, 1);
 
         usba_init_debugfs(udc);
         for (i = 1; i < udc->num_ep; i++)
@@ -2147,6 +2193,7 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
 
         udc = platform_get_drvdata(pdev);
 
+        device_init_wakeup(&pdev->dev, 0);
         usb_del_gadget_udc(&udc->gadget);
 
         for (i = 1; i < udc->num_ep; i++)
@@ -2156,10 +2203,65 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int usba_udc_suspend(struct device *dev)
+{
+        struct usba_udc *udc = dev_get_drvdata(dev);
+
+        /* Not started */
+        if (!udc->driver)
+                return 0;
+
+        mutex_lock(&udc->vbus_mutex);
+
+        if (!device_may_wakeup(dev)) {
+                usba_stop(udc);
+                goto out;
+        }
+
+        /*
+         * Device may wake up. We stay clocked if we failed
+         * to request vbus irq, assuming always on.
+         */
+        if (gpio_is_valid(udc->vbus_pin)) {
+                usba_stop(udc);
+                enable_irq_wake(gpio_to_irq(udc->vbus_pin));
+        }
+
+out:
+        mutex_unlock(&udc->vbus_mutex);
+        return 0;
+}
+
+static int usba_udc_resume(struct device *dev)
+{
+        struct usba_udc *udc = dev_get_drvdata(dev);
+
+        /* Not started */
+        if (!udc->driver)
+                return 0;
+
+        if (device_may_wakeup(dev) && gpio_is_valid(udc->vbus_pin))
+                disable_irq_wake(gpio_to_irq(udc->vbus_pin));
+
+        /* If Vbus is present, enable the controller and wait for reset */
+        mutex_lock(&udc->vbus_mutex);
+        udc->vbus_prev = vbus_is_present(udc);
+        if (udc->vbus_prev)
+                usba_start(udc);
+        mutex_unlock(&udc->vbus_mutex);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(usba_udc_pm_ops, usba_udc_suspend, usba_udc_resume);
+
 static struct platform_driver udc_driver = {
         .remove         = __exit_p(usba_udc_remove),
         .driver         = {
                 .name           = "atmel_usba_udc",
+                .pm             = &usba_udc_pm_ops,
                 .of_match_table = of_match_ptr(atmel_udc_dt_ids),
         },
 };
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.h b/drivers/usb/gadget/udc/atmel_usba_udc.h
index 497cd18836f3..ea448a344767 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.h
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.h
@@ -191,18 +191,28 @@
          | USBA_BF(name, value))
 
 /* Register access macros */
+#ifdef CONFIG_AVR32
+#define usba_io_readl   __raw_readl
+#define usba_io_writel  __raw_writel
+#define usba_io_writew  __raw_writew
+#else
+#define usba_io_readl   readl_relaxed
+#define usba_io_writel  writel_relaxed
+#define usba_io_writew  writew_relaxed
+#endif
+
 #define usba_readl(udc, reg)                                    \
-        __raw_readl((udc)->regs + USBA_##reg)
+        usba_io_readl((udc)->regs + USBA_##reg)
 #define usba_writel(udc, reg, value)                            \
-        __raw_writel((value), (udc)->regs + USBA_##reg)
+        usba_io_writel((value), (udc)->regs + USBA_##reg)
 #define usba_ep_readl(ep, reg)                                  \
-        __raw_readl((ep)->ep_regs + USBA_EPT_##reg)
+        usba_io_readl((ep)->ep_regs + USBA_EPT_##reg)
 #define usba_ep_writel(ep, reg, value)                          \
-        __raw_writel((value), (ep)->ep_regs + USBA_EPT_##reg)
+        usba_io_writel((value), (ep)->ep_regs + USBA_EPT_##reg)
 #define usba_dma_readl(ep, reg)                                 \
-        __raw_readl((ep)->dma_regs + USBA_DMA_##reg)
+        usba_io_readl((ep)->dma_regs + USBA_DMA_##reg)
 #define usba_dma_writel(ep, reg, value)                         \
-        __raw_writel((value), (ep)->dma_regs + USBA_DMA_##reg)
+        usba_io_writel((value), (ep)->dma_regs + USBA_DMA_##reg)
 
 /* Calculate base address for a given endpoint or DMA controller */
 #define USBA_EPT_BASE(x)        (0x100 + (x) * 0x20)
@@ -313,6 +323,9 @@ struct usba_udc {
         /* Protect hw registers from concurrent modifications */
         spinlock_t lock;
 
+        /* Mutex to prevent concurrent start or stop */
+        struct mutex vbus_mutex;
+
         void __iomem *regs;
         void __iomem *fifo;
 
@@ -328,6 +341,7 @@ struct usba_udc {
         struct clk *hclk;
         struct usba_ep *usba_ep;
         bool bias_pulse_needed;
+        bool clocked;
 
         u16 devstatus;
 
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c
index 8dda48445f6f..181112c88f43 100644
--- a/drivers/usb/gadget/udc/dummy_hcd.c
+++ b/drivers/usb/gadget/udc/dummy_hcd.c
@@ -1923,7 +1923,7 @@ static inline void
 ss_hub_descriptor(struct usb_hub_descriptor *desc)
 {
         memset(desc, 0, sizeof *desc);
-        desc->bDescriptorType = 0x2a;
+        desc->bDescriptorType = USB_DT_SS_HUB;
         desc->bDescLength = 12;
         desc->wHubCharacteristics = cpu_to_le16(
                         HUB_CHAR_INDV_PORT_LPSM |
@@ -1936,7 +1936,7 @@ ss_hub_descriptor(struct usb_hub_descriptor *desc)
 static inline void hub_descriptor(struct usb_hub_descriptor *desc)
 {
         memset(desc, 0, sizeof *desc);
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bDescLength = 9;
         desc->wHubCharacteristics = cpu_to_le16(
                         HUB_CHAR_INDV_PORT_LPSM |
@@ -2631,7 +2631,7 @@ static int __init init(void)
                 return -EINVAL;
 
         if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) {
-                pr_err("Number of emulated UDC must be in range of 1…%d\n",
+                pr_err("Number of emulated UDC must be in range of 1...%d\n",
                                 MAX_NUM_UDC);
                 return -EINVAL;
         }
diff --git a/drivers/usb/gadget/udc/goku_udc.c b/drivers/usb/gadget/udc/goku_udc.c
index 5b9176e7202a..9e8d842e8c08 100644
--- a/drivers/usb/gadget/udc/goku_udc.c
+++ b/drivers/usb/gadget/udc/goku_udc.c
@@ -1024,35 +1024,79 @@ static const char proc_node_name [] = "driver/udc";
 static void dump_intmask(struct seq_file *m, const char *label, u32 mask)
 {
         /* int_status is the same format ... */
-        seq_printf(m,
-                "%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n",
-                label, mask,
-                (mask & INT_PWRDETECT) ? " power" : "",
-                (mask & INT_SYSERROR) ? " sys" : "",
-                (mask & INT_MSTRDEND) ? " in-dma" : "",
-                (mask & INT_MSTWRTMOUT) ? " wrtmo" : "",
-
-                (mask & INT_MSTWREND) ? " out-dma" : "",
-                (mask & INT_MSTWRSET) ? " wrset" : "",
-                (mask & INT_ERR) ? " err" : "",
-                (mask & INT_SOF) ? " sof" : "",
-
-                (mask & INT_EP3NAK) ? " ep3nak" : "",
-                (mask & INT_EP2NAK) ? " ep2nak" : "",
-                (mask & INT_EP1NAK) ? " ep1nak" : "",
-                (mask & INT_EP3DATASET) ? " ep3" : "",
-
-                (mask & INT_EP2DATASET) ? " ep2" : "",
-                (mask & INT_EP1DATASET) ? " ep1" : "",
-                (mask & INT_STATUSNAK) ? " ep0snak" : "",
-                (mask & INT_STATUS) ? " ep0status" : "",
-
-                (mask & INT_SETUP) ? " setup" : "",
-                (mask & INT_ENDPOINT0) ? " ep0" : "",
-                (mask & INT_USBRESET) ? " reset" : "",
-                (mask & INT_SUSPEND) ? " suspend" : "");
+        seq_printf(m, "%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n",
+                   label, mask,
+                   (mask & INT_PWRDETECT) ? " power" : "",
+                   (mask & INT_SYSERROR) ? " sys" : "",
+                   (mask & INT_MSTRDEND) ? " in-dma" : "",
+                   (mask & INT_MSTWRTMOUT) ? " wrtmo" : "",
+
+                   (mask & INT_MSTWREND) ? " out-dma" : "",
+                   (mask & INT_MSTWRSET) ? " wrset" : "",
+                   (mask & INT_ERR) ? " err" : "",
+                   (mask & INT_SOF) ? " sof" : "",
+
+                   (mask & INT_EP3NAK) ? " ep3nak" : "",
+                   (mask & INT_EP2NAK) ? " ep2nak" : "",
+                   (mask & INT_EP1NAK) ? " ep1nak" : "",
+                   (mask & INT_EP3DATASET) ? " ep3" : "",
+
+                   (mask & INT_EP2DATASET) ? " ep2" : "",
+                   (mask & INT_EP1DATASET) ? " ep1" : "",
+                   (mask & INT_STATUSNAK) ? " ep0snak" : "",
+                   (mask & INT_STATUS) ? " ep0status" : "",
+
+                   (mask & INT_SETUP) ? " setup" : "",
+                   (mask & INT_ENDPOINT0) ? " ep0" : "",
+                   (mask & INT_USBRESET) ? " reset" : "",
+                   (mask & INT_SUSPEND) ? " suspend" : "");
+}
+
+static const char *udc_ep_state(enum ep0state state)
+{
+        switch (state) {
+        case EP0_DISCONNECT:
+                return "ep0_disconnect";
+        case EP0_IDLE:
+                return "ep0_idle";
+        case EP0_IN:
+                return "ep0_in";
+        case EP0_OUT:
+                return "ep0_out";
+        case EP0_STATUS:
+                return "ep0_status";
+        case EP0_STALL:
+                return "ep0_stall";
+        case EP0_SUSPEND:
+                return "ep0_suspend";
+        }
+
+        return "ep0_?";
 }
 
+static const char *udc_ep_status(u32 status)
+{
+        switch (status & EPxSTATUS_EP_MASK) {
+        case EPxSTATUS_EP_READY:
+                return "ready";
+        case EPxSTATUS_EP_DATAIN:
+                return "packet";
+        case EPxSTATUS_EP_FULL:
+                return "full";
+        case EPxSTATUS_EP_TX_ERR:       /* host will retry */
+                return "tx_err";
+        case EPxSTATUS_EP_RX_ERR:
+                return "rx_err";
+        case EPxSTATUS_EP_BUSY:         /* ep0 only */
+                return "busy";
+        case EPxSTATUS_EP_STALL:
+                return "stall";
+        case EPxSTATUS_EP_INVALID:      /* these "can't happen" */
+                return "invalid";
+        }
+
+        return "?";
+}
 
 static int udc_proc_read(struct seq_file *m, void *v)
 {
@@ -1068,29 +1112,18 @@ static int udc_proc_read(struct seq_file *m, void *v)
         tmp = readl(&regs->power_detect);
         is_usb_connected = tmp & PW_DETECT;
         seq_printf(m,
-                "%s - %s\n"
-                "%s version: %s %s\n"
-                "Gadget driver: %s\n"
-                "Host %s, %s\n"
-                "\n",
-                pci_name(dev->pdev), driver_desc,
-                driver_name, DRIVER_VERSION, dmastr(),
-                dev->driver ? dev->driver->driver.name : "(none)",
-                is_usb_connected
-                        ? ((tmp & PW_PULLUP) ? "full speed" : "powered")
-                        : "disconnected",
-                ({const char *state;
-                switch(dev->ep0state){
-                case EP0_DISCONNECT:    state = "ep0_disconnect"; break;
-                case EP0_IDLE:          state = "ep0_idle"; break;
-                case EP0_IN:            state = "ep0_in"; break;
-                case EP0_OUT:           state = "ep0_out"; break;
-                case EP0_STATUS:        state = "ep0_status"; break;
-                case EP0_STALL:         state = "ep0_stall"; break;
-                case EP0_SUSPEND:       state = "ep0_suspend"; break;
-                default:                state = "ep0_?"; break;
-                } state; })
-                );
+                   "%s - %s\n"
+                   "%s version: %s %s\n"
+                   "Gadget driver: %s\n"
+                   "Host %s, %s\n"
+                   "\n",
+                   pci_name(dev->pdev), driver_desc,
+                   driver_name, DRIVER_VERSION, dmastr(),
+                   dev->driver ? dev->driver->driver.name : "(none)",
+                   is_usb_connected
+                           ? ((tmp & PW_PULLUP) ? "full speed" : "powered")
+                           : "disconnected",
+                   udc_ep_state(dev->ep0state));
 
         dump_intmask(m, "int_status", readl(&regs->int_status));
         dump_intmask(m, "int_enable", readl(&regs->int_enable));
@@ -1099,31 +1132,30 @@ static int udc_proc_read(struct seq_file *m, void *v)
                 goto done;
 
         /* registers for (active) device and ep0 */
-        if (seq_printf(m, "\nirqs %lu\ndataset %02x "
-                        "single.bcs %02x.%02x state %x addr %u\n",
-                        dev->irqs, readl(&regs->DataSet),
-                        readl(&regs->EPxSingle), readl(&regs->EPxBCS),
-                        readl(&regs->UsbState),
-                        readl(&regs->address)) < 0)
+        seq_printf(m, "\nirqs %lu\ndataset %02x single.bcs %02x.%02x state %x addr %u\n",
+                   dev->irqs, readl(&regs->DataSet),
+                   readl(&regs->EPxSingle), readl(&regs->EPxBCS),
+                   readl(&regs->UsbState),
+                   readl(&regs->address));
+        if (seq_has_overflowed(m))
                 goto done;
 
         tmp = readl(&regs->dma_master);
-        if (seq_printf(m,
-                "dma %03X =" EIGHTBITS "%s %s\n", tmp,
-                (tmp & MST_EOPB_DIS) ? " eopb-" : "",
-                (tmp & MST_EOPB_ENA) ? " eopb+" : "",
-                (tmp & MST_TIMEOUT_DIS) ? " tmo-" : "",
-                (tmp & MST_TIMEOUT_ENA) ? " tmo+" : "",
-
-                (tmp & MST_RD_EOPB) ? " eopb" : "",
-                (tmp & MST_RD_RESET) ? " in_reset" : "",
-                (tmp & MST_WR_RESET) ? " out_reset" : "",
-                (tmp & MST_RD_ENA) ? " IN" : "",
-
-                (tmp & MST_WR_ENA) ? " OUT" : "",
-                (tmp & MST_CONNECTION)
-                        ? "ep1in/ep2out"
-                        : "ep1out/ep2in") < 0)
+        seq_printf(m, "dma %03X =" EIGHTBITS "%s %s\n",
+                   tmp,
+                   (tmp & MST_EOPB_DIS) ? " eopb-" : "",
+                   (tmp & MST_EOPB_ENA) ? " eopb+" : "",
+                   (tmp & MST_TIMEOUT_DIS) ? " tmo-" : "",
+                   (tmp & MST_TIMEOUT_ENA) ? " tmo+" : "",
+
+                   (tmp & MST_RD_EOPB) ? " eopb" : "",
+                   (tmp & MST_RD_RESET) ? " in_reset" : "",
+                   (tmp & MST_WR_RESET) ? " out_reset" : "",
+                   (tmp & MST_RD_ENA) ? " IN" : "",
+
+                   (tmp & MST_WR_ENA) ? " OUT" : "",
+                   (tmp & MST_CONNECTION) ? "ep1in/ep2out" : "ep1out/ep2in");
+        if (seq_has_overflowed(m))
                 goto done;
 
         /* dump endpoint queues */
@@ -1135,44 +1167,23 @@ static int udc_proc_read(struct seq_file *m, void *v)
                         continue;
 
                 tmp = readl(ep->reg_status);
-                if (seq_printf(m,
-                        "%s %s max %u %s, irqs %lu, "
-                        "status %02x (%s) " FOURBITS "\n",
-                        ep->ep.name,
-                        ep->is_in ? "in" : "out",
-                        ep->ep.maxpacket,
-                        ep->dma ? "dma" : "pio",
-                        ep->irqs,
-                        tmp, ({ char *s;
-                        switch (tmp & EPxSTATUS_EP_MASK) {
-                        case EPxSTATUS_EP_READY:
-                                s = "ready"; break;
-                        case EPxSTATUS_EP_DATAIN:
-                                s = "packet"; break;
-                        case EPxSTATUS_EP_FULL:
-                                s = "full"; break;
-                        case EPxSTATUS_EP_TX_ERR:       // host will retry
-                                s = "tx_err"; break;
-                        case EPxSTATUS_EP_RX_ERR:
-                                s = "rx_err"; break;
-                        case EPxSTATUS_EP_BUSY:         /* ep0 only */
-                                s = "busy"; break;
-                        case EPxSTATUS_EP_STALL:
-                                s = "stall"; break;
-                        case EPxSTATUS_EP_INVALID:      // these "can't happen"
-                                s = "invalid"; break;
-                        default:
-                                s = "?"; break;
-                        } s; }),
-                        (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0",
-                        (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "",
-                        (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "",
-                        (tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : ""
-                        ) < 0)
+                seq_printf(m, "%s %s max %u %s, irqs %lu, status %02x (%s) " FOURBITS "\n",
+                           ep->ep.name,
+                           ep->is_in ? "in" : "out",
+                           ep->ep.maxpacket,
+                           ep->dma ? "dma" : "pio",
+                           ep->irqs,
+                           tmp, udc_ep_status(tmp),
+                           (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0",
+                           (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "",
+                           (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "",
+                           (tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : "");
+                if (seq_has_overflowed(m))
                         goto done;
 
                 if (list_empty(&ep->queue)) {
-                        if (seq_puts(m, "\t(nothing queued)\n") < 0)
+                        seq_puts(m, "\t(nothing queued)\n");
+                        if (seq_has_overflowed(m))
                                 goto done;
                         continue;
                 }
@@ -1187,10 +1198,10 @@ static int udc_proc_read(struct seq_file *m, void *v)
                         } else
                                 tmp = req->req.actual;
 
-                        if (seq_printf(m,
-                                "\treq %p len %u/%u buf %p\n",
-                                &req->req, tmp, req->req.length,
-                                req->req.buf) < 0)
+                        seq_printf(m, "\treq %p len %u/%u buf %p\n",
+                                   &req->req, tmp, req->req.length,
+                                   req->req.buf);
+                        if (seq_has_overflowed(m))
                                 goto done;
                 }
         }
diff --git a/drivers/usb/gadget/udc/lpc32xx_udc.c b/drivers/usb/gadget/udc/lpc32xx_udc.c
index 27fd41333f71..3b6a7852822d 100644
--- a/drivers/usb/gadget/udc/lpc32xx_udc.c
+++ b/drivers/usb/gadget/udc/lpc32xx_udc.c
@@ -1803,23 +1803,14 @@ static int lpc32xx_ep_queue(struct usb_ep *_ep,
         req = container_of(_req, struct lpc32xx_request, req);
         ep = container_of(_ep, struct lpc32xx_ep, ep);
 
-        if (!_req || !_req->complete || !_req->buf ||
+        if (!_ep || !_req || !_req->complete || !_req->buf ||
             !list_empty(&req->queue))
                 return -EINVAL;
 
         udc = ep->udc;
 
-        if (!_ep) {
-                dev_dbg(udc->dev, "invalid ep\n");
-                return -EINVAL;
-        }
-
-
-        if ((!udc) || (!udc->driver) ||
-            (udc->gadget.speed == USB_SPEED_UNKNOWN)) {
-                dev_dbg(udc->dev, "invalid device\n");
-                return -EINVAL;
-        }
+        if (udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -EPIPE;
 
         if (ep->lep) {
                 struct lpc32xx_usbd_dd_gad *dd;
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index d2c0bf65e345..9871b90195ad 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -80,6 +80,13 @@ static const char *const ep_name[] = {
         "ep-e", "ep-f", "ep-g", "ep-h",
 };
 
+/* Endpoint names for usb3380 advance mode */
+static const char *const ep_name_adv[] = {
+        ep0name,
+        "ep1in", "ep2out", "ep3in", "ep4out",
+        "ep1out", "ep2in", "ep3out", "ep4in",
+};
+
 /* mode 0 == ep-{a,b,c,d} 1K fifo each
  * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
  * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
@@ -138,31 +145,44 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
         u32                     max, tmp;
         unsigned long           flags;
         static const u32 ep_key[9] = { 1, 0, 1, 0, 1, 1, 0, 1, 0 };
+        int ret = 0;
 
         ep = container_of(_ep, struct net2280_ep, ep);
         if (!_ep || !desc || ep->desc || _ep->name == ep0name ||
-                        desc->bDescriptorType != USB_DT_ENDPOINT)
+                        desc->bDescriptorType != USB_DT_ENDPOINT) {
+                pr_err("%s: failed at line=%d\n", __func__, __LINE__);
                 return -EINVAL;
+        }
         dev = ep->dev;
-        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-                return -ESHUTDOWN;
+        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
+                ret = -ESHUTDOWN;
+                goto print_err;
+        }
 
         /* erratum 0119 workaround ties up an endpoint number */
-        if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE)
-                return -EDOM;
+        if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE) {
+                ret = -EDOM;
+                goto print_err;
+        }
 
         if (dev->quirks & PLX_SUPERSPEED) {
-                if ((desc->bEndpointAddress & 0x0f) >= 0x0c)
-                        return -EDOM;
+                if ((desc->bEndpointAddress & 0x0f) >= 0x0c) {
+                        ret = -EDOM;
+                        goto print_err;
+                }
                 ep->is_in = !!usb_endpoint_dir_in(desc);
-                if (dev->enhanced_mode && ep->is_in && ep_key[ep->num])
-                        return -EINVAL;
+                if (dev->enhanced_mode && ep->is_in && ep_key[ep->num]) {
+                        ret = -EINVAL;
+                        goto print_err;
+                }
         }
 
         /* sanity check ep-e/ep-f since their fifos are small */
         max = usb_endpoint_maxp(desc) & 0x1fff;
-        if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY))
-                return -ERANGE;
+        if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY)) {
+                ret = -ERANGE;
+                goto print_err;
+        }
 
         spin_lock_irqsave(&dev->lock, flags);
         _ep->maxpacket = max & 0x7ff;
@@ -192,7 +212,8 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                     (dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
                     (dev->gadget.speed == USB_SPEED_FULL && max > 64)) {
                         spin_unlock_irqrestore(&dev->lock, flags);
-                        return -ERANGE;
+                        ret = -ERANGE;
+                        goto print_err;
                 }
         }
         ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
@@ -271,7 +292,11 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 
         /* pci writes may still be posted */
         spin_unlock_irqrestore(&dev->lock, flags);
-        return 0;
+        return ret;
+
+print_err:
+        dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret);
+        return ret;
 }
 
 static int handshake(u32 __iomem *ptr, u32 mask, u32 done, int usec)
@@ -426,9 +451,10 @@ static int net2280_disable(struct usb_ep *_ep)
         unsigned long           flags;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || !ep->desc || _ep->name == ep0name)
+        if (!_ep || !ep->desc || _ep->name == ep0name) {
+                pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
                 return -EINVAL;
-
+        }
         spin_lock_irqsave(&ep->dev->lock, flags);
         nuke(ep);
 
@@ -458,8 +484,10 @@ static struct usb_request
         struct net2280_ep       *ep;
         struct net2280_request  *req;
 
-        if (!_ep)
+        if (!_ep) {
+                pr_err("%s: Invalid ep\n", __func__);
                 return NULL;
+        }
         ep = container_of(_ep, struct net2280_ep, ep);
 
         req = kzalloc(sizeof(*req), gfp_flags);
@@ -491,8 +519,11 @@ static void net2280_free_request(struct usb_ep *_ep, struct usb_request *_req)
         struct net2280_request  *req;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || !_req)
+        if (!_ep || !_req) {
+                dev_err(&ep->dev->pdev->dev, "%s: Inavlid ep=%p or req=%p\n",
+                                                        __func__, _ep, _req);
                 return;
+        }
 
         req = container_of(_req, struct net2280_request, req);
         WARN_ON(!list_empty(&req->queue));
@@ -896,35 +927,44 @@ net2280_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         struct net2280_ep       *ep;
         struct net2280          *dev;
         unsigned long           flags;
+        int ret = 0;
 
         /* we always require a cpu-view buffer, so that we can
          * always use pio (as fallback or whatever).
          */
-        req = container_of(_req, struct net2280_request, req);
-        if (!_req || !_req->complete || !_req->buf ||
-                                !list_empty(&req->queue))
-                return -EINVAL;
-        if (_req->length > (~0 & DMA_BYTE_COUNT_MASK))
-                return -EDOM;
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || (!ep->desc && ep->num != 0))
+        if (!_ep || (!ep->desc && ep->num != 0)) {
+                pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
                 return -EINVAL;
+        }
+        req = container_of(_req, struct net2280_request, req);
+        if (!_req || !_req->complete || !_req->buf ||
+                                !list_empty(&req->queue)) {
+                ret = -EINVAL;
+                goto print_err;
+        }
+        if (_req->length > (~0 & DMA_BYTE_COUNT_MASK)) {
+                ret = -EDOM;
+                goto print_err;
+        }
         dev = ep->dev;
-        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-                return -ESHUTDOWN;
+        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
+                ret = -ESHUTDOWN;
+                goto print_err;
+        }
 
         /* FIXME implement PIO fallback for ZLPs with DMA */
-        if (ep->dma && _req->length == 0)
-                return -EOPNOTSUPP;
+        if (ep->dma && _req->length == 0) {
+                ret = -EOPNOTSUPP;
+                goto print_err;
+        }
 
         /* set up dma mapping in case the caller didn't */
         if (ep->dma) {
-                int ret;
-
                 ret = usb_gadget_map_request(&dev->gadget, _req,
                                 ep->is_in);
                 if (ret)
-                        return ret;
+                        goto print_err;
         }
 
         ep_vdbg(dev, "%s queue req %p, len %d buf %p\n",
@@ -1013,7 +1053,11 @@ done:
         spin_unlock_irqrestore(&dev->lock, flags);
 
         /* pci writes may still be posted */
-        return 0;
+        return ret;
+
+print_err:
+        dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret);
+        return ret;
 }
 
 static inline void
@@ -1134,8 +1178,11 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req)
         int                     stopped;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || (!ep->desc && ep->num != 0) || !_req)
+        if (!_ep || (!ep->desc && ep->num != 0) || !_req) {
+                pr_err("%s: Invalid ep=%p or ep->desc or req=%p\n",
+                                                __func__, _ep, _req);
                 return -EINVAL;
+        }
 
         spin_lock_irqsave(&ep->dev->lock, flags);
         stopped = ep->stopped;
@@ -1157,6 +1204,8 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req)
         }
         if (&req->req != _req) {
                 spin_unlock_irqrestore(&ep->dev->lock, flags);
+                dev_err(&ep->dev->pdev->dev, "%s: Request mismatch\n",
+                                                                __func__);
                 return -EINVAL;
         }
 
@@ -1214,20 +1263,28 @@ net2280_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
         int                     retval = 0;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || (!ep->desc && ep->num != 0))
+        if (!_ep || (!ep->desc && ep->num != 0)) {
+                pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
                 return -EINVAL;
-        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
-                return -ESHUTDOWN;
+        }
+        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
+                retval = -ESHUTDOWN;
+                goto print_err;
+        }
         if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
-                                                == USB_ENDPOINT_XFER_ISOC)
-                return -EINVAL;
+                                                == USB_ENDPOINT_XFER_ISOC) {
+                retval = -EINVAL;
+                goto print_err;
+        }
 
         spin_lock_irqsave(&ep->dev->lock, flags);
-        if (!list_empty(&ep->queue))
+        if (!list_empty(&ep->queue)) {
                 retval = -EAGAIN;
-        else if (ep->is_in && value && net2280_fifo_status(_ep) != 0)
+                goto print_unlock;
+        } else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) {
                 retval = -EAGAIN;
-        else {
+                goto print_unlock;
+        } else {
                 ep_vdbg(ep->dev, "%s %s %s\n", _ep->name,
                                 value ? "set" : "clear",
                                 wedged ? "wedge" : "halt");
@@ -1251,6 +1308,12 @@ net2280_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
         spin_unlock_irqrestore(&ep->dev->lock, flags);
 
         return retval;
+
+print_unlock:
+        spin_unlock_irqrestore(&ep->dev->lock, flags);
+print_err:
+        dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, retval);
+        return retval;
 }
 
 static int net2280_set_halt(struct usb_ep *_ep, int value)
@@ -1260,8 +1323,10 @@ static int net2280_set_halt(struct usb_ep *_ep, int value)
 
 static int net2280_set_wedge(struct usb_ep *_ep)
 {
-        if (!_ep || _ep->name == ep0name)
+        if (!_ep || _ep->name == ep0name) {
+                pr_err("%s: Invalid ep=%p or ep0\n", __func__, _ep);
                 return -EINVAL;
+        }
         return net2280_set_halt_and_wedge(_ep, 1, 1);
 }
 
@@ -1271,14 +1336,22 @@ static int net2280_fifo_status(struct usb_ep *_ep)
         u32                     avail;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || (!ep->desc && ep->num != 0))
+        if (!_ep || (!ep->desc && ep->num != 0)) {
+                pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
                 return -ENODEV;
-        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
+        }
+        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
+                dev_err(&ep->dev->pdev->dev,
+                        "%s: Invalid driver=%p or speed=%d\n",
+                        __func__, ep->dev->driver, ep->dev->gadget.speed);
                 return -ESHUTDOWN;
+        }
 
         avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1);
-        if (avail > ep->fifo_size)
+        if (avail > ep->fifo_size) {
+                dev_err(&ep->dev->pdev->dev, "%s: Fifo overflow\n", __func__);
                 return -EOVERFLOW;
+        }
         if (ep->is_in)
                 avail = ep->fifo_size - avail;
         return avail;
@@ -1289,10 +1362,16 @@ static void net2280_fifo_flush(struct usb_ep *_ep)
         struct net2280_ep       *ep;
 
         ep = container_of(_ep, struct net2280_ep, ep);
-        if (!_ep || (!ep->desc && ep->num != 0))
+        if (!_ep || (!ep->desc && ep->num != 0)) {
+                pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
                 return;
-        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
+        }
+        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
+                dev_err(&ep->dev->pdev->dev,
+                        "%s: Invalid driver=%p or speed=%d\n",
+                        __func__, ep->dev->driver, ep->dev->gadget.speed);
                 return;
+        }
 
         writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
         (void) readl(&ep->regs->ep_rsp);
@@ -1977,7 +2056,7 @@ static void usb_reinit_338x(struct net2280 *dev)
         for (i = 0; i < dev->n_ep; i++) {
                 struct net2280_ep *ep = &dev->ep[i];
 
-                ep->ep.name = ep_name[i];
+                ep->ep.name = dev->enhanced_mode ? ep_name_adv[i] : ep_name[i];
                 ep->dev = dev;
                 ep->num = i;
 
@@ -1989,11 +2068,9 @@ static void usb_reinit_338x(struct net2280 *dev)
                         ep->regs = (struct net2280_ep_regs __iomem *)
                                 (((void __iomem *)&dev->epregs[ne[i]]) +
                                 ep_reg_addr[i]);
-                        ep->fiforegs = &dev->fiforegs[i];
                 } else {
                         ep->cfg = &dev->epregs[i];
                         ep->regs = &dev->epregs[i];
-                        ep->fiforegs = &dev->fiforegs[i];
                 }
 
                 ep->fifo_size = (i != 0) ? 2048 : 512;
@@ -2186,7 +2263,6 @@ static int net2280_start(struct usb_gadget *_gadget,
                 dev->ep[i].irqs = 0;
 
         /* hook up the driver ... */
-        dev->softconnect = 1;
         driver->driver.bus = NULL;
         dev->driver = driver;
 
@@ -3052,6 +3128,8 @@ next_endpoints:
                 BIT(PCI_RETRY_ABORT_INTERRUPT))
 
 static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
+__releases(dev->lock)
+__acquires(dev->lock)
 {
         struct net2280_ep       *ep;
         u32                     tmp, num, mask, scratch;
@@ -3373,8 +3451,6 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 u32 usbstat;
                 dev->usb_ext = (struct usb338x_usb_ext_regs __iomem *)
                                                         (base + 0x00b4);
-                dev->fiforegs = (struct usb338x_fifo_regs __iomem *)
-                                                        (base + 0x0500);
                 dev->llregs = (struct usb338x_ll_regs __iomem *)
                                                         (base + 0x0700);
                 dev->ll_lfps_regs = (struct usb338x_ll_lfps_regs __iomem *)
diff --git a/drivers/usb/gadget/udc/net2280.h b/drivers/usb/gadget/udc/net2280.h
index ac8d5a20a378..4dff60d34f73 100644
--- a/drivers/usb/gadget/udc/net2280.h
+++ b/drivers/usb/gadget/udc/net2280.h
@@ -96,7 +96,6 @@ struct net2280_ep {
         struct net2280_ep_regs                  __iomem *regs;
         struct net2280_dma_regs                 __iomem *dma;
         struct net2280_dma                      *dummy;
-        struct usb338x_fifo_regs __iomem *fiforegs;
         dma_addr_t                              td_dma; /* of dummy */
         struct net2280                          *dev;
         unsigned long                           irqs;
@@ -181,7 +180,6 @@ struct net2280 {
         struct net2280_dma_regs         __iomem *dma;
         struct net2280_dep_regs         __iomem *dep;
         struct net2280_ep_regs          __iomem *epregs;
-        struct usb338x_fifo_regs        __iomem *fiforegs;
         struct usb338x_ll_regs          __iomem *llregs;
         struct usb338x_ll_lfps_regs     __iomem *ll_lfps_regs;
         struct usb338x_ll_tsn_regs      __iomem *ll_tsn_regs;
diff --git a/drivers/usb/gadget/udc/pxa27x_udc.c b/drivers/usb/gadget/udc/pxa27x_udc.c
index 6a855fc9bd84..b51226abade6 100644
--- a/drivers/usb/gadget/udc/pxa27x_udc.c
+++ b/drivers/usb/gadget/udc/pxa27x_udc.c
@@ -93,50 +93,46 @@ static void handle_ep(struct pxa_ep *ep);
 static int state_dbg_show(struct seq_file *s, void *p)
 {
         struct pxa_udc *udc = s->private;
-        int pos = 0, ret;
         u32 tmp;
 
-        ret = -ENODEV;
         if (!udc->driver)
-                goto out;
+                return -ENODEV;
 
         /* basic device status */
-        pos += seq_printf(s, DRIVER_DESC "\n"
-                         "%s version: %s\nGadget driver: %s\n",
-                         driver_name, DRIVER_VERSION,
-                         udc->driver ? udc->driver->driver.name : "(none)");
+        seq_printf(s, DRIVER_DESC "\n"
+                   "%s version: %s\n"
+                   "Gadget driver: %s\n",
+                   driver_name, DRIVER_VERSION,
+                   udc->driver ? udc->driver->driver.name : "(none)");
 
         tmp = udc_readl(udc, UDCCR);
-        pos += seq_printf(s,
-                         "udccr=0x%0x(%s%s%s%s%s%s%s%s%s%s), "
-                         "con=%d,inter=%d,altinter=%d\n", tmp,
-                         (tmp & UDCCR_OEN) ? " oen":"",
-                         (tmp & UDCCR_AALTHNP) ? " aalthnp":"",
-                         (tmp & UDCCR_AHNP) ? " rem" : "",
-                         (tmp & UDCCR_BHNP) ? " rstir" : "",
-                         (tmp & UDCCR_DWRE) ? " dwre" : "",
-                         (tmp & UDCCR_SMAC) ? " smac" : "",
-                         (tmp & UDCCR_EMCE) ? " emce" : "",
-                         (tmp & UDCCR_UDR) ? " udr" : "",
-                         (tmp & UDCCR_UDA) ? " uda" : "",
-                         (tmp & UDCCR_UDE) ? " ude" : "",
-                         (tmp & UDCCR_ACN) >> UDCCR_ACN_S,
-                         (tmp & UDCCR_AIN) >> UDCCR_AIN_S,
-                         (tmp & UDCCR_AAISN) >> UDCCR_AAISN_S);
+        seq_printf(s,
+                   "udccr=0x%0x(%s%s%s%s%s%s%s%s%s%s), con=%d,inter=%d,altinter=%d\n",
+                   tmp,
+                   (tmp & UDCCR_OEN) ? " oen":"",
+                   (tmp & UDCCR_AALTHNP) ? " aalthnp":"",
+                   (tmp & UDCCR_AHNP) ? " rem" : "",
+                   (tmp & UDCCR_BHNP) ? " rstir" : "",
+                   (tmp & UDCCR_DWRE) ? " dwre" : "",
+                   (tmp & UDCCR_SMAC) ? " smac" : "",
+                   (tmp & UDCCR_EMCE) ? " emce" : "",
+                   (tmp & UDCCR_UDR) ? " udr" : "",
+                   (tmp & UDCCR_UDA) ? " uda" : "",
+                   (tmp & UDCCR_UDE) ? " ude" : "",
+                   (tmp & UDCCR_ACN) >> UDCCR_ACN_S,
+                   (tmp & UDCCR_AIN) >> UDCCR_AIN_S,
+                   (tmp & UDCCR_AAISN) >> UDCCR_AAISN_S);
         /* registers for device and ep0 */
-        pos += seq_printf(s, "udcicr0=0x%08x udcicr1=0x%08x\n",
-                        udc_readl(udc, UDCICR0), udc_readl(udc, UDCICR1));
-        pos += seq_printf(s, "udcisr0=0x%08x udcisr1=0x%08x\n",
-                        udc_readl(udc, UDCISR0), udc_readl(udc, UDCISR1));
-        pos += seq_printf(s, "udcfnr=%d\n", udc_readl(udc, UDCFNR));
-        pos += seq_printf(s, "irqs: reset=%lu, suspend=%lu, resume=%lu, "
-                        "reconfig=%lu\n",
-                        udc->stats.irqs_reset, udc->stats.irqs_suspend,
-                        udc->stats.irqs_resume, udc->stats.irqs_reconfig);
-
-        ret = 0;
-out:
-        return ret;
+        seq_printf(s, "udcicr0=0x%08x udcicr1=0x%08x\n",
+                   udc_readl(udc, UDCICR0), udc_readl(udc, UDCICR1));
+        seq_printf(s, "udcisr0=0x%08x udcisr1=0x%08x\n",
+                   udc_readl(udc, UDCISR0), udc_readl(udc, UDCISR1));
+        seq_printf(s, "udcfnr=%d\n", udc_readl(udc, UDCFNR));
+        seq_printf(s, "irqs: reset=%lu, suspend=%lu, resume=%lu, reconfig=%lu\n",
+                   udc->stats.irqs_reset, udc->stats.irqs_suspend,
+                   udc->stats.irqs_resume, udc->stats.irqs_reconfig);
+
+        return 0;
 }
 
 static int queues_dbg_show(struct seq_file *s, void *p)
@@ -144,75 +140,67 @@ static int queues_dbg_show(struct seq_file *s, void *p)
         struct pxa_udc *udc = s->private;
         struct pxa_ep *ep;
         struct pxa27x_request *req;
-        int pos = 0, i, maxpkt, ret;
+        int i, maxpkt;
 
-        ret = -ENODEV;
         if (!udc->driver)
-                goto out;
+                return -ENODEV;
 
         /* dump endpoint queues */
         for (i = 0; i < NR_PXA_ENDPOINTS; i++) {
                 ep = &udc->pxa_ep[i];
                 maxpkt = ep->fifo_size;
-                pos += seq_printf(s,  "%-12s max_pkt=%d %s\n",
-                                EPNAME(ep), maxpkt, "pio");
+                seq_printf(s,  "%-12s max_pkt=%d %s\n",
+                           EPNAME(ep), maxpkt, "pio");
 
                 if (list_empty(&ep->queue)) {
-                        pos += seq_printf(s, "\t(nothing queued)\n");
+                        seq_puts(s, "\t(nothing queued)\n");
                         continue;
                 }
 
                 list_for_each_entry(req, &ep->queue, queue) {
-                        pos += seq_printf(s,  "\treq %p len %d/%d buf %p\n",
-                                        &req->req, req->req.actual,
-                                        req->req.length, req->req.buf);
+                        seq_printf(s,  "\treq %p len %d/%d buf %p\n",
+                                   &req->req, req->req.actual,
+                                   req->req.length, req->req.buf);
                 }
         }
 
-        ret = 0;
-out:
-        return ret;
+        return 0;
 }
 
 static int eps_dbg_show(struct seq_file *s, void *p)
 {
         struct pxa_udc *udc = s->private;
         struct pxa_ep *ep;
-        int pos = 0, i, ret;
+        int i;
         u32 tmp;
 
-        ret = -ENODEV;
         if (!udc->driver)
-                goto out;
+                return -ENODEV;
 
         ep = &udc->pxa_ep[0];
         tmp = udc_ep_readl(ep, UDCCSR);
-        pos += seq_printf(s, "udccsr0=0x%03x(%s%s%s%s%s%s%s)\n", tmp,
-                         (tmp & UDCCSR0_SA) ? " sa" : "",
-                         (tmp & UDCCSR0_RNE) ? " rne" : "",
-                         (tmp & UDCCSR0_FST) ? " fst" : "",
-                         (tmp & UDCCSR0_SST) ? " sst" : "",
-                         (tmp & UDCCSR0_DME) ? " dme" : "",
-                         (tmp & UDCCSR0_IPR) ? " ipr" : "",
-                         (tmp & UDCCSR0_OPC) ? " opc" : "");
+        seq_printf(s, "udccsr0=0x%03x(%s%s%s%s%s%s%s)\n",
+                   tmp,
+                   (tmp & UDCCSR0_SA) ? " sa" : "",
+                   (tmp & UDCCSR0_RNE) ? " rne" : "",
+                   (tmp & UDCCSR0_FST) ? " fst" : "",
+                   (tmp & UDCCSR0_SST) ? " sst" : "",
+                   (tmp & UDCCSR0_DME) ? " dme" : "",
+                   (tmp & UDCCSR0_IPR) ? " ipr" : "",
+                   (tmp & UDCCSR0_OPC) ? " opc" : "");
         for (i = 0; i < NR_PXA_ENDPOINTS; i++) {
                 ep = &udc->pxa_ep[i];
                 tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR);
-                pos += seq_printf(s, "%-12s: "
-                                "IN %lu(%lu reqs), OUT %lu(%lu reqs), "
-                                "irqs=%lu, udccr=0x%08x, udccsr=0x%03x, "
-                                "udcbcr=%d\n",
-                                EPNAME(ep),
-                                ep->stats.in_bytes, ep->stats.in_ops,
-                                ep->stats.out_bytes, ep->stats.out_ops,
-                                ep->stats.irqs,
-                                tmp, udc_ep_readl(ep, UDCCSR),
-                                udc_ep_readl(ep, UDCBCR));
+                seq_printf(s, "%-12s: IN %lu(%lu reqs), OUT %lu(%lu reqs), irqs=%lu, udccr=0x%08x, udccsr=0x%03x, udcbcr=%d\n",
+                           EPNAME(ep),
+                           ep->stats.in_bytes, ep->stats.in_ops,
+                           ep->stats.out_bytes, ep->stats.out_ops,
+                           ep->stats.irqs,
+                           tmp, udc_ep_readl(ep, UDCCSR),
+                           udc_ep_readl(ep, UDCBCR));
         }
 
-        ret = 0;
-out:
-        return ret;
+        return 0;
 }
 
 static int eps_dbg_open(struct inode *inode, struct file *file)
@@ -2399,7 +2387,7 @@ static struct pxa_udc memory = {
 };
 
 #if defined(CONFIG_OF)
-static struct of_device_id udc_pxa_dt_ids[] = {
+static const struct of_device_id udc_pxa_dt_ids[] = {
         { .compatible = "marvell,pxa270-udc" },
         {}
 };
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c
index 5a81cb086b99..d69c35558f68 100644
--- a/drivers/usb/gadget/udc/udc-core.c
+++ b/drivers/usb/gadget/udc/udc-core.c
@@ -35,6 +35,8 @@
  * @dev - the child device to the actual controller
  * @gadget - the gadget. For use by the class code
  * @list - for use by the udc class driver
+ * @vbus - for udcs who care about vbus status, this value is real vbus status;
+ * for udcs who do not care about vbus status, this value is always true
  *
  * This represents the internal data structure which is used by the UDC-class
  * to hold information about udc driver and gadget together.
@@ -44,6 +46,7 @@ struct usb_udc {
         struct usb_gadget               *gadget;
         struct device                   dev;
         struct list_head                list;
+        bool                            vbus;
 };
 
 static struct class *udc_class;
@@ -128,21 +131,11 @@ EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
 
 static void usb_gadget_state_work(struct work_struct *work)
 {
-        struct usb_gadget       *gadget = work_to_gadget(work);
-        struct usb_udc          *udc = NULL;
-
-        mutex_lock(&udc_lock);
-        list_for_each_entry(udc, &udc_list, list)
-                if (udc->gadget == gadget)
-                        goto found;
-        mutex_unlock(&udc_lock);
-
-        return;
-
-found:
-        mutex_unlock(&udc_lock);
+        struct usb_gadget *gadget = work_to_gadget(work);
+        struct usb_udc *udc = gadget->udc;
 
-        sysfs_notify(&udc->dev.kobj, NULL, "state");
+        if (udc)
+                sysfs_notify(&udc->dev.kobj, NULL, "state");
 }
 
 void usb_gadget_set_state(struct usb_gadget *gadget,
@@ -155,6 +148,34 @@ EXPORT_SYMBOL_GPL(usb_gadget_set_state);
 
 /* ------------------------------------------------------------------------- */
 
+static void usb_udc_connect_control(struct usb_udc *udc)
+{
+        if (udc->vbus)
+                usb_gadget_connect(udc->gadget);
+        else
+                usb_gadget_disconnect(udc->gadget);
+}
+
+/**
+ * usb_udc_vbus_handler - updates the udc core vbus status, and try to
+ * connect or disconnect gadget
+ * @gadget: The gadget which vbus change occurs
+ * @status: The vbus status
+ *
+ * The udc driver calls it when it wants to connect or disconnect gadget
+ * according to vbus status.
+ */
+void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
+{
+        struct usb_udc *udc = gadget->udc;
+
+        if (udc) {
+                udc->vbus = status;
+                usb_udc_connect_control(udc);
+        }
+}
+EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
+
 /**
  * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
  * @gadget: The gadget which bus reset occurs
@@ -278,6 +299,7 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
                 goto err3;
 
         udc->gadget = gadget;
+        gadget->udc = udc;
 
         mutex_lock(&udc_lock);
         list_add_tail(&udc->list, &udc_list);
@@ -287,6 +309,7 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
                 goto err4;
 
         usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
+        udc->vbus = true;
 
         mutex_unlock(&udc_lock);
 
@@ -348,21 +371,14 @@ static void usb_gadget_remove_driver(struct usb_udc *udc)
  */
 void usb_del_gadget_udc(struct usb_gadget *gadget)
 {
-        struct usb_udc          *udc = NULL;
+        struct usb_udc *udc = gadget->udc;
 
-        mutex_lock(&udc_lock);
-        list_for_each_entry(udc, &udc_list, list)
-                if (udc->gadget == gadget)
-                        goto found;
-
-        dev_err(gadget->dev.parent, "gadget not registered.\n");
-        mutex_unlock(&udc_lock);
-
-        return;
+        if (!udc)
+                return;
 
-found:
         dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
 
+        mutex_lock(&udc_lock);
         list_del(&udc->list);
         mutex_unlock(&udc_lock);
 
@@ -397,7 +413,7 @@ static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *dri
                 driver->unbind(udc->gadget);
                 goto err1;
         }
-        usb_gadget_connect(udc->gadget);
+        usb_udc_connect_control(udc);
 
         kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
         return 0;
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 5ad60e46dc2b..197a6a3e613b 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -198,7 +198,7 @@ config USB_EHCI_HCD_AT91
 
 config USB_EHCI_MSM
         tristate "Support for Qualcomm QSD/MSM on-chip EHCI USB controller"
-        depends on ARCH_MSM || ARCH_QCOM
+        depends on ARCH_QCOM
         select USB_EHCI_ROOT_HUB_TT
         ---help---
           Enables support for the USB Host controller present on the
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 663f7908b15c..be0964a801e8 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -34,7 +34,6 @@ static const char hcd_name[] = "ehci-atmel";
 
 struct atmel_ehci_priv {
         struct clk *iclk;
-        struct clk *fclk;
         struct clk *uclk;
         bool clocked;
 };
@@ -51,12 +50,9 @@ static void atmel_start_clock(struct atmel_ehci_priv *atmel_ehci)
 {
         if (atmel_ehci->clocked)
                 return;
-        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                clk_set_rate(atmel_ehci->uclk, 48000000);
-                clk_prepare_enable(atmel_ehci->uclk);
-        }
+
+        clk_prepare_enable(atmel_ehci->uclk);
         clk_prepare_enable(atmel_ehci->iclk);
-        clk_prepare_enable(atmel_ehci->fclk);
         atmel_ehci->clocked = true;
 }
 
@@ -64,10 +60,9 @@ static void atmel_stop_clock(struct atmel_ehci_priv *atmel_ehci)
 {
         if (!atmel_ehci->clocked)
                 return;
-        clk_disable_unprepare(atmel_ehci->fclk);
+
         clk_disable_unprepare(atmel_ehci->iclk);
-        if (IS_ENABLED(CONFIG_COMMON_CLK))
-                clk_disable_unprepare(atmel_ehci->uclk);
+        clk_disable_unprepare(atmel_ehci->uclk);
         atmel_ehci->clocked = false;
 }
 
@@ -146,20 +141,13 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
                 retval = -ENOENT;
                 goto fail_request_resource;
         }
-        atmel_ehci->fclk = devm_clk_get(&pdev->dev, "uhpck");
-        if (IS_ERR(atmel_ehci->fclk)) {
-                dev_err(&pdev->dev, "Error getting function clock\n");
-                retval = -ENOENT;
+
+        atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk");
+        if (IS_ERR(atmel_ehci->uclk)) {
+                dev_err(&pdev->dev, "failed to get uclk\n");
+                retval = PTR_ERR(atmel_ehci->uclk);
                 goto fail_request_resource;
         }
-        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk");
-                if (IS_ERR(atmel_ehci->uclk)) {
-                        dev_err(&pdev->dev, "failed to get uclk\n");
-                        retval = PTR_ERR(atmel_ehci->uclk);
-                        goto fail_request_resource;
-                }
-        }
 
         ehci = hcd_to_ehci(hcd);
         /* registers start at offset 0x0 */
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 85e56d1abd23..f4d88dfb26a7 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -792,12 +792,12 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                                         ehci->reset_done[i] == 0))
                                 continue;
 
-                        /* start 20 msec resume signaling from this port,
-                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
-                         * stop that signaling.  Use 5 ms extra for safety,
-                         * like usb_port_resume() does.
+                        /* start USB_RESUME_TIMEOUT msec resume signaling from
+                         * this port, and make hub_wq collect
+                         * PORT_STAT_C_SUSPEND to stop that signaling.
                          */
-                        ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
+                        ehci->reset_done[i] = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(i, &ehci->resuming_ports);
                         ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
                         usb_hcd_start_port_resume(&hcd->self, i);
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 87cf86f38b36..69208447d213 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -471,10 +471,13 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
 
-        /* msleep for 20ms only if code is trying to resume port */
+        /*
+         * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
+         * port
+         */
         if (resume_needed) {
                 spin_unlock_irq(&ehci->lock);
-                msleep(20);
+                msleep(USB_RESUME_TIMEOUT);
                 spin_lock_irq(&ehci->lock);
                 if (ehci->shutdown)
                         goto shutdown;
@@ -688,7 +691,7 @@ ehci_hub_descriptor (
         int             ports = HCS_N_PORTS (ehci->hcs_params);
         u16             temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = 10;      /* ehci 1.0, 2.3.9 says 20ms max */
         desc->bHubContrCurrent = 0;
 
@@ -942,7 +945,7 @@ int ehci_hub_control(
                         temp &= ~PORT_WAKE_BITS;
                         ehci_writel(ehci, temp | PORT_RESUME, status_reg);
                         ehci->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(wIndex, &ehci->resuming_ports);
                         usb_hcd_start_port_resume(&hcd->self, wIndex);
                         break;
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index f6eafecab15c..bfcbb9aa8816 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -29,7 +29,13 @@
 #define wrl(off, val)   writel_relaxed((val), hcd->regs + (off))
 
 #define USB_CMD                 0x140
+#define   USB_CMD_RUN           BIT(0)
+#define   USB_CMD_RESET         BIT(1)
 #define USB_MODE                0x1a8
+#define   USB_MODE_MASK         GENMASK(1, 0)
+#define   USB_MODE_DEVICE       0x2
+#define   USB_MODE_HOST         0x3
+#define   USB_MODE_SDIS         BIT(4)
 #define USB_CAUSE               0x310
 #define USB_MASK                0x314
 #define USB_WINDOW_CTRL(i)      (0x320 + ((i) << 4))
@@ -69,8 +75,8 @@ static void orion_usb_phy_v1_setup(struct usb_hcd *hcd)
         /*
          * Reset controller
          */
-        wrl(USB_CMD, rdl(USB_CMD) | 0x2);
-        while (rdl(USB_CMD) & 0x2);
+        wrl(USB_CMD, rdl(USB_CMD) | USB_CMD_RESET);
+        while (rdl(USB_CMD) & USB_CMD_RESET);
 
         /*
          * GL# USB-10: Set IPG for non start of frame packets
@@ -112,16 +118,16 @@ static void orion_usb_phy_v1_setup(struct usb_hcd *hcd)
         /*
          * Stop and reset controller
          */
-        wrl(USB_CMD, rdl(USB_CMD) & ~0x1);
-        wrl(USB_CMD, rdl(USB_CMD) | 0x2);
-        while (rdl(USB_CMD) & 0x2);
+        wrl(USB_CMD, rdl(USB_CMD) & ~USB_CMD_RUN);
+        wrl(USB_CMD, rdl(USB_CMD) | USB_CMD_RESET);
+        while (rdl(USB_CMD) & USB_CMD_RESET);
 
         /*
          * GL# USB-5 Streaming disable REG_USB_MODE[4]=1
          * TBD: This need to be done after each reset!
          * GL# USB-4 Setup USB Host mode
          */
-        wrl(USB_MODE, 0x13);
+        wrl(USB_MODE, USB_MODE_SDIS | USB_MODE_HOST);
 }
 
 static void
diff --git a/drivers/usb/host/fhci-hub.c b/drivers/usb/host/fhci-hub.c
index 70116a65262c..3bacdd7befe9 100644
--- a/drivers/usb/host/fhci-hub.c
+++ b/drivers/usb/host/fhci-hub.c
@@ -30,7 +30,7 @@
 /* virtual root hub specific descriptor */
 static u8 root_hub_des[] = {
         0x09, /* blength */
-        0x29, /* bDescriptorType;hub-descriptor */
+        USB_DT_HUB, /* bDescriptorType;hub-descriptor */
         0x01, /* bNbrPorts */
         HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM, /* wHubCharacteristics */
         0x00, /* per-port power, no overcurrent */
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index 475b21fd373b..000ed80ab592 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -1509,7 +1509,7 @@ fotg210_hub_descriptor(
         int             ports = HCS_N_PORTS(fotg210->hcs_params);
         u16             temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = 10;      /* fotg210 1.0, 2.3.9 says 20ms max */
         desc->bHubContrCurrent = 0;
 
@@ -1595,7 +1595,7 @@ static int fotg210_hub_control(
                         /* resume signaling for 20 msec */
                         fotg210_writel(fotg210, temp | PORT_RESUME, status_reg);
                         fotg210->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(wIndex, &fotg210->port_c_suspend);
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index a83eefefffda..00e492eaba6a 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -1467,7 +1467,7 @@ fusbh200_hub_descriptor (
         int             ports = HCS_N_PORTS (fusbh200->hcs_params);
         u16             temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = 10;      /* fusbh200 1.0, 2.3.9 says 20ms max */
         desc->bHubContrCurrent = 0;
 
@@ -1550,10 +1550,9 @@ static int fusbh200_hub_control (
                         if ((temp & PORT_PE) == 0)
                                 goto error;
 
-                        /* resume signaling for 20 msec */
                         fusbh200_writel(fusbh200, temp | PORT_RESUME, status_reg);
                         fusbh200->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(wIndex, &fusbh200->port_c_suspend);
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index 6a2ad550b120..f542045dc2a6 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -1474,7 +1474,7 @@ static int get_hub_descriptor(struct usb_hcd *hcd,
                               struct usb_hub_descriptor *desc)
 {
         struct imx21 *imx21 = hcd_to_imx21(hcd);
-        desc->bDescriptorType = 0x29;   /* HUB descriptor */
+        desc->bDescriptorType = USB_DT_HUB; /* HUB descriptor */
         desc->bHubContrCurrent = 0;
 
         desc->bNbrPorts = readl(imx21->regs + USBH_ROOTHUBA)
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 113d0cc6cc43..13181dcd9820 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -943,7 +943,7 @@ static void isp116x_hub_descriptor(struct isp116x *isp116x,
 {
         u32 reg = isp116x->rhdesca;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bDescLength = 9;
         desc->bHubContrCurrent = 0;
         desc->bNbrPorts = (u8) (reg & 0x3);
@@ -1490,7 +1490,7 @@ static int isp116x_bus_resume(struct usb_hcd *hcd)
         spin_unlock_irq(&isp116x->lock);
 
         hcd->state = HC_STATE_RESUMING;
-        msleep(20);
+        msleep(USB_RESUME_TIMEOUT);
 
         /* Go operational */
         spin_lock_irq(&isp116x->lock);
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index b32ab60cad1e..6cf82ee460a6 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -1538,7 +1538,7 @@ static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
 
         DBG(3, "%s: enter\n", __func__);
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bDescLength = 9;
         desc->bHubContrCurrent = 0;
         desc->bNbrPorts = reg & 0x3;
diff --git a/drivers/usb/host/max3421-hcd.c b/drivers/usb/host/max3421-hcd.c
index a98833cbfcf3..fc1fd403973a 100644
--- a/drivers/usb/host/max3421-hcd.c
+++ b/drivers/usb/host/max3421-hcd.c
@@ -1659,7 +1659,7 @@ hub_descriptor(struct usb_hub_descriptor *desc)
         /*
          * See Table 11-13: Hub Descriptor in USB 2.0 spec.
          */
-        desc->bDescriptorType = 0x29;   /* hub descriptor */
+        desc->bDescriptorType = USB_DT_HUB; /* hub descriptor */
         desc->bDescLength = 9;
         desc->wHubCharacteristics = cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM |
                                                 HUB_CHAR_COMMON_OCPM);
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 7cce85a1f7dc..15df00cceed9 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -39,7 +39,6 @@
 struct ohci_at91_priv {
         struct clk *iclk;
         struct clk *fclk;
-        struct clk *uclk;
         struct clk *hclk;
         bool clocked;
         bool wakeup;            /* Saved wake-up state for resume */
@@ -64,10 +63,8 @@ static void at91_start_clock(struct ohci_at91_priv *ohci_at91)
 {
         if (ohci_at91->clocked)
                 return;
-        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                clk_set_rate(ohci_at91->uclk, 48000000);
-                clk_prepare_enable(ohci_at91->uclk);
-        }
+
+        clk_set_rate(ohci_at91->fclk, 48000000);
         clk_prepare_enable(ohci_at91->hclk);
         clk_prepare_enable(ohci_at91->iclk);
         clk_prepare_enable(ohci_at91->fclk);
@@ -78,11 +75,10 @@ static void at91_stop_clock(struct ohci_at91_priv *ohci_at91)
 {
         if (!ohci_at91->clocked)
                 return;
+
         clk_disable_unprepare(ohci_at91->fclk);
         clk_disable_unprepare(ohci_at91->iclk);
         clk_disable_unprepare(ohci_at91->hclk);
-        if (IS_ENABLED(CONFIG_COMMON_CLK))
-                clk_disable_unprepare(ohci_at91->uclk);
         ohci_at91->clocked = false;
 }
 
@@ -191,14 +187,6 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
                 retval = PTR_ERR(ohci_at91->hclk);
                 goto err;
         }
-        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                ohci_at91->uclk = devm_clk_get(dev, "usb_clk");
-                if (IS_ERR(ohci_at91->uclk)) {
-                        dev_err(dev, "failed to get uclk\n");
-                        retval = PTR_ERR(ohci_at91->uclk);
-                        goto err;
-                }
-        }
 
         board = hcd->self.controller->platform_data;
         ohci = hcd_to_ohci(hcd);
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index fe2aedd8a54d..ed678c17c4ea 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -536,7 +536,7 @@ ohci_hub_descriptor (
         u32             rh = roothub_a (ohci);
         u16             temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
         desc->bHubContrCurrent = 0;
 
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index ef7efb278b15..6352f54e65a1 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -445,7 +445,7 @@ static void ehci_hub_descriptor(struct oxu_hcd *oxu,
         int ports = HCS_N_PORTS(oxu->hcs_params);
         u16 temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = 10;      /* oxu 1.0, 2.3.9 says 20ms max */
         desc->bHubContrCurrent = 0;
 
@@ -2500,11 +2500,12 @@ static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
                                         || oxu->reset_done[i] != 0)
                                 continue;
 
-                        /* start 20 msec resume signaling from this port,
-                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
+                        /* start USB_RESUME_TIMEOUT resume signaling from this
+                         * port, and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.
                          */
-                        oxu->reset_done[i] = jiffies + msecs_to_jiffies(20);
+                        oxu->reset_done[i] = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         oxu_dbg(oxu, "port %d remote wakeup\n", i + 1);
                         mod_timer(&hcd->rh_timer, oxu->reset_done[i]);
                 }
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index bdc82fea0a1f..4cbd0633c5c2 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2136,7 +2136,7 @@ static int r8a66597_hub_status_data(struct usb_hcd *hcd, char *buf)
 static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
                                     struct usb_hub_descriptor *desc)
 {
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bHubContrCurrent = 0;
         desc->bNbrPorts = r8a66597->max_root_hub;
         desc->bDescLength = 9;
@@ -2301,7 +2301,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
                 rh->port &= ~USB_PORT_STAT_SUSPEND;
                 rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
-                msleep(50);
+                msleep(USB_RESUME_TIMEOUT);
                 r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
         }
 
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 4f4ba1ea9e9b..fd2a11473be7 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1091,7 +1091,7 @@ sl811h_hub_descriptor (
 ) {
         u16             temp = 0;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bHubContrCurrent = 0;
 
         desc->bNbrPorts = 1;
@@ -1259,7 +1259,7 @@ sl811h_hub_control(
                         sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
 
                         mod_timer(&sl811->timer, jiffies
-                                        + msecs_to_jiffies(20));
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT));
                         break;
                 case USB_PORT_FEAT_POWER:
                         port_power(sl811, 0);
@@ -1809,7 +1809,6 @@ struct platform_driver sl811h_driver = {
         .resume =       sl811h_resume,
         .driver = {
                 .name = (char *) hcd_name,
-                .owner = THIS_MODULE,
         },
 };
 EXPORT_SYMBOL(sl811h_driver);
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index ad97e8a1ad1c..d51687780b61 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -2584,7 +2584,7 @@ static int u132_roothub_descriptor(struct u132 *u132,
         retval = u132_read_pcimem(u132, roothub.a, &rh_a);
         if (retval)
                 return retval;
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
         desc->bHubContrCurrent = 0;
         desc->bNbrPorts = u132->num_ports;
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 19ba5eafb31e..ece9e37e89fe 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -15,7 +15,7 @@
 static const __u8 root_hub_hub_des[] =
 {
         0x09,                   /*  __u8  bLength; */
-        0x29,                   /*  __u8  bDescriptorType; Hub-descriptor */
+        USB_DT_HUB,             /*  __u8  bDescriptorType; Hub-descriptor */
         0x02,                   /*  __u8  bNbrPorts; */
         HUB_CHAR_NO_LPSM |      /* __u16  wHubCharacteristics; */
                 HUB_CHAR_INDV_PORT_OCPM, /* (per-port OC, no power switching) */
@@ -166,7 +166,7 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
                                 /* Port received a wakeup request */
                                 set_bit(port, &uhci->resuming_ports);
                                 uhci->ports_timeout = jiffies +
-                                                msecs_to_jiffies(25);
+                                        msecs_to_jiffies(USB_RESUME_TIMEOUT);
                                 usb_hcd_start_port_resume(
                                                 &uhci_to_hcd(uhci)->self, port);
 
@@ -338,7 +338,8 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         uhci_finish_suspend(uhci, port, port_addr);
 
                         /* USB v2.0 7.1.7.5 */
-                        uhci->ports_timeout = jiffies + msecs_to_jiffies(50);
+                        uhci->ports_timeout = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_POWER:
                         /* UHCI has no power switching */
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index d7b363a418de..43626c44683b 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -313,8 +313,7 @@ error_wusbhc_create:
         uwb_rc_put(wusbhc->uwb_rc);
 error:
         whc_clean_up(whc);
-        if (usb_hcd)
-                usb_put_hcd(usb_hcd);
+        usb_put_hcd(usb_hcd);
         return ret;
 }
 
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index a7865c4b0498..0827d7c96527 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -387,6 +387,10 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 status = PORT_PLC;
                 port_change_bit = "link state";
                 break;
+        case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
+                status = PORT_CEC;
+                port_change_bit = "config error";
+                break;
         default:
                 /* Should never happen */
                 return;
@@ -588,6 +592,8 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd,
                         status |= USB_PORT_STAT_C_LINK_STATE << 16;
                 if ((raw_port_status & PORT_WRC))
                         status |= USB_PORT_STAT_C_BH_RESET << 16;
+                if ((raw_port_status & PORT_CEC))
+                        status |= USB_PORT_STAT_C_CONFIG_ERROR << 16;
         }
 
         if (hcd->speed != HCD_USB3) {
@@ -1005,6 +1011,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 case USB_PORT_FEAT_C_OVER_CURRENT:
                 case USB_PORT_FEAT_C_ENABLE:
                 case USB_PORT_FEAT_C_PORT_LINK_STATE:
+                case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
                         xhci_clear_port_change_bit(xhci, wValue, wIndex,
                                         port_array[wIndex], temp);
                         break;
@@ -1069,7 +1076,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
          */
         status = bus_state->resuming_ports;
 
-        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC | PORT_CEC;
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index fd53c9ebd662..2af32e26fafc 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -115,6 +115,7 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
         if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
                 xhci->quirks |= XHCI_LPM_SUPPORT;
                 xhci->quirks |= XHCI_INTEL_HOST;
+                xhci->quirks |= XHCI_AVOID_BEI;
         }
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
                         pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI) {
@@ -130,7 +131,6 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  * PPT chipsets.
                  */
                 xhci->quirks |= XHCI_SPURIOUS_REBOOT;
-                xhci->quirks |= XHCI_AVOID_BEI;
         }
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
                 pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI) {
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 0e11d61408ff..783e819139a7 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/usb/phy.h>
 #include <linux/slab.h>
 #include <linux/usb/xhci_pdriver.h>
 
@@ -155,12 +156,27 @@ static int xhci_plat_probe(struct platform_device *pdev)
         if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
                 xhci->shared_hcd->can_do_streams = 1;
 
+        hcd->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
+        if (IS_ERR(hcd->usb_phy)) {
+                ret = PTR_ERR(hcd->usb_phy);
+                if (ret == -EPROBE_DEFER)
+                        goto put_usb3_hcd;
+                hcd->usb_phy = NULL;
+        } else {
+                ret = usb_phy_init(hcd->usb_phy);
+                if (ret)
+                        goto put_usb3_hcd;
+        }
+
         ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
         if (ret)
-                goto put_usb3_hcd;
+                goto disable_usb_phy;
 
         return 0;
 
+disable_usb_phy:
+        usb_phy_shutdown(hcd->usb_phy);
+
 put_usb3_hcd:
         usb_put_hcd(xhci->shared_hcd);
 
@@ -184,6 +200,7 @@ static int xhci_plat_remove(struct platform_device *dev)
         struct clk *clk = xhci->clk;
 
         usb_remove_hcd(xhci->shared_hcd);
+        usb_phy_shutdown(hcd->usb_phy);
         usb_put_hcd(xhci->shared_hcd);
 
         usb_remove_hcd(hcd);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 5fb66db89e05..f5397a517c54 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -238,7 +238,7 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
 
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
-                                ring->cycle_state = (ring->cycle_state ? 0 : 1);
+                                ring->cycle_state ^= 1;
                         }
                 }
                 ring->enq_seg = ring->enq_seg->next;
@@ -1574,7 +1574,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
                 } else {
                         xhci_dbg(xhci, "resume HS port %d\n", port_id);
                         bus_state->resume_done[faked_port_index] = jiffies +
-                                msecs_to_jiffies(20);
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(faked_port_index, &bus_state->resuming_ports);
                         mod_timer(&hcd->rh_timer,
                                   bus_state->resume_done[faked_port_index]);
@@ -1729,7 +1729,7 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
         if (!command)
                 return;
 
-        ep->ep_state |= EP_HALTED | EP_RECENTLY_HALTED;
+        ep->ep_state |= EP_HALTED;
         ep->stopped_stream = stream_id;
 
         xhci_queue_reset_ep(xhci, command, slot_id, ep_index);
@@ -2809,7 +2809,7 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
 
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
-                                ring->cycle_state = (ring->cycle_state ? 0 : 1);
+                                ring->cycle_state ^= 1;
                         }
                         ring->enq_seg = ring->enq_seg->next;
                         ring->enqueue = ring->enq_seg->trbs;
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index b06d1a53652d..ec8ac1674854 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1338,12 +1338,6 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                 goto exit;
         }
 
-        /* Reject urb if endpoint is in soft reset, queue must stay empty */
-        if (xhci->devs[slot_id]->eps[ep_index].ep_state & EP_CONFIG_PENDING) {
-                xhci_warn(xhci, "Can't enqueue URB while ep is in soft reset\n");
-                ret = -EINVAL;
-        }
-
         if (usb_endpoint_xfer_isoc(&urb->ep->desc))
                 size = urb->number_of_packets;
         else
@@ -2954,36 +2948,23 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
         }
 }
 
-/* Called after clearing a halted device. USB core should have sent the control
+/* Called when clearing halted device. The core should have sent the control
  * message to clear the device halt condition. The host side of the halt should
- * already be cleared with a reset endpoint command issued immediately when the
- * STALL tx event was received.
+ * already be cleared with a reset endpoint command issued when the STALL tx
+ * event was received.
+ *
+ * Context: in_interrupt
  */
 
 void xhci_endpoint_reset(struct usb_hcd *hcd,
                 struct usb_host_endpoint *ep)
 {
         struct xhci_hcd *xhci;
-        struct usb_device *udev;
-        struct xhci_virt_device *virt_dev;
-        struct xhci_virt_ep *virt_ep;
-        struct xhci_input_control_ctx *ctrl_ctx;
-        struct xhci_command *command;
-        unsigned int ep_index, ep_state;
-        unsigned long flags;
-        u32 ep_flag;
 
         xhci = hcd_to_xhci(hcd);
-        udev = (struct usb_device *) ep->hcpriv;
-        if (!ep->hcpriv)
-                return;
-        virt_dev = xhci->devs[udev->slot_id];
-        ep_index = xhci_get_endpoint_index(&ep->desc);
-        virt_ep = &virt_dev->eps[ep_index];
-        ep_state = virt_ep->ep_state;
 
         /*
-         * Implement the config ep command in xhci 4.6.8 additional note:
+         * We might need to implement the config ep cmd in xhci 4.8.1 note:
          * The Reset Endpoint Command may only be issued to endpoints in the
          * Halted state. If software wishes reset the Data Toggle or Sequence
          * Number of an endpoint that isn't in the Halted state, then software
@@ -2991,72 +2972,9 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
          * for the target endpoint. that is in the Stopped state.
          */
 
-        if (ep_state & SET_DEQ_PENDING || ep_state & EP_RECENTLY_HALTED) {
-                virt_ep->ep_state &= ~EP_RECENTLY_HALTED;
-                xhci_dbg(xhci, "ep recently halted, no toggle reset needed\n");
-                return;
-        }
-
-        /* Only interrupt and bulk ep's use Data toggle, USB2 spec 5.5.4-> */
-        if (usb_endpoint_xfer_control(&ep->desc) ||
-            usb_endpoint_xfer_isoc(&ep->desc))
-                return;
-
-        ep_flag = xhci_get_endpoint_flag(&ep->desc);
-
-        if (ep_flag == SLOT_FLAG || ep_flag == EP0_FLAG)
-                return;
-
-        command = xhci_alloc_command(xhci, true, true, GFP_NOWAIT);
-        if (!command) {
-                xhci_err(xhci, "Could not allocate xHCI command structure.\n");
-                return;
-        }
-
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        /* block ringing ep doorbell */
-        virt_ep->ep_state |= EP_CONFIG_PENDING;
-
-        /*
-         * Make sure endpoint ring is empty before resetting the toggle/seq.
-         * Driver is required to synchronously cancel all transfer request.
-         *
-         * xhci 4.6.6 says we can issue a configure endpoint command on a
-         * running endpoint ring as long as it's idle (queue empty)
-         */
-
-        if (!list_empty(&virt_ep->ring->td_list)) {
-                dev_err(&udev->dev, "EP not empty, refuse reset\n");
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                goto cleanup;
-        }
-
-        xhci_dbg(xhci, "Reset toggle/seq for slot %d, ep_index: %d\n",
-                 udev->slot_id, ep_index);
-
-        ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
-        if (!ctrl_ctx) {
-                xhci_err(xhci, "Could not get input context, bad type. virt_dev: %p, in_ctx %p\n",
-                         virt_dev, virt_dev->in_ctx);
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                goto cleanup;
-        }
-        xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx,
-                                           virt_dev->out_ctx, ctrl_ctx,
-                                           ep_flag, ep_flag);
-        xhci_endpoint_copy(xhci, command->in_ctx, virt_dev->out_ctx, ep_index);
-
-        xhci_queue_configure_endpoint(xhci, command, command->in_ctx->dma,
-                                     udev->slot_id, false);
-        xhci_ring_cmd_db(xhci);
-        spin_unlock_irqrestore(&xhci->lock, flags);
-
-        wait_for_completion(command->completion);
-
-cleanup:
-        virt_ep->ep_state &= ~EP_CONFIG_PENDING;
-        xhci_free_command(xhci, command);
+        /* For now just print debug to follow the situation */
+        xhci_dbg(xhci, "Endpoint 0x%x ep reset callback called\n",
+                 ep->desc.bEndpointAddress);
 }
 
 static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 265ab1771d24..8e421b89632d 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -865,8 +865,6 @@ struct xhci_virt_ep {
 #define EP_HAS_STREAMS          (1 << 4)
 /* Transitioning the endpoint to not using streams, don't enqueue URBs */
 #define EP_GETTING_NO_STREAMS   (1 << 5)
-#define EP_RECENTLY_HALTED      (1 << 6)
-#define EP_CONFIG_PENDING       (1 << 7)
         /* ----  Related to URB cancellation ---- */
         struct list_head        cancelled_td_list;
         struct xhci_td          *stopped_td;
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index a62865af53cc..5cf2633cdb04 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -347,7 +347,8 @@ static int mdc800_usb_waitForIRQ (int mode, int msec)
 {
         mdc800->camera_request_ready=1+mode;
 
-        wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken, msec*HZ/1000);
+        wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken,
+                           msecs_to_jiffies(msec));
         mdc800->irq_woken = 0;
 
         if (mdc800->camera_request_ready>0)
@@ -743,8 +744,9 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
                                         mutex_unlock(&mdc800->io_lock);
                                         return len-left;
                                 }
-                                wait_event_timeout(mdc800->download_wait, mdc800->downloaded,
-                                                                                TO_DOWNLOAD_GET_READY*HZ/1000);
+                                wait_event_timeout(mdc800->download_wait,
+                                     mdc800->downloaded,
+                                     msecs_to_jiffies(TO_DOWNLOAD_GET_READY));
                                 mdc800->downloaded = 0;
                                 if (mdc800->download_urb->status != 0)
                                 {
@@ -867,7 +869,8 @@ static ssize_t mdc800_device_write (struct file *file, const char __user *buf, s
                                 mutex_unlock(&mdc800->io_lock);
                                 return -EIO;
                         }
-                        wait_event_timeout(mdc800->write_wait, mdc800->written, TO_WRITE_GET_READY*HZ/1000);
+                        wait_event_timeout(mdc800->write_wait, mdc800->written,
+                                        msecs_to_jiffies(TO_WRITE_GET_READY));
                         mdc800->written = 0;
                         if (mdc800->state == WORKING)
                         {
diff --git a/drivers/usb/isp1760/isp1760-core.c b/drivers/usb/isp1760/isp1760-core.c
index b9827556455f..bfa402cf3a27 100644
--- a/drivers/usb/isp1760/isp1760-core.c
+++ b/drivers/usb/isp1760/isp1760-core.c
@@ -151,8 +151,7 @@ int isp1760_register(struct resource *mem, int irq, unsigned long irqflags,
         }
 
         if (IS_ENABLED(CONFIG_USB_ISP1761_UDC) && !udc_disabled) {
-                ret = isp1760_udc_register(isp, irq, irqflags | IRQF_SHARED |
-                                           IRQF_DISABLED);
+                ret = isp1760_udc_register(isp, irq, irqflags);
                 if (ret < 0) {
                         isp1760_hcd_unregister(&isp->hcd);
                         return ret;
diff --git a/drivers/usb/isp1760/isp1760-hcd.c b/drivers/usb/isp1760/isp1760-hcd.c
index 3cb98b1d5d29..ac31d19cc54b 100644
--- a/drivers/usb/isp1760/isp1760-hcd.c
+++ b/drivers/usb/isp1760/isp1760-hcd.c
@@ -1758,7 +1758,7 @@ static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
         int ports = HCS_N_PORTS(priv->hcs_params);
         u16 temp;
 
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         /* priv 1.0, 2.3.9 says 20ms max */
         desc->bPwrOn2PwrGood = 10;
         desc->bHubContrCurrent = 0;
@@ -1869,7 +1869,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                 reg_write32(hcd->regs, HC_PORTSC1,
                                                         temp | PORT_RESUME);
                                 priv->reset_done = jiffies +
-                                        msecs_to_jiffies(20);
+                                        msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         }
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
diff --git a/drivers/usb/isp1760/isp1760-udc.c b/drivers/usb/isp1760/isp1760-udc.c
index 9612d7990565..3fc4fe770253 100644
--- a/drivers/usb/isp1760/isp1760-udc.c
+++ b/drivers/usb/isp1760/isp1760-udc.c
@@ -1191,6 +1191,7 @@ static int isp1760_udc_start(struct usb_gadget *gadget,
                              struct usb_gadget_driver *driver)
 {
         struct isp1760_udc *udc = gadget_to_udc(gadget);
+        unsigned long flags;
 
         /* The hardware doesn't support low speed. */
         if (driver->max_speed < USB_SPEED_FULL) {
@@ -1198,17 +1199,17 @@ static int isp1760_udc_start(struct usb_gadget *gadget,
                 return -EINVAL;
         }
 
-        spin_lock(&udc->lock);
+        spin_lock_irqsave(&udc->lock, flags);
 
         if (udc->driver) {
                 dev_err(udc->isp->dev, "UDC already has a gadget driver\n");
-                spin_unlock(&udc->lock);
+                spin_unlock_irqrestore(&udc->lock, flags);
                 return -EBUSY;
         }
 
         udc->driver = driver;
 
-        spin_unlock(&udc->lock);
+        spin_unlock_irqrestore(&udc->lock, flags);
 
         dev_dbg(udc->isp->dev, "starting UDC with driver %s\n",
                 driver->function);
@@ -1232,6 +1233,7 @@ static int isp1760_udc_start(struct usb_gadget *gadget,
 static int isp1760_udc_stop(struct usb_gadget *gadget)
 {
         struct isp1760_udc *udc = gadget_to_udc(gadget);
+        unsigned long flags;
 
         dev_dbg(udc->isp->dev, "%s\n", __func__);
 
@@ -1239,9 +1241,9 @@ static int isp1760_udc_stop(struct usb_gadget *gadget)
 
         isp1760_udc_write(udc, DC_MODE, 0);
 
-        spin_lock(&udc->lock);
+        spin_lock_irqsave(&udc->lock, flags);
         udc->driver = NULL;
-        spin_unlock(&udc->lock);
+        spin_unlock_irqrestore(&udc->lock, flags);
 
         return 0;
 }
@@ -1411,7 +1413,7 @@ static int isp1760_udc_init(struct isp1760_udc *udc)
                 return -ENODEV;
         }
 
-        if (chipid != 0x00011582) {
+        if (chipid != 0x00011582 && chipid != 0x00158210) {
                 dev_err(udc->isp->dev, "udc: invalid chip ID 0x%08x\n", chipid);
                 return -ENODEV;
         }
@@ -1451,8 +1453,8 @@ int isp1760_udc_register(struct isp1760_device *isp, int irq,
 
         sprintf(udc->irqname, "%s (udc)", devname);
 
-        ret = request_irq(irq, isp1760_udc_irq, IRQF_SHARED | IRQF_DISABLED |
-                          irqflags, udc->irqname, udc);
+        ret = request_irq(irq, isp1760_udc_irq, IRQF_SHARED | irqflags,
+                          udc->irqname, udc);
         if (ret < 0)
                 goto error;
 
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index 76d77206e011..f7a7fc21be8a 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -255,3 +255,16 @@ config USB_LINK_LAYER_TEST
           This driver is for generating specific traffic for Super Speed Link
           Layer Test Device. Say Y only when you want to conduct USB Super Speed
           Link Layer Test for host controllers.
+
+config USB_CHAOSKEY
+        tristate "ChaosKey random number generator driver support"
+        depends on HW_RANDOM
+        help
+          Say Y here if you want to connect an AltusMetrum ChaosKey to
+          your computer's USB port. The ChaosKey is a hardware random
+          number generator which hooks into the kernel entropy pool to
+          ensure a large supply of entropy for /dev/random and
+          /dev/urandom and also provides direct access via /dev/chaoskeyX
+
+          To compile this driver as a module, choose M here: the
+          module will be called chaoskey.
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 65b0402c1ca1..45fd4ac39d3e 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_USB_USS720)		+= uss720.o
 obj-$(CONFIG_USB_SEVSEG)                += usbsevseg.o
 obj-$(CONFIG_USB_YUREX)                 += yurex.o
 obj-$(CONFIG_USB_HSIC_USB3503)          += usb3503.o
+obj-$(CONFIG_USB_CHAOSKEY)              += chaoskey.o
 
 obj-$(CONFIG_USB_SISUSBVGA)             += sisusbvga/
 obj-$(CONFIG_USB_LINK_LAYER_TEST)       += lvstest.o
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index b3d245ef46ef..a0a3827b4aff 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -329,7 +329,7 @@ error:
                                         pdata->urbdata, pdata->urb->transfer_dma);
                         usb_free_urb(pdata->urb);
                 }
-                if (pdata->bd && !IS_ERR(pdata->bd))
+                if (!IS_ERR(pdata->bd))
                         backlight_device_unregister(pdata->bd);
                 kfree(pdata->msgdata);
         }
diff --git a/drivers/usb/misc/chaoskey.c b/drivers/usb/misc/chaoskey.c
new file mode 100644
index 000000000000..3ad5d19e4d04
--- /dev/null
+++ b/drivers/usb/misc/chaoskey.c
@@ -0,0 +1,532 @@
+/*
+ * chaoskey - driver for ChaosKey device from Altus Metrum.
+ *
+ * This device provides true random numbers using a noise source based
+ * on a reverse-biased p-n junction in avalanche breakdown. More
+ * details can be found at http://chaoskey.org
+ *
+ * The driver connects to the kernel hardware RNG interface to provide
+ * entropy for /dev/random and other kernel activities. It also offers
+ * a separate /dev/ entry to allow for direct access to the random
+ * bit stream.
+ *
+ * Copyright © 2015 Keith Packard <keithp@keithp.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 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/wait.h>
+#include <linux/hw_random.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+
+static struct usb_driver chaoskey_driver;
+static struct usb_class_driver chaoskey_class;
+static int chaoskey_rng_read(struct hwrng *rng, void *data,
+                             size_t max, bool wait);
+
+#define usb_dbg(usb_if, format, arg...) \
+        dev_dbg(&(usb_if)->dev, format, ## arg)
+
+#define usb_err(usb_if, format, arg...) \
+        dev_err(&(usb_if)->dev, format, ## arg)
+
+/* Version Information */
+#define DRIVER_VERSION  "v0.1"
+#define DRIVER_AUTHOR   "Keith Packard, keithp@keithp.com"
+#define DRIVER_DESC     "Altus Metrum ChaosKey driver"
+#define DRIVER_SHORT    "chaoskey"
+
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+#define CHAOSKEY_VENDOR_ID      0x1d50  /* OpenMoko */
+#define CHAOSKEY_PRODUCT_ID     0x60c6  /* ChaosKey */
+
+#define CHAOSKEY_BUF_LEN        64      /* max size of USB full speed packet */
+
+#define NAK_TIMEOUT (HZ)                /* stall/wait timeout for device */
+
+#ifdef CONFIG_USB_DYNAMIC_MINORS
+#define USB_CHAOSKEY_MINOR_BASE 0
+#else
+
+/* IOWARRIOR_MINOR_BASE + 16, not official yet */
+#define USB_CHAOSKEY_MINOR_BASE 224
+#endif
+
+static const struct usb_device_id chaoskey_table[] = {
+        { USB_DEVICE(CHAOSKEY_VENDOR_ID, CHAOSKEY_PRODUCT_ID) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, chaoskey_table);
+
+/* Driver-local specific stuff */
+struct chaoskey {
+        struct usb_interface *interface;
+        char in_ep;
+        struct mutex lock;
+        struct mutex rng_lock;
+        int open;                       /* open count */
+        int present;                    /* device not disconnected */
+        int size;                       /* size of buf */
+        int valid;                      /* bytes of buf read */
+        int used;                       /* bytes of buf consumed */
+        char *name;                     /* product + serial */
+        struct hwrng hwrng;             /* Embedded struct for hwrng */
+        int hwrng_registered;           /* registered with hwrng API */
+        wait_queue_head_t wait_q;       /* for timeouts */
+        char *buf;
+};
+
+static void chaoskey_free(struct chaoskey *dev)
+{
+        usb_dbg(dev->interface, "free");
+        kfree(dev->name);
+        kfree(dev->buf);
+        kfree(dev);
+}
+
+static int chaoskey_probe(struct usb_interface *interface,
+                          const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(interface);
+        struct usb_host_interface *altsetting = interface->cur_altsetting;
+        int i;
+        int in_ep = -1;
+        struct chaoskey *dev;
+        int result;
+        int size;
+
+        usb_dbg(interface, "probe %s-%s", udev->product, udev->serial);
+
+        /* Find the first bulk IN endpoint and its packet size */
+        for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
+                if (usb_endpoint_is_bulk_in(&altsetting->endpoint[i].desc)) {
+                        in_ep = usb_endpoint_num(&altsetting->endpoint[i].desc);
+                        size = usb_endpoint_maxp(&altsetting->endpoint[i].desc);
+                        break;
+                }
+        }
+
+        /* Validate endpoint and size */
+        if (in_ep == -1) {
+                usb_dbg(interface, "no IN endpoint found");
+                return -ENODEV;
+        }
+        if (size <= 0) {
+                usb_dbg(interface, "invalid size (%d)", size);
+                return -ENODEV;
+        }
+
+        if (size > CHAOSKEY_BUF_LEN) {
+                usb_dbg(interface, "size reduced from %d to %d\n",
+                        size, CHAOSKEY_BUF_LEN);
+                size = CHAOSKEY_BUF_LEN;
+        }
+
+        /* Looks good, allocate and initialize */
+
+        dev = kzalloc(sizeof(struct chaoskey), GFP_KERNEL);
+
+        if (dev == NULL)
+                return -ENOMEM;
+
+        dev->buf = kmalloc(size, GFP_KERNEL);
+
+        if (dev->buf == NULL) {
+                kfree(dev);
+                return -ENOMEM;
+        }
+
+        /* Construct a name using the product and serial values. Each
+         * device needs a unique name for the hwrng code
+         */
+
+        if (udev->product && udev->serial) {
+                dev->name = kmalloc(strlen(udev->product) + 1 +
+                                    strlen(udev->serial) + 1, GFP_KERNEL);
+                if (dev->name == NULL) {
+                        kfree(dev->buf);
+                        kfree(dev);
+                        return -ENOMEM;
+                }
+
+                strcpy(dev->name, udev->product);
+                strcat(dev->name, "-");
+                strcat(dev->name, udev->serial);
+        }
+
+        dev->interface = interface;
+
+        dev->in_ep = in_ep;
+
+        dev->size = size;
+        dev->present = 1;
+
+        init_waitqueue_head(&dev->wait_q);
+
+        mutex_init(&dev->lock);
+        mutex_init(&dev->rng_lock);
+
+        usb_set_intfdata(interface, dev);
+
+        result = usb_register_dev(interface, &chaoskey_class);
+        if (result) {
+                usb_err(interface, "Unable to allocate minor number.");
+                usb_set_intfdata(interface, NULL);
+                chaoskey_free(dev);
+                return result;
+        }
+
+        dev->hwrng.name = dev->name ? dev->name : chaoskey_driver.name;
+        dev->hwrng.read = chaoskey_rng_read;
+
+        /* Set the 'quality' metric.  Quality is measured in units of
+         * 1/1024's of a bit ("mills"). This should be set to 1024,
+         * but there is a bug in the hwrng core which masks it with
+         * 1023.
+         *
+         * The patch that has been merged to the crypto development
+         * tree for that bug limits the value to 1024 at most, so by
+         * setting this to 1024 + 1023, we get 1023 before the fix is
+         * merged and 1024 afterwards. We'll patch this driver once
+         * both bits of code are in the same tree.
+         */
+        dev->hwrng.quality = 1024 + 1023;
+
+        dev->hwrng_registered = (hwrng_register(&dev->hwrng) == 0);
+        if (!dev->hwrng_registered)
+                usb_err(interface, "Unable to register with hwrng");
+
+        usb_enable_autosuspend(udev);
+
+        usb_dbg(interface, "chaoskey probe success, size %d", dev->size);
+        return 0;
+}
+
+static void chaoskey_disconnect(struct usb_interface *interface)
+{
+        struct chaoskey *dev;
+
+        usb_dbg(interface, "disconnect");
+        dev = usb_get_intfdata(interface);
+        if (!dev) {
+                usb_dbg(interface, "disconnect failed - no dev");
+                return;
+        }
+
+        if (dev->hwrng_registered)
+                hwrng_unregister(&dev->hwrng);
+
+        usb_deregister_dev(interface, &chaoskey_class);
+
+        usb_set_intfdata(interface, NULL);
+        mutex_lock(&dev->lock);
+
+        dev->present = 0;
+
+        if (!dev->open) {
+                mutex_unlock(&dev->lock);
+                chaoskey_free(dev);
+        } else
+                mutex_unlock(&dev->lock);
+
+        usb_dbg(interface, "disconnect done");
+}
+
+static int chaoskey_open(struct inode *inode, struct file *file)
+{
+        struct chaoskey *dev;
+        struct usb_interface *interface;
+
+        /* get the interface from minor number and driver information */
+        interface = usb_find_interface(&chaoskey_driver, iminor(inode));
+        if (!interface)
+                return -ENODEV;
+
+        usb_dbg(interface, "open");
+
+        dev = usb_get_intfdata(interface);
+        if (!dev) {
+                usb_dbg(interface, "open (dev)");
+                return -ENODEV;
+        }
+
+        file->private_data = dev;
+        mutex_lock(&dev->lock);
+        ++dev->open;
+        mutex_unlock(&dev->lock);
+
+        usb_dbg(interface, "open success");
+        return 0;
+}
+
+static int chaoskey_release(struct inode *inode, struct file *file)
+{
+        struct chaoskey *dev = file->private_data;
+        struct usb_interface *interface;
+
+        if (dev == NULL)
+                return -ENODEV;
+
+        interface = dev->interface;
+
+        usb_dbg(interface, "release");
+
+        mutex_lock(&dev->lock);
+
+        usb_dbg(interface, "open count at release is %d", dev->open);
+
+        if (dev->open <= 0) {
+                usb_dbg(interface, "invalid open count (%d)", dev->open);
+                mutex_unlock(&dev->lock);
+                return -ENODEV;
+        }
+
+        --dev->open;
+
+        if (!dev->present) {
+                if (dev->open == 0) {
+                        mutex_unlock(&dev->lock);
+                        chaoskey_free(dev);
+                } else
+                        mutex_unlock(&dev->lock);
+        } else
+                mutex_unlock(&dev->lock);
+
+        usb_dbg(interface, "release success");
+        return 0;
+}
+
+/* Fill the buffer. Called with dev->lock held
+ */
+static int _chaoskey_fill(struct chaoskey *dev)
+{
+        DEFINE_WAIT(wait);
+        int result;
+        int this_read;
+        struct usb_device *udev = interface_to_usbdev(dev->interface);
+
+        usb_dbg(dev->interface, "fill");
+
+        /* Return immediately if someone called before the buffer was
+         * empty */
+        if (dev->valid != dev->used) {
+                usb_dbg(dev->interface, "not empty yet (valid %d used %d)",
+                        dev->valid, dev->used);
+                return 0;
+        }
+
+        /* Bail if the device has been removed */
+        if (!dev->present) {
+                usb_dbg(dev->interface, "device not present");
+                return -ENODEV;
+        }
+
+        /* Make sure the device is awake */
+        result = usb_autopm_get_interface(dev->interface);
+        if (result) {
+                usb_dbg(dev->interface, "wakeup failed (result %d)", result);
+                return result;
+        }
+
+        result = usb_bulk_msg(udev,
+                              usb_rcvbulkpipe(udev, dev->in_ep),
+                              dev->buf, dev->size, &this_read,
+                              NAK_TIMEOUT);
+
+        /* Let the device go back to sleep eventually */
+        usb_autopm_put_interface(dev->interface);
+
+        if (result == 0) {
+                dev->valid = this_read;
+                dev->used = 0;
+        }
+
+        usb_dbg(dev->interface, "bulk_msg result %d this_read %d",
+                result, this_read);
+
+        return result;
+}
+
+static ssize_t chaoskey_read(struct file *file,
+                             char __user *buffer,
+                             size_t count,
+                             loff_t *ppos)
+{
+        struct chaoskey *dev;
+        ssize_t read_count = 0;
+        int this_time;
+        int result = 0;
+        unsigned long remain;
+
+        dev = file->private_data;
+
+        if (dev == NULL || !dev->present)
+                return -ENODEV;
+
+        usb_dbg(dev->interface, "read %zu", count);
+
+        while (count > 0) {
+
+                /* Grab the rng_lock briefly to ensure that the hwrng interface
+                 * gets priority over other user access
+                 */
+                result = mutex_lock_interruptible(&dev->rng_lock);
+                if (result)
+                        goto bail;
+                mutex_unlock(&dev->rng_lock);
+
+                result = mutex_lock_interruptible(&dev->lock);
+                if (result)
+                        goto bail;
+                if (dev->valid == dev->used) {
+                        result = _chaoskey_fill(dev);
+                        if (result) {
+                                mutex_unlock(&dev->lock);
+                                goto bail;
+                        }
+
+                        /* Read returned zero bytes */
+                        if (dev->used == dev->valid) {
+                                mutex_unlock(&dev->lock);
+                                goto bail;
+                        }
+                }
+
+                this_time = dev->valid - dev->used;
+                if (this_time > count)
+                        this_time = count;
+
+                remain = copy_to_user(buffer, dev->buf + dev->used, this_time);
+                if (remain) {
+                        result = -EFAULT;
+
+                        /* Consume the bytes that were copied so we don't leak
+                         * data to user space
+                         */
+                        dev->used += this_time - remain;
+                        mutex_unlock(&dev->lock);
+                        goto bail;
+                }
+
+                count -= this_time;
+                read_count += this_time;
+                buffer += this_time;
+                dev->used += this_time;
+                mutex_unlock(&dev->lock);
+        }
+bail:
+        if (read_count) {
+                usb_dbg(dev->interface, "read %zu bytes", read_count);
+                return read_count;
+        }
+        usb_dbg(dev->interface, "empty read, result %d", result);
+        return result;
+}
+
+static int chaoskey_rng_read(struct hwrng *rng, void *data,
+                             size_t max, bool wait)
+{
+        struct chaoskey *dev = container_of(rng, struct chaoskey, hwrng);
+        int this_time;
+
+        usb_dbg(dev->interface, "rng_read max %zu wait %d", max, wait);
+
+        if (!dev->present) {
+                usb_dbg(dev->interface, "device not present");
+                return 0;
+        }
+
+        /* Hold the rng_lock until we acquire the device lock so that
+         * this operation gets priority over other user access to the
+         * device
+         */
+        mutex_lock(&dev->rng_lock);
+
+        mutex_lock(&dev->lock);
+
+        mutex_unlock(&dev->rng_lock);
+
+        /* Try to fill the buffer if empty. It doesn't actually matter
+         * if _chaoskey_fill works; we'll just return zero bytes as
+         * the buffer will still be empty
+         */
+        if (dev->valid == dev->used)
+                (void) _chaoskey_fill(dev);
+
+        this_time = dev->valid - dev->used;
+        if (this_time > max)
+                this_time = max;
+
+        memcpy(data, dev->buf, this_time);
+
+        dev->used += this_time;
+
+        mutex_unlock(&dev->lock);
+
+        usb_dbg(dev->interface, "rng_read this_time %d\n", this_time);
+        return this_time;
+}
+
+#ifdef CONFIG_PM
+static int chaoskey_suspend(struct usb_interface *interface,
+                            pm_message_t message)
+{
+        usb_dbg(interface, "suspend");
+        return 0;
+}
+
+static int chaoskey_resume(struct usb_interface *interface)
+{
+        usb_dbg(interface, "resume");
+        return 0;
+}
+#else
+#define chaoskey_suspend NULL
+#define chaoskey_resume NULL
+#endif
+
+/* file operation pointers */
+static const struct file_operations chaoskey_fops = {
+        .owner = THIS_MODULE,
+        .read = chaoskey_read,
+        .open = chaoskey_open,
+        .release = chaoskey_release,
+        .llseek = default_llseek,
+};
+
+/* class driver information */
+static struct usb_class_driver chaoskey_class = {
+        .name = "chaoskey%d",
+        .fops = &chaoskey_fops,
+        .minor_base = USB_CHAOSKEY_MINOR_BASE,
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver chaoskey_driver = {
+        .name = DRIVER_SHORT,
+        .probe = chaoskey_probe,
+        .disconnect = chaoskey_disconnect,
+        .suspend = chaoskey_suspend,
+        .resume = chaoskey_resume,
+        .reset_resume = chaoskey_resume,
+        .id_table = chaoskey_table,
+        .supports_autosuspend = 1,
+};
+
+module_usb_driver(chaoskey_driver);
+
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 97cd9e24bd25..7771be3ac178 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -574,7 +574,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
         }
 
         if (read_timeout) {
-                timeout = jiffies + read_timeout * HZ / 1000;
+                timeout = jiffies + msecs_to_jiffies(read_timeout);
         }
 
         /* wait for data */
@@ -592,7 +592,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
                 /* reset read timeout during read or write activity */
                 if (read_timeout
                     && (dev->read_buffer_length || dev->interrupt_out_busy)) {
-                        timeout = jiffies + read_timeout * HZ / 1000;
+                        timeout = jiffies + msecs_to_jiffies(read_timeout);
                 }
                 /* check for read timeout */
                 if (read_timeout && time_after (jiffies, timeout)) {
@@ -831,7 +831,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
         dev->read_buffer_length = 0;
         dev->read_packet_length = 0;
         spin_lock_init (&dev->read_buffer_lock);
-        dev->packet_timeout_jiffies = packet_timeout * HZ / 1000;
+        dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);
         dev->read_last_arrival = jiffies;
 
         init_waitqueue_head (&dev->read_wait);
diff --git a/drivers/usb/misc/usb3503.c b/drivers/usb/misc/usb3503.c
index 258d2f546e43..64ff5b91752d 100644
--- a/drivers/usb/misc/usb3503.c
+++ b/drivers/usb/misc/usb3503.c
@@ -186,8 +186,31 @@ static int usb3503_probe(struct usb3503 *hub)
                 hub->mode               = pdata->initial_mode;
         } else if (np) {
                 struct clk *clk;
+                u32 rate = 0;
                 hub->port_off_mask = 0;
 
+                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;
+                        }
+                }
+
                 clk = devm_clk_get(dev, "refclk");
                 if (IS_ERR(clk) && PTR_ERR(clk) != -ENOENT) {
                         dev_err(dev, "unable to request refclk (%ld)\n",
@@ -196,31 +219,9 @@ static int usb3503_probe(struct usb3503 *hub)
                 }
 
                 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;
-                                }
+                        if (rate != 0) {
                                 err = clk_set_rate(hub->clk, rate);
                                 if (err) {
                                         dev_err(dev,
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 14e1628483d9..39db8b603627 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -79,7 +79,8 @@ config USB_MUSB_TUSB6010
 
 config USB_MUSB_OMAP2PLUS
         tristate "OMAP2430 and onwards"
-        depends on ARCH_OMAP2PLUS && USB && OMAP_CONTROL_PHY
+        depends on ARCH_OMAP2PLUS && USB
+        depends on OMAP_CONTROL_PHY || !OMAP_CONTROL_PHY
         select GENERIC_PHY
 
 config USB_MUSB_AM35X
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 067920f2d570..3789b08ef67b 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -99,6 +99,7 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb.h>
 
 #include "musb_core.h"
 
@@ -507,7 +508,8 @@ void musb_hnp_stop(struct musb *musb)
         musb->port1_status &= ~(USB_PORT_STAT_C_CONNECTION << 16);
 }
 
-static void musb_generic_disable(struct musb *musb);
+static void musb_recover_from_babble(struct musb *musb);
+
 /*
  * Interrupt Service Routine to record USB "global" interrupts.
  * Since these do not happen often and signify things of
@@ -534,35 +536,21 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
          */
         if (int_usb & MUSB_INTR_RESUME) {
                 handled = IRQ_HANDLED;
-                dev_dbg(musb->controller, "RESUME (%s)\n", usb_otg_state_string(musb->xceiv->otg->state));
+                dev_dbg(musb->controller, "RESUME (%s)\n",
+                                usb_otg_state_string(musb->xceiv->otg->state));
 
                 if (devctl & MUSB_DEVCTL_HM) {
-                        void __iomem *mbase = musb->mregs;
-                        u8 power;
-
                         switch (musb->xceiv->otg->state) {
                         case OTG_STATE_A_SUSPEND:
                                 /* remote wakeup?  later, GetPortStatus
                                  * will stop RESUME signaling
                                  */
 
-                                power = musb_readb(musb->mregs, MUSB_POWER);
-                                if (power & MUSB_POWER_SUSPENDM) {
-                                        /* spurious */
-                                        musb->int_usb &= ~MUSB_INTR_SUSPEND;
-                                        dev_dbg(musb->controller, "Spurious SUSPENDM\n");
-                                        break;
-                                }
-
-                                power &= ~MUSB_POWER_SUSPENDM;
-                                musb_writeb(mbase, MUSB_POWER,
-                                                power | MUSB_POWER_RESUME);
-
                                 musb->port1_status |=
                                                 (USB_PORT_STAT_C_SUSPEND << 16)
                                                 | MUSB_PORT_STAT_RESUME;
                                 musb->rh_timer = jiffies
-                                                 + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                                 musb->need_finish_resume = 1;
 
                                 musb->xceiv->otg->state = OTG_STATE_A_HOST;
@@ -775,10 +763,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                 musb->ep0_stage = MUSB_EP0_START;
 
-                /* flush endpoints when transitioning from Device Mode */
-                if (is_peripheral_active(musb)) {
-                        /* REVISIT HNP; just force disconnect */
-                }
                 musb->intrtxe = musb->epmask;
                 musb_writew(musb->mregs, MUSB_INTRTXE, musb->intrtxe);
                 musb->intrrxe = musb->epmask & 0xfffe;
@@ -879,20 +863,19 @@ b_host:
          */
         if (int_usb & MUSB_INTR_RESET) {
                 handled = IRQ_HANDLED;
-                if ((devctl & MUSB_DEVCTL_HM) != 0) {
+                if (devctl & MUSB_DEVCTL_HM) {
                         /*
-                         * Looks like non-HS BABBLE can be ignored, but
-                         * HS BABBLE is an error condition. For HS the solution
-                         * is to avoid babble in the first place and fix what
-                         * caused BABBLE. When HS BABBLE happens we can only
-                         * stop the session.
+                         * When BABBLE happens what we can depends on which
+                         * platform MUSB is running, because some platforms
+                         * implemented proprietary means for 'recovering' from
+                         * Babble conditions. One such platform is AM335x. In
+                         * most cases, however, the only thing we can do is
+                         * drop the session.
                          */
-                        if (devctl & (MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV))
-                                dev_dbg(musb->controller, "BABBLE devctl: %02x\n", devctl);
-                        else {
-                                ERR("Stopping host session -- babble\n");
-                                musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
-                        }
+                        dev_err(musb->controller, "Babble\n");
+
+                        if (is_host_active(musb))
+                                musb_recover_from_babble(musb);
                 } else {
                         dev_dbg(musb->controller, "BUS RESET as %s\n",
                                 usb_otg_state_string(musb->xceiv->otg->state));
@@ -931,13 +914,6 @@ b_host:
                 }
         }
 
-        /* handle babble condition */
-        if (int_usb & MUSB_INTR_BABBLE && is_host_active(musb)) {
-                musb_generic_disable(musb);
-                schedule_delayed_work(&musb->recover_work,
-                                      msecs_to_jiffies(100));
-        }
-
 #if 0
 /* REVISIT ... this would be for multiplexing periodic endpoints, or
  * supporting transfer phasing to prevent exceeding ISO bandwidth
@@ -990,7 +966,7 @@ b_host:
 
 /*-------------------------------------------------------------------------*/
 
-static void musb_generic_disable(struct musb *musb)
+static void musb_disable_interrupts(struct musb *musb)
 {
         void __iomem    *mbase = musb->mregs;
         u16     temp;
@@ -1002,14 +978,33 @@ static void musb_generic_disable(struct musb *musb)
         musb->intrrxe = 0;
         musb_writew(mbase, MUSB_INTRRXE, 0);
 
-        /* off */
-        musb_writeb(mbase, MUSB_DEVCTL, 0);
-
         /*  flush pending interrupts */
         temp = musb_readb(mbase, MUSB_INTRUSB);
         temp = musb_readw(mbase, MUSB_INTRTX);
         temp = musb_readw(mbase, MUSB_INTRRX);
+}
+
+static void musb_enable_interrupts(struct musb *musb)
+{
+        void __iomem    *regs = musb->mregs;
+
+        /*  Set INT enable registers, enable interrupts */
+        musb->intrtxe = musb->epmask;
+        musb_writew(regs, MUSB_INTRTXE, musb->intrtxe);
+        musb->intrrxe = musb->epmask & 0xfffe;
+        musb_writew(regs, MUSB_INTRRXE, musb->intrrxe);
+        musb_writeb(regs, MUSB_INTRUSBE, 0xf7);
+
+}
+
+static void musb_generic_disable(struct musb *musb)
+{
+        void __iomem    *mbase = musb->mregs;
 
+        musb_disable_interrupts(musb);
+
+        /* off */
+        musb_writeb(mbase, MUSB_DEVCTL, 0);
 }
 
 /*
@@ -1022,13 +1017,7 @@ void musb_start(struct musb *musb)
 
         dev_dbg(musb->controller, "<== devctl %02x\n", devctl);
 
-        /*  Set INT enable registers, enable interrupts */
-        musb->intrtxe = musb->epmask;
-        musb_writew(regs, MUSB_INTRTXE, musb->intrtxe);
-        musb->intrrxe = musb->epmask & 0xfffe;
-        musb_writew(regs, MUSB_INTRRXE, musb->intrrxe);
-        musb_writeb(regs, MUSB_INTRUSBE, 0xf7);
-
+        musb_enable_interrupts(musb);
         musb_writeb(regs, MUSB_TESTMODE, 0);
 
         /* put into basic highspeed mode and start session */
@@ -1587,9 +1576,12 @@ static int musb_core_init(u16 musb_type, struct musb *musb)
 irqreturn_t musb_interrupt(struct musb *musb)
 {
         irqreturn_t     retval = IRQ_NONE;
+        unsigned long   status;
+        unsigned long   epnum;
         u8              devctl;
-        int             ep_num;
-        u32             reg;
+
+        if (!musb->int_usb && !musb->int_tx && !musb->int_rx)
+                return IRQ_NONE;
 
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
@@ -1597,56 +1589,57 @@ irqreturn_t musb_interrupt(struct musb *musb)
                 is_host_active(musb) ? "host" : "peripheral",
                 musb->int_usb, musb->int_tx, musb->int_rx);
 
-        /* the core can interrupt us for multiple reasons; docs have
-         * a generic interrupt flowchart to follow
+        /**
+         * According to Mentor Graphics' documentation, flowchart on page 98,
+         * IRQ should be handled as follows:
+         *
+         * . Resume IRQ
+         * . Session Request IRQ
+         * . VBUS Error IRQ
+         * . Suspend IRQ
+         * . Connect IRQ
+         * . Disconnect IRQ
+         * . Reset/Babble IRQ
+         * . SOF IRQ (we're not using this one)
+         * . Endpoint 0 IRQ
+         * . TX Endpoints
+         * . RX Endpoints
+         *
+         * We will be following that flowchart in order to avoid any problems
+         * that might arise with internal Finite State Machine.
          */
-        if (musb->int_usb)
-                retval |= musb_stage0_irq(musb, musb->int_usb,
-                                devctl);
 
-        /* "stage 1" is handling endpoint irqs */
+        if (musb->int_usb)
+                retval |= musb_stage0_irq(musb, musb->int_usb, devctl);
 
-        /* handle endpoint 0 first */
         if (musb->int_tx & 1) {
                 if (is_host_active(musb))
                         retval |= musb_h_ep0_irq(musb);
                 else
                         retval |= musb_g_ep0_irq(musb);
+
+                /* we have just handled endpoint 0 IRQ, clear it */
+                musb->int_tx &= ~BIT(0);
         }
 
-        /* RX on endpoints 1-15 */
-        reg = musb->int_rx >> 1;
-        ep_num = 1;
-        while (reg) {
-                if (reg & 1) {
-                        /* musb_ep_select(musb->mregs, ep_num); */
-                        /* REVISIT just retval = ep->rx_irq(...) */
-                        retval = IRQ_HANDLED;
-                        if (is_host_active(musb))
-                                musb_host_rx(musb, ep_num);
-                        else
-                                musb_g_rx(musb, ep_num);
-                }
+        status = musb->int_tx;
 
-                reg >>= 1;
-                ep_num++;
+        for_each_set_bit(epnum, &status, 16) {
+                retval = IRQ_HANDLED;
+                if (is_host_active(musb))
+                        musb_host_tx(musb, epnum);
+                else
+                        musb_g_tx(musb, epnum);
         }
 
-        /* TX on endpoints 1-15 */
-        reg = musb->int_tx >> 1;
-        ep_num = 1;
-        while (reg) {
-                if (reg & 1) {
-                        /* musb_ep_select(musb->mregs, ep_num); */
-                        /* REVISIT just retval |= ep->tx_irq(...) */
-                        retval = IRQ_HANDLED;
-                        if (is_host_active(musb))
-                                musb_host_tx(musb, ep_num);
-                        else
-                                musb_g_tx(musb, ep_num);
-                }
-                reg >>= 1;
-                ep_num++;
+        status = musb->int_rx;
+
+        for_each_set_bit(epnum, &status, 16) {
+                retval = IRQ_HANDLED;
+                if (is_host_active(musb))
+                        musb_host_rx(musb, epnum);
+                else
+                        musb_g_rx(musb, epnum);
         }
 
         return retval;
@@ -1825,33 +1818,44 @@ static void musb_irq_work(struct work_struct *data)
         }
 }
 
-/* Recover from babble interrupt conditions */
-static void musb_recover_work(struct work_struct *data)
+static void musb_recover_from_babble(struct musb *musb)
 {
-        struct musb *musb = container_of(data, struct musb, recover_work.work);
-        int status, ret;
+        int ret;
+        u8 devctl;
 
-        ret  = musb_platform_reset(musb);
-        if (ret)
+        musb_disable_interrupts(musb);
+
+        /*
+         * wait at least 320 cycles of 60MHz clock. That's 5.3us, we will give
+         * it some slack and wait for 10us.
+         */
+        udelay(10);
+
+        ret  = musb_platform_recover(musb);
+        if (ret) {
+                musb_enable_interrupts(musb);
                 return;
+        }
 
-        usb_phy_vbus_off(musb->xceiv);
-        usleep_range(100, 200);
+        /* drop session bit */
+        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
+        devctl &= ~MUSB_DEVCTL_SESSION;
+        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
-        usb_phy_vbus_on(musb->xceiv);
-        usleep_range(100, 200);
+        /* tell usbcore about it */
+        musb_root_disconnect(musb);
 
         /*
          * 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);
+                ret = ep_config_from_table(musb);
         else
-                status = ep_config_from_hw(musb);
+                ret = ep_config_from_hw(musb);
 
-        /* start the session again */
-        if (status == 0)
+        /* restart session */
+        if (ret == 0)
                 musb_start(musb);
 }
 
@@ -2087,7 +2091,6 @@ 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_DELAYED_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);
 
@@ -2183,7 +2186,6 @@ fail4:
 
 fail3:
         cancel_work_sync(&musb->irq_work);
-        cancel_delayed_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)
@@ -2249,7 +2251,6 @@ static int musb_remove(struct platform_device *pdev)
                 dma_controller_destroy(musb->dma_controller);
 
         cancel_work_sync(&musb->irq_work);
-        cancel_delayed_work_sync(&musb->recover_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         musb_free(musb);
@@ -2463,7 +2464,7 @@ static int musb_resume(struct device *dev)
         if (musb->need_finish_resume) {
                 musb->need_finish_resume = 0;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                      msecs_to_jiffies(20));
+                                      msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 
         /*
@@ -2506,7 +2507,7 @@ static int musb_runtime_resume(struct device *dev)
         if (musb->need_finish_resume) {
                 musb->need_finish_resume = 0;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                msecs_to_jiffies(20));
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 
         return 0;
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 5e65958f7915..3877249a8b2d 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -160,7 +160,8 @@ struct musb_io;
  * @init:       turns on clocks, sets up platform-specific registers, etc
  * @exit:       undoes @init
  * @set_mode:   forcefully changes operating mode
- * @try_ilde:   tries to idle the IP
+ * @try_idle:   tries to idle the IP
+ * @recover:    platform-specific babble recovery
  * @vbus_status: returns vbus status if possible
  * @set_vbus:   forces vbus status
  * @adjust_channel_params: pre check for standard dma channel_program func
@@ -196,7 +197,7 @@ struct musb_platform_ops {
         void    (*write_fifo)(struct musb_hw_ep *hw_ep, u16 len, const u8 *buf);
         int     (*set_mode)(struct musb *musb, u8 mode);
         void    (*try_idle)(struct musb *musb, unsigned long timeout);
-        int     (*reset)(struct musb *musb);
+        int     (*recover)(struct musb *musb);
 
         int     (*vbus_status)(struct musb *musb);
         void    (*set_vbus)(struct musb *musb, int on);
@@ -300,7 +301,6 @@ struct musb {
 
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
-        struct delayed_work     recover_work;
         struct delayed_work     deassert_reset_work;
         struct delayed_work     finish_resume_work;
         u16                     hwvers;
@@ -558,12 +558,12 @@ static inline void musb_platform_try_idle(struct musb *musb,
                 musb->ops->try_idle(musb, timeout);
 }
 
-static inline int  musb_platform_reset(struct musb *musb)
+static inline int  musb_platform_recover(struct musb *musb)
 {
-        if (!musb->ops->reset)
-                return -EINVAL;
+        if (!musb->ops->recover)
+                return 0;
 
-        return musb->ops->reset(musb);
+        return musb->ops->recover(musb);
 }
 
 static inline int musb_platform_get_vbus_status(struct musb *musb)
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index be84562d021b..8bd8c5e26921 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -225,10 +225,12 @@ static void cppi41_dma_callback(void *private_data)
         struct dma_channel *channel = private_data;
         struct cppi41_dma_channel *cppi41_channel = channel->private_data;
         struct musb_hw_ep *hw_ep = cppi41_channel->hw_ep;
+        struct cppi41_dma_controller *controller;
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
         struct dma_tx_state txstate;
         u32 transferred;
+        int is_hs = 0;
         bool empty;
 
         spin_lock_irqsave(&musb->lock, flags);
@@ -248,61 +250,59 @@ static void cppi41_dma_callback(void *private_data)
                         transferred < cppi41_channel->packet_sz)
                 cppi41_channel->prog_len = 0;
 
-        empty = musb_is_tx_fifo_empty(hw_ep);
-        if (empty) {
+        if (cppi41_channel->is_tx)
+                empty = musb_is_tx_fifo_empty(hw_ep);
+
+        if (!cppi41_channel->is_tx || empty) {
                 cppi41_trans_done(cppi41_channel);
-        } else {
-                struct cppi41_dma_controller *controller;
-                int is_hs = 0;
-                /*
-                 * On AM335x it has been observed that the TX interrupt fires
-                 * too early that means the TXFIFO is not yet empty but the DMA
-                 * engine says that it is done with the transfer. We don't
-                 * receive a FIFO empty interrupt so the only thing we can do is
-                 * to poll for the bit. On HS it usually takes 2us, on FS around
-                 * 110us - 150us depending on the transfer size.
-                 * We spin on HS (no longer than than 25us and setup a timer on
-                 * FS to check for the bit and complete the transfer.
-                 */
-                controller = cppi41_channel->controller;
+                goto out;
+        }
 
-                if (is_host_active(musb)) {
-                        if (musb->port1_status & USB_PORT_STAT_HIGH_SPEED)
-                                is_hs = 1;
-                } else {
-                        if (musb->g.speed == USB_SPEED_HIGH)
-                                is_hs = 1;
-                }
-                if (is_hs) {
-                        unsigned wait = 25;
-
-                        do {
-                                empty = musb_is_tx_fifo_empty(hw_ep);
-                                if (empty)
-                                        break;
-                                wait--;
-                                if (!wait)
-                                        break;
-                                udelay(1);
-                        } while (1);
+        /*
+         * On AM335x it has been observed that the TX interrupt fires
+         * too early that means the TXFIFO is not yet empty but the DMA
+         * engine says that it is done with the transfer. We don't
+         * receive a FIFO empty interrupt so the only thing we can do is
+         * to poll for the bit. On HS it usually takes 2us, on FS around
+         * 110us - 150us depending on the transfer size.
+         * We spin on HS (no longer than than 25us and setup a timer on
+         * FS to check for the bit and complete the transfer.
+         */
+        controller = cppi41_channel->controller;
+
+        if (is_host_active(musb)) {
+                if (musb->port1_status & USB_PORT_STAT_HIGH_SPEED)
+                        is_hs = 1;
+        } else {
+                if (musb->g.speed == USB_SPEED_HIGH)
+                        is_hs = 1;
+        }
+        if (is_hs) {
+                unsigned wait = 25;
 
+                do {
                         empty = musb_is_tx_fifo_empty(hw_ep);
                         if (empty) {
                                 cppi41_trans_done(cppi41_channel);
                                 goto out;
                         }
-                }
-                list_add_tail(&cppi41_channel->tx_check,
-                                &controller->early_tx_list);
-                if (!hrtimer_is_queued(&controller->early_tx)) {
-                        unsigned long usecs = cppi41_channel->total_len / 10;
+                        wait--;
+                        if (!wait)
+                                break;
+                        cpu_relax();
+                } while (1);
+        }
+        list_add_tail(&cppi41_channel->tx_check,
+                        &controller->early_tx_list);
+        if (!hrtimer_is_queued(&controller->early_tx)) {
+                unsigned long usecs = cppi41_channel->total_len / 10;
 
-                        hrtimer_start_range_ns(&controller->early_tx,
+                hrtimer_start_range_ns(&controller->early_tx,
                                 ktime_set(0, usecs * NSEC_PER_USEC),
                                 20 * NSEC_PER_USEC,
                                 HRTIMER_MODE_REL);
-                }
         }
+
 out:
         spin_unlock_irqrestore(&musb->lock, flags);
 }
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index a900c9877195..65d931a28a14 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -119,7 +119,7 @@ struct dsps_musb_wrapper {
         unsigned        iddig:5;
         unsigned        iddig_mux:5;
         /* miscellaneous stuff */
-        u8              poll_seconds;
+        unsigned        poll_timeout;
 };
 
 /*
@@ -225,9 +225,8 @@ static void dsps_musb_enable(struct musb *musb)
 
         dsps_writel(reg_base, wrp->epintr_set, epmask);
         dsps_writel(reg_base, wrp->coreintr_set, coremask);
-        /* Force the DRVVBUS IRQ so we can start polling for ID change. */
-        dsps_writel(reg_base, wrp->coreintr_set,
-                    (1 << wrp->drvvbus) << wrp->usb_shift);
+        /* start polling for ID change. */
+        mod_timer(&glue->timer, jiffies + msecs_to_jiffies(wrp->poll_timeout));
         dsps_musb_try_idle(musb, 0);
 }
 
@@ -285,7 +284,8 @@ static void otg_timer(unsigned long _musb)
                 }
                 if (!(devctl & MUSB_DEVCTL_SESSION) && !skip_session)
                         dsps_writeb(mregs, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
-                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
+                mod_timer(&glue->timer, jiffies +
+                                msecs_to_jiffies(wrp->poll_timeout));
                 break;
         case OTG_STATE_A_WAIT_VFALL:
                 musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
@@ -330,28 +330,6 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
 
         dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n",
                         usbintr, epintr);
-        /*
-         * DRVVBUS IRQs are the only proxy we have (a very poor one!) for
-         * DSPS IP's missing ID change IRQ.  We need an ID change IRQ to
-         * switch appropriately between halves of the OTG state machine.
-         * Managing DEVCTL.SESSION per Mentor docs requires that we know its
-         * 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) {
-                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);
@@ -374,8 +352,8 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                          */
                         musb->int_usb &= ~MUSB_INTR_VBUSERROR;
                         musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
-                        mod_timer(&glue->timer,
-                                        jiffies + wrp->poll_seconds * HZ);
+                        mod_timer(&glue->timer, jiffies +
+                                        msecs_to_jiffies(wrp->poll_timeout));
                         WARNING("VBUS error workaround (delay coming)\n");
                 } else if (drvvbus) {
                         MUSB_HST_MODE(musb);
@@ -404,7 +382,8 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
         /* Poll for ID change in OTG port mode */
         if (musb->xceiv->otg->state == OTG_STATE_B_IDLE &&
                         musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE)
-                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
+                mod_timer(&glue->timer, jiffies +
+                                msecs_to_jiffies(wrp->poll_timeout));
 out:
         spin_unlock_irqrestore(&musb->lock, flags);
 
@@ -453,7 +432,7 @@ static int dsps_musb_init(struct musb *musb)
         musb->ctrl_base = reg_base;
 
         /* NOP driver needs change if supporting dual instance */
-        musb->xceiv = devm_usb_get_phy_by_phandle(dev, "phys", 0);
+        musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "phys", 0);
         if (IS_ERR(musb->xceiv))
                 return PTR_ERR(musb->xceiv);
 
@@ -497,7 +476,7 @@ static int dsps_musb_init(struct musb *musb)
          * logic enabled.
          */
         val = dsps_readb(musb->mregs, MUSB_BABBLE_CTL);
-        if (val == MUSB_BABBLE_RCV_DISABLE) {
+        if (val & MUSB_BABBLE_RCV_DISABLE) {
                 glue->sw_babble_enabled = true;
                 val |= MUSB_BABBLE_SW_SESSION_CTRL;
                 dsps_writeb(musb->mregs, MUSB_BABBLE_CTL, val);
@@ -571,7 +550,7 @@ static int dsps_musb_set_mode(struct musb *musb, u8 mode)
         return 0;
 }
 
-static bool  sw_babble_control(struct musb *musb)
+static bool dsps_sw_babble_control(struct musb *musb)
 {
         u8 babble_ctl;
         bool session_restart =  false;
@@ -622,37 +601,36 @@ static bool  sw_babble_control(struct musb *musb)
         return session_restart;
 }
 
-static int dsps_musb_reset(struct musb *musb)
+static int dsps_musb_recover(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;
-        int session_restart = 0, error;
+        int session_restart = 0;
 
         if (glue->sw_babble_enabled)
-                session_restart = sw_babble_control(musb);
-        /*
-         * In case of new silicon version babble condition can be recovered
-         * without resetting the MUSB. But for older silicon versions, MUSB
-         * reset is needed
-         */
-        if (session_restart || !glue->sw_babble_enabled) {
-                dev_info(musb->controller, "Restarting MUSB to recover from Babble\n");
-                dsps_writel(musb->ctrl_base, wrp->control, (1 << wrp->reset));
-                usleep_range(100, 200);
-                usb_phy_shutdown(musb->xceiv);
-                error = phy_power_off(musb->phy);
-                if (error)
-                        dev_err(dev, "phy shutdown failed: %i\n", error);
-                usleep_range(100, 200);
-                usb_phy_init(musb->xceiv);
-                error = phy_power_on(musb->phy);
-                if (error)
-                        dev_err(dev, "phy powerup failed: %i\n", error);
+                session_restart = dsps_sw_babble_control(musb);
+        else
                 session_restart = 1;
+
+        return session_restart ? 0 : -EPIPE;
+}
+
+/* Similar to am35x, dm81xx support only 32-bit read operation */
+static void dsps_read_fifo32(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
+{
+        void __iomem *fifo = hw_ep->fifo;
+
+        if (len >= 4) {
+                ioread32_rep(fifo, dst, len >> 2);
+                dst += len & ~0x03;
+                len &= 0x03;
         }
 
-        return !session_restart;
+        /* Read any remaining 1 to 3 bytes */
+        if (len > 0) {
+                u32 val = musb_readl(fifo, 0);
+                memcpy(dst, &val, len);
+        }
 }
 
 static struct musb_platform_ops dsps_ops = {
@@ -665,7 +643,7 @@ static struct musb_platform_ops dsps_ops = {
 
         .try_idle       = dsps_musb_try_idle,
         .set_mode       = dsps_musb_set_mode,
-        .reset          = dsps_musb_reset,
+        .recover        = dsps_musb_recover,
 };
 
 static u64 musb_dmamask = DMA_BIT_MASK(32);
@@ -737,7 +715,6 @@ static int dsps_create_musb_pdev(struct dsps_glue *glue,
         musb->dev.parent                = dev;
         musb->dev.dma_mask              = &musb_dmamask;
         musb->dev.coherent_dma_mask     = musb_dmamask;
-        musb->dev.of_node               = of_node_get(dn);
 
         glue->musb = musb;
 
@@ -802,6 +779,9 @@ static int dsps_probe(struct platform_device *pdev)
         }
         wrp = match->data;
 
+        if (of_device_is_compatible(pdev->dev.of_node, "ti,musb-dm816"))
+                dsps_ops.read_fifo = dsps_read_fifo32;
+
         /* allocate glue */
         glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
         if (!glue)
@@ -873,12 +853,14 @@ static const struct dsps_musb_wrapper am33xx_driver_data = {
         .rxep_shift             = 16,
         .rxep_mask              = 0xfffe,
         .rxep_bitmap            = (0xfffe << 16),
-        .poll_seconds           = 2,
+        .poll_timeout           = 2000, /* ms */
 };
 
 static const struct of_device_id musb_dsps_of_match[] = {
         { .compatible = "ti,musb-am33xx",
-                .data = (void *) &am33xx_driver_data, },
+                .data = &am33xx_driver_data, },
+        { .compatible = "ti,musb-dm816",
+                .data = &am33xx_driver_data, },
         {  },
 };
 MODULE_DEVICE_TABLE(of, musb_dsps_of_match);
@@ -929,7 +911,8 @@ static int dsps_resume(struct device *dev)
         dsps_writel(mbase, wrp->rx_mode, glue->context.rx_mode);
         if (musb->xceiv->otg->state == OTG_STATE_B_IDLE &&
             musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE)
-                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
+                mod_timer(&glue->timer, jiffies +
+                                msecs_to_jiffies(wrp->poll_timeout));
 
         return 0;
 }
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index b2d9040c7685..4c481cd66c77 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1876,44 +1876,6 @@ err:
         return retval;
 }
 
-static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
-{
-        int                     i;
-        struct musb_hw_ep       *hw_ep;
-
-        /* don't disconnect if it's not connected */
-        if (musb->g.speed == USB_SPEED_UNKNOWN)
-                driver = NULL;
-        else
-                musb->g.speed = USB_SPEED_UNKNOWN;
-
-        /* deactivate the hardware */
-        if (musb->softconnect) {
-                musb->softconnect = 0;
-                musb_pullup(musb, 0);
-        }
-        musb_stop(musb);
-
-        /* killing any outstanding requests will quiesce the driver;
-         * then report disconnect
-         */
-        if (driver) {
-                for (i = 0, hw_ep = musb->endpoints;
-                                i < musb->nr_endpoints;
-                                i++, hw_ep++) {
-                        musb_ep_select(musb->mregs, i);
-                        if (hw_ep->is_shared_fifo /* || !epnum */) {
-                                nuke(&hw_ep->ep_in, -ESHUTDOWN);
-                        } else {
-                                if (hw_ep->max_packet_sz_tx)
-                                        nuke(&hw_ep->ep_in, -ESHUTDOWN);
-                                if (hw_ep->max_packet_sz_rx)
-                                        nuke(&hw_ep->ep_out, -ESHUTDOWN);
-                        }
-                }
-        }
-}
-
 /*
  * Unregister the gadget driver. Used by gadget drivers when
  * unregistering themselves from the controller.
@@ -1940,7 +1902,7 @@ static int musb_gadget_stop(struct usb_gadget *g)
         (void) musb_gadget_vbus_draw(&musb->g, 0);
 
         musb->xceiv->otg->state = OTG_STATE_UNDEFINED;
-        stop_activity(musb, NULL);
+        musb_stop(musb);
         otg_set_peripheral(musb->xceiv->otg, NULL);
 
         musb->is_active = 0;
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 294e159f4afe..86c4b533e90b 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -136,7 +136,7 @@ void musb_port_suspend(struct musb *musb, bool do_suspend)
                 /* later, GetPortStatus will stop RESUME signaling */
                 musb->port1_status |= MUSB_PORT_STAT_RESUME;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                      msecs_to_jiffies(20));
+                                      msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 }
 
@@ -345,7 +345,7 @@ int musb_hub_control(
                 struct usb_hub_descriptor *desc = (void *)buf;
 
                 desc->bDescLength = 9;
-                desc->bDescriptorType = 0x29;
+                desc->bDescriptorType = USB_DT_HUB;
                 desc->bNbrPorts = 1;
                 desc->wHubCharacteristics = cpu_to_le16(
                         HUB_CHAR_INDV_PORT_LPSM /* per-port power switching */
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index 52d3d58252e1..2175678e674e 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -139,7 +139,7 @@ config USB_ISP1301
 
 config USB_MSM_OTG
         tristate "Qualcomm on-chip USB OTG controller support"
-        depends on (USB || USB_GADGET) && (ARCH_MSM || ARCH_QCOM || COMPILE_TEST)
+        depends on (USB || USB_GADGET) && (ARCH_QCOM || COMPILE_TEST)
         depends on RESET_CONTROLLER
         select USB_PHY
         help
@@ -202,13 +202,13 @@ config USB_RCAR_GEN2_PHY
 config USB_ULPI
         bool "Generic ULPI Transceiver Driver"
         depends on ARM || ARM64
+        select USB_ULPI_VIEWPORT
         help
           Enable this to support ULPI connected USB OTG transceivers which
           are likely found on embedded boards.
 
 config USB_ULPI_VIEWPORT
         bool
-        depends on USB_ULPI
         help
           Provides read/write operations to the ULPI phy register set for
           controllers with a viewport register (e.g. Chipidea/ARC controllers).
diff --git a/drivers/usb/phy/of.c b/drivers/usb/phy/of.c
index 7ea0154da9d5..66ffa82457a8 100644
--- a/drivers/usb/phy/of.c
+++ b/drivers/usb/phy/of.c
@@ -27,7 +27,7 @@ static const char *const usbphy_modes[] = {
  * @np: Pointer to the given device_node
  *
  * The function gets phy interface string from property 'phy_type',
- * and returns the correspondig enum usb_phy_interface
+ * and returns the corresponding enum usb_phy_interface
  */
 enum usb_phy_interface of_usb_get_phy_mode(struct device_node *np)
 {
diff --git a/drivers/usb/phy/phy-ab8500-usb.c b/drivers/usb/phy/phy-ab8500-usb.c
index 0b1bd2369293..7225d526df04 100644
--- a/drivers/usb/phy/phy-ab8500-usb.c
+++ b/drivers/usb/phy/phy-ab8500-usb.c
@@ -277,7 +277,7 @@ static void ab8500_usb_regulator_enable(struct ab8500_usb *ab)
                         dev_err(ab->dev, "Failed to set the Vintcore to 1.3V, ret=%d\n",
                                         ret);
 
-                ret = regulator_set_optimum_mode(ab->v_ulpi, 28000);
+                ret = regulator_set_load(ab->v_ulpi, 28000);
                 if (ret < 0)
                         dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
                                         ret);
@@ -317,7 +317,7 @@ static void ab8500_usb_regulator_disable(struct ab8500_usb *ab)
                                                 ab->saved_v_ulpi, ret);
                 }
 
-                ret = regulator_set_optimum_mode(ab->v_ulpi, 0);
+                ret = regulator_set_load(ab->v_ulpi, 0);
                 if (ret < 0)
                         dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
                                         ret);
@@ -893,7 +893,7 @@ static int abx500_usb_link_status_update(struct ab8500_usb *ab)
 
 /*
  * Disconnection Sequence:
- *   1. Disconect Interrupt
+ *   1. Disconnect Interrupt
  *   2. Disable regulators
  *   3. Disable AB clock
  *   4. Disable the Phy
diff --git a/drivers/usb/phy/phy-am335x-control.c b/drivers/usb/phy/phy-am335x-control.c
index 403fab772724..7b3035ff9434 100644
--- a/drivers/usb/phy/phy-am335x-control.c
+++ b/drivers/usb/phy/phy-am335x-control.c
@@ -126,6 +126,9 @@ struct phy_control *am335x_get_phy_control(struct device *dev)
                 return NULL;
 
         dev = bus_find_device(&platform_bus_type, NULL, node, match);
+        if (!dev)
+                return NULL;
+
         ctrl_usb = dev_get_drvdata(dev);
         if (!ctrl_usb)
                 return NULL;
diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c
index 70be50b734b2..deee68eafb72 100644
--- a/drivers/usb/phy/phy-generic.c
+++ b/drivers/usb/phy/phy-generic.c
@@ -62,14 +62,14 @@ static int nop_set_suspend(struct usb_phy *x, int suspend)
         return 0;
 }
 
-static void nop_reset_set(struct usb_phy_generic *nop, int asserted)
+static void nop_reset(struct usb_phy_generic *nop)
 {
         if (!nop->gpiod_reset)
                 return;
 
-        gpiod_direction_output(nop->gpiod_reset, !asserted);
+        gpiod_set_value(nop->gpiod_reset, 1);
         usleep_range(10000, 20000);
-        gpiod_set_value(nop->gpiod_reset, asserted);
+        gpiod_set_value(nop->gpiod_reset, 0);
 }
 
 /* interface to regulator framework */
@@ -151,8 +151,7 @@ int usb_gen_phy_init(struct usb_phy *phy)
         if (!IS_ERR(nop->clk))
                 clk_prepare_enable(nop->clk);
 
-        /* De-assert RESET */
-        nop_reset_set(nop, 0);
+        nop_reset(nop);
 
         return 0;
 }
@@ -162,8 +161,7 @@ void usb_gen_phy_shutdown(struct usb_phy *phy)
 {
         struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 
-        /* Assert RESET */
-        nop_reset_set(nop, 1);
+        gpiod_set_value(nop->gpiod_reset, 1);
 
         if (!IS_ERR(nop->clk))
                 clk_disable_unprepare(nop->clk);
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index 000fd892455f..c9156beeadef 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -142,27 +142,22 @@ static int msm_hsusb_ldo_set_mode(struct msm_otg *motg, int on)
         int ret = 0;
 
         if (on) {
-                ret = regulator_set_optimum_mode(motg->v1p8,
-                                USB_PHY_1P8_HPM_LOAD);
+                ret = regulator_set_load(motg->v1p8, USB_PHY_1P8_HPM_LOAD);
                 if (ret < 0) {
                         pr_err("Could not set HPM for v1p8\n");
                         return ret;
                 }
-                ret = regulator_set_optimum_mode(motg->v3p3,
-                                USB_PHY_3P3_HPM_LOAD);
+                ret = regulator_set_load(motg->v3p3, USB_PHY_3P3_HPM_LOAD);
                 if (ret < 0) {
                         pr_err("Could not set HPM for v3p3\n");
-                        regulator_set_optimum_mode(motg->v1p8,
-                                USB_PHY_1P8_LPM_LOAD);
+                        regulator_set_load(motg->v1p8, USB_PHY_1P8_LPM_LOAD);
                         return ret;
                 }
         } else {
-                ret = regulator_set_optimum_mode(motg->v1p8,
-                                USB_PHY_1P8_LPM_LOAD);
+                ret = regulator_set_load(motg->v1p8, USB_PHY_1P8_LPM_LOAD);
                 if (ret < 0)
                         pr_err("Could not set LPM for v1p8\n");
-                ret = regulator_set_optimum_mode(motg->v3p3,
-                                USB_PHY_3P3_LPM_LOAD);
+                ret = regulator_set_load(motg->v3p3, USB_PHY_3P3_LPM_LOAD);
                 if (ret < 0)
                         pr_err("Could not set LPM for v3p3\n");
         }
@@ -263,9 +258,7 @@ static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
 {
         int ret;
 
-        if (motg->pdata->link_clk_reset)
-                ret = motg->pdata->link_clk_reset(motg->clk, assert);
-        else if (assert)
+        if (assert)
                 ret = reset_control_assert(motg->link_rst);
         else
                 ret = reset_control_deassert(motg->link_rst);
@@ -281,9 +274,7 @@ static int msm_otg_phy_clk_reset(struct msm_otg *motg)
 {
         int ret = 0;
 
-        if (motg->pdata->phy_clk_reset)
-                ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
-        else if (motg->phy_rst)
+        if (motg->phy_rst)
                 ret = reset_control_reset(motg->phy_rst);
 
         if (ret)
@@ -1551,16 +1542,6 @@ static int msm_otg_probe(struct platform_device *pdev)
         phy = &motg->phy;
         phy->dev = &pdev->dev;
 
-        if (motg->pdata->phy_clk_reset) {
-                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");
-                        return PTR_ERR(motg->phy_reset_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");
diff --git a/drivers/usb/phy/phy-rcar-gen2-usb.c b/drivers/usb/phy/phy-rcar-gen2-usb.c
index f83808413ba2..f81800b6562a 100644
--- a/drivers/usb/phy/phy-rcar-gen2-usb.c
+++ b/drivers/usb/phy/phy-rcar-gen2-usb.c
@@ -47,7 +47,7 @@ struct rcar_gen2_usb_phy_priv {
 
 /* USB General status register */
 #define USBHS_UGSTS_REG                 0x88
-#define USBHS_UGSTS_LOCK                (3 << 8)
+#define USBHS_UGSTS_LOCK                (1 << 8)
 
 /* Enable USBHS internal phy */
 static int __rcar_gen2_usbhs_phy_enable(void __iomem *base)
diff --git a/drivers/usb/phy/phy.c b/drivers/usb/phy/phy.c
index 2f9735b35338..d1cd6b50f520 100644
--- a/drivers/usb/phy/phy.c
+++ b/drivers/usb/phy/phy.c
@@ -81,7 +81,9 @@ static void devm_usb_phy_release(struct device *dev, void *res)
 
 static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
 {
-        return res == match_data;
+        struct usb_phy **phy = res;
+
+        return *phy == match_data;
 }
 
 /**
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
index 4cf77d3c3bd2..0f7e850fd4aa 100644
--- a/drivers/usb/renesas_usbhs/common.c
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -276,6 +276,16 @@ int usbhs_set_device_config(struct usbhs_priv *priv, int devnum,
 }
 
 /*
+ *              interrupt functions
+ */
+void usbhs_xxxsts_clear(struct usbhs_priv *priv, u16 sts_reg, u16 bit)
+{
+        u16 pipe_mask = (u16)GENMASK(usbhs_get_dparam(priv, pipe_size), 0);
+
+        usbhs_write(priv, sts_reg, ~(1 << bit) & pipe_mask);
+}
+
+/*
  *              local functions
  */
 static void usbhsc_set_buswait(struct usbhs_priv *priv)
@@ -487,6 +497,15 @@ static struct renesas_usbhs_platform_info *usbhs_parse_dt(struct device *dev)
         if (gpio > 0)
                 dparam->enable_gpio = gpio;
 
+        switch (dparam->type) {
+        case USBHS_TYPE_R8A7790:
+        case USBHS_TYPE_R8A7791:
+                dparam->has_usb_dmac = 1;
+                break;
+        default:
+                break;
+        }
+
         return info;
 }
 
diff --git a/drivers/usb/renesas_usbhs/common.h b/drivers/usb/renesas_usbhs/common.h
index fc96e924edc4..8c5fc12ad778 100644
--- a/drivers/usb/renesas_usbhs/common.h
+++ b/drivers/usb/renesas_usbhs/common.h
@@ -193,6 +193,7 @@ struct usbhs_priv;
 #define TYPE_BULK       (1 << 14)
 #define TYPE_INT        (2 << 14)
 #define TYPE_ISO        (3 << 14)
+#define BFRE            (1 << 10)       /* BRDY Interrupt Operation Spec. */
 #define DBLB            (1 << 9)        /* Double Buffer Mode */
 #define SHTNAK          (1 << 7)        /* Pipe Disable in Transfer End */
 #define DIR_OUT         (1 << 4)        /* Transfer Direction */
@@ -216,6 +217,7 @@ struct usbhs_priv;
 #define ACLRM           (1 << 9)        /* Buffer Auto-Clear Mode */
 #define SQCLR           (1 << 8)        /* Toggle Bit Clear */
 #define SQSET           (1 << 7)        /* Toggle Bit Set */
+#define SQMON           (1 << 6)        /* Toggle Bit Check */
 #define PBUSY           (1 << 5)        /* Pipe Busy */
 #define PID_MASK        (0x3)           /* Response PID */
 #define  PID_NAK        0
@@ -324,6 +326,11 @@ int usbhs_set_device_config(struct usbhs_priv *priv, int devnum, u16 upphub,
                            u16 hubport, u16 speed);
 
 /*
+ * interrupt functions
+ */
+void usbhs_xxxsts_clear(struct usbhs_priv *priv, u16 sts_reg, u16 bit);
+
+/*
  * data
  */
 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev);
diff --git a/drivers/usb/renesas_usbhs/fifo.c b/drivers/usb/renesas_usbhs/fifo.c
index d891bff39d66..8597cf9cfceb 100644
--- a/drivers/usb/renesas_usbhs/fifo.c
+++ b/drivers/usb/renesas_usbhs/fifo.c
@@ -813,7 +813,8 @@ static void xfer_work(struct work_struct *work)
         desc->callback          = usbhsf_dma_complete;
         desc->callback_param    = pipe;
 
-        if (dmaengine_submit(desc) < 0) {
+        pkt->cookie = dmaengine_submit(desc);
+        if (pkt->cookie < 0) {
                 dev_err(dev, "Failed to submit dma descriptor\n");
                 return;
         }
@@ -822,10 +823,10 @@ static void xfer_work(struct work_struct *work)
                 fifo->name, usbhs_pipe_number(pipe), pkt->length, pkt->zero);
 
         usbhs_pipe_running(pipe, 1);
-        usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->trans);
-        usbhs_pipe_enable(pipe);
         usbhsf_dma_start(pipe, fifo);
+        usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->trans);
         dma_async_issue_pending(chan);
+        usbhs_pipe_enable(pipe);
 }
 
 /*
@@ -838,6 +839,7 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
         struct usbhs_fifo *fifo;
         int len = pkt->length - pkt->actual;
         int ret;
+        uintptr_t align_mask;
 
         if (usbhs_pipe_is_busy(pipe))
                 return 0;
@@ -847,10 +849,14 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
             usbhs_pipe_is_dcp(pipe))
                 goto usbhsf_pio_prepare_push;
 
-        if (len & 0x7) /* 8byte alignment */
+        /* check data length if this driver don't use USB-DMAC */
+        if (!usbhs_get_dparam(priv, has_usb_dmac) && len & 0x7)
                 goto usbhsf_pio_prepare_push;
 
-        if ((uintptr_t)(pkt->buf + pkt->actual) & 0x7) /* 8byte alignment */
+        /* check buffer alignment */
+        align_mask = usbhs_get_dparam(priv, has_usb_dmac) ?
+                                        USBHS_USB_DMAC_XFER_SIZE - 1 : 0x7;
+        if ((uintptr_t)(pkt->buf + pkt->actual) & align_mask)
                 goto usbhsf_pio_prepare_push;
 
         /* return at this time if the pipe is running */
@@ -924,7 +930,85 @@ struct usbhs_pkt_handle usbhs_fifo_dma_push_handler = {
 /*
  *              DMA pop handler
  */
-static int usbhsf_dma_try_pop(struct usbhs_pkt *pkt, int *is_done)
+
+static int usbhsf_dma_prepare_pop_with_rx_irq(struct usbhs_pkt *pkt,
+                                              int *is_done)
+{
+        return usbhsf_prepare_pop(pkt, is_done);
+}
+
+static int usbhsf_dma_prepare_pop_with_usb_dmac(struct usbhs_pkt *pkt,
+                                                int *is_done)
+{
+        struct usbhs_pipe *pipe = pkt->pipe;
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+        struct usbhs_fifo *fifo;
+        int ret;
+
+        if (usbhs_pipe_is_busy(pipe))
+                return 0;
+
+        /* use PIO if packet is less than pio_dma_border or pipe is DCP */
+        if ((pkt->length < usbhs_get_dparam(priv, pio_dma_border)) ||
+            usbhs_pipe_is_dcp(pipe))
+                goto usbhsf_pio_prepare_pop;
+
+        fifo = usbhsf_get_dma_fifo(priv, pkt);
+        if (!fifo)
+                goto usbhsf_pio_prepare_pop;
+
+        if ((uintptr_t)pkt->buf & (USBHS_USB_DMAC_XFER_SIZE - 1))
+                goto usbhsf_pio_prepare_pop;
+
+        usbhs_pipe_config_change_bfre(pipe, 1);
+
+        ret = usbhsf_fifo_select(pipe, fifo, 0);
+        if (ret < 0)
+                goto usbhsf_pio_prepare_pop;
+
+        if (usbhsf_dma_map(pkt) < 0)
+                goto usbhsf_pio_prepare_pop_unselect;
+
+        /* DMA */
+
+        /*
+         * usbhs_fifo_dma_pop_handler :: prepare
+         * enabled irq to come here.
+         * but it is no longer needed for DMA. disable it.
+         */
+        usbhsf_rx_irq_ctrl(pipe, 0);
+
+        pkt->trans = pkt->length;
+
+        INIT_WORK(&pkt->work, xfer_work);
+        schedule_work(&pkt->work);
+
+        return 0;
+
+usbhsf_pio_prepare_pop_unselect:
+        usbhsf_fifo_unselect(pipe, fifo);
+usbhsf_pio_prepare_pop:
+
+        /*
+         * change handler to PIO
+         */
+        pkt->handler = &usbhs_fifo_pio_pop_handler;
+        usbhs_pipe_config_change_bfre(pipe, 0);
+
+        return pkt->handler->prepare(pkt, is_done);
+}
+
+static int usbhsf_dma_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
+{
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
+
+        if (usbhs_get_dparam(priv, has_usb_dmac))
+                return usbhsf_dma_prepare_pop_with_usb_dmac(pkt, is_done);
+        else
+                return usbhsf_dma_prepare_pop_with_rx_irq(pkt, is_done);
+}
+
+static int usbhsf_dma_try_pop_with_rx_irq(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
@@ -993,7 +1077,16 @@ usbhsf_pio_prepare_pop:
         return pkt->handler->try_run(pkt, is_done);
 }
 
-static int usbhsf_dma_pop_done(struct usbhs_pkt *pkt, int *is_done)
+static int usbhsf_dma_try_pop(struct usbhs_pkt *pkt, int *is_done)
+{
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
+
+        BUG_ON(usbhs_get_dparam(priv, has_usb_dmac));
+
+        return usbhsf_dma_try_pop_with_rx_irq(pkt, is_done);
+}
+
+static int usbhsf_dma_pop_done_with_rx_irq(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
         int maxp = usbhs_pipe_get_maxpacket(pipe);
@@ -1017,8 +1110,68 @@ static int usbhsf_dma_pop_done(struct usbhs_pkt *pkt, int *is_done)
         return 0;
 }
 
+static size_t usbhs_dma_calc_received_size(struct usbhs_pkt *pkt,
+                                           struct dma_chan *chan, int dtln)
+{
+        struct usbhs_pipe *pipe = pkt->pipe;
+        struct dma_tx_state state;
+        size_t received_size;
+        int maxp = usbhs_pipe_get_maxpacket(pipe);
+
+        dmaengine_tx_status(chan, pkt->cookie, &state);
+        received_size = pkt->length - state.residue;
+
+        if (dtln) {
+                received_size -= USBHS_USB_DMAC_XFER_SIZE;
+                received_size &= ~(maxp - 1);
+                received_size += dtln;
+        }
+
+        return received_size;
+}
+
+static int usbhsf_dma_pop_done_with_usb_dmac(struct usbhs_pkt *pkt,
+                                             int *is_done)
+{
+        struct usbhs_pipe *pipe = pkt->pipe;
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+        struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
+        struct dma_chan *chan = usbhsf_dma_chan_get(fifo, pkt);
+        int rcv_len;
+
+        /*
+         * Since the driver disables rx_irq in DMA mode, the interrupt handler
+         * cannot the BRDYSTS. So, the function clears it here because the
+         * driver may use PIO mode next time.
+         */
+        usbhs_xxxsts_clear(priv, BRDYSTS, usbhs_pipe_number(pipe));
+
+        rcv_len = usbhsf_fifo_rcv_len(priv, fifo);
+        usbhsf_fifo_clear(pipe, fifo);
+        pkt->actual = usbhs_dma_calc_received_size(pkt, chan, rcv_len);
+
+        usbhsf_dma_stop(pipe, fifo);
+        usbhsf_dma_unmap(pkt);
+        usbhsf_fifo_unselect(pipe, pipe->fifo);
+
+        /* The driver can assume the rx transaction is always "done" */
+        *is_done = 1;
+
+        return 0;
+}
+
+static int usbhsf_dma_pop_done(struct usbhs_pkt *pkt, int *is_done)
+{
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
+
+        if (usbhs_get_dparam(priv, has_usb_dmac))
+                return usbhsf_dma_pop_done_with_usb_dmac(pkt, is_done);
+        else
+                return usbhsf_dma_pop_done_with_rx_irq(pkt, is_done);
+}
+
 struct usbhs_pkt_handle usbhs_fifo_dma_pop_handler = {
-        .prepare        = usbhsf_prepare_pop,
+        .prepare        = usbhsf_dma_prepare_pop,
         .try_run        = usbhsf_dma_try_pop,
         .dma_done       = usbhsf_dma_pop_done
 };
@@ -1069,23 +1222,29 @@ static void usbhsf_dma_init_pdev(struct usbhs_fifo *fifo)
                                             &fifo->rx_slave);
 }
 
-static void usbhsf_dma_init_dt(struct device *dev, struct usbhs_fifo *fifo)
+static void usbhsf_dma_init_dt(struct device *dev, struct usbhs_fifo *fifo,
+                               int channel)
 {
-        fifo->tx_chan = dma_request_slave_channel_reason(dev, "tx");
+        char name[16];
+
+        snprintf(name, sizeof(name), "tx%d", channel);
+        fifo->tx_chan = dma_request_slave_channel_reason(dev, name);
         if (IS_ERR(fifo->tx_chan))
                 fifo->tx_chan = NULL;
-        fifo->rx_chan = dma_request_slave_channel_reason(dev, "rx");
+
+        snprintf(name, sizeof(name), "rx%d", channel);
+        fifo->rx_chan = dma_request_slave_channel_reason(dev, name);
         if (IS_ERR(fifo->rx_chan))
                 fifo->rx_chan = NULL;
 }
 
-static void usbhsf_dma_init(struct usbhs_priv *priv,
-                            struct usbhs_fifo *fifo)
+static void usbhsf_dma_init(struct usbhs_priv *priv, struct usbhs_fifo *fifo,
+                            int channel)
 {
         struct device *dev = usbhs_priv_to_dev(priv);
 
         if (dev->of_node)
-                usbhsf_dma_init_dt(dev, fifo);
+                usbhsf_dma_init_dt(dev, fifo, channel);
         else
                 usbhsf_dma_init_pdev(fifo);
 
@@ -1231,7 +1390,7 @@ do {									\
                         usbhs_get_dparam(priv, d##channel##_tx_id);     \
         fifo->rx_slave.shdma_slave.slave_id =                           \
                         usbhs_get_dparam(priv, d##channel##_rx_id);     \
-        usbhsf_dma_init(priv, fifo);                                    \
+        usbhsf_dma_init(priv, fifo, channel);                           \
 } while (0)
 
 #define USBHS_DFIFO_INIT(priv, fifo, channel)                           \
diff --git a/drivers/usb/renesas_usbhs/fifo.h b/drivers/usb/renesas_usbhs/fifo.h
index f07037c1185f..04d3f8abad9e 100644
--- a/drivers/usb/renesas_usbhs/fifo.h
+++ b/drivers/usb/renesas_usbhs/fifo.h
@@ -58,6 +58,7 @@ struct usbhs_pkt {
                      struct usbhs_pkt *pkt);
         struct work_struct work;
         dma_addr_t dma;
+        dma_cookie_t cookie;
         void *buf;
         int length;
         int trans;
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index e0384af77e56..dc2aa3261202 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -119,18 +119,34 @@ struct usbhsg_recip_handle {
 /*
  *              queue push/pop
  */
-static void usbhsg_queue_pop(struct usbhsg_uep *uep,
-                             struct usbhsg_request *ureq,
-                             int status)
+static void __usbhsg_queue_pop(struct usbhsg_uep *uep,
+                               struct usbhsg_request *ureq,
+                               int status)
 {
         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 
         dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
 
         ureq->req.status = status;
+        spin_unlock(usbhs_priv_to_lock(priv));
         usb_gadget_giveback_request(&uep->ep, &ureq->req);
+        spin_lock(usbhs_priv_to_lock(priv));
+}
+
+static void usbhsg_queue_pop(struct usbhsg_uep *uep,
+                             struct usbhsg_request *ureq,
+                             int status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+        unsigned long flags;
+
+        usbhs_lock(priv, flags);
+        __usbhsg_queue_pop(uep, ureq, status);
+        usbhs_unlock(priv, flags);
 }
 
 static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
diff --git a/drivers/usb/renesas_usbhs/mod_host.c b/drivers/usb/renesas_usbhs/mod_host.c
index 96eead619282..bd050359926c 100644
--- a/drivers/usb/renesas_usbhs/mod_host.c
+++ b/drivers/usb/renesas_usbhs/mod_host.c
@@ -1229,7 +1229,7 @@ static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv,
                 break;
 
         case GetHubDescriptor:
-                desc->bDescriptorType           = 0x29;
+                desc->bDescriptorType           = USB_DT_HUB;
                 desc->bHubContrCurrent          = 0;
                 desc->bNbrPorts                 = roothub_id;
                 desc->bDescLength               = 9;
diff --git a/drivers/usb/renesas_usbhs/pipe.c b/drivers/usb/renesas_usbhs/pipe.c
index 007f45abe96c..4f9c3356127a 100644
--- a/drivers/usb/renesas_usbhs/pipe.c
+++ b/drivers/usb/renesas_usbhs/pipe.c
@@ -84,6 +84,17 @@ static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
                 usbhs_bset(priv, pipe_reg, mask, val);
 }
 
+static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe,
+                                 u16 dcp_reg, u16 pipe_reg)
+{
+        struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+
+        if (usbhs_pipe_is_dcp(pipe))
+                return usbhs_read(priv, dcp_reg);
+        else
+                return usbhs_read(priv, pipe_reg);
+}
+
 /*
  *              DCPCFG/PIPECFG functions
  */
@@ -92,6 +103,11 @@ static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
         __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
 }
 
+static u16 usbhsp_pipe_cfg_get(struct usbhs_pipe *pipe)
+{
+        return __usbhsp_pipe_xxx_get(pipe, DCPCFG, PIPECFG);
+}
+
 /*
  *              PIPEnTRN/PIPEnTRE functions
  */
@@ -616,6 +632,11 @@ void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
         usbhsp_pipectrl_set(pipe, mask, val);
 }
 
+static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe)
+{
+        return !!(usbhsp_pipectrl_get(pipe) & SQMON);
+}
+
 void usbhs_pipe_clear(struct usbhs_pipe *pipe)
 {
         if (usbhs_pipe_is_dcp(pipe)) {
@@ -626,6 +647,24 @@ void usbhs_pipe_clear(struct usbhs_pipe *pipe)
         }
 }
 
+void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable)
+{
+        int sequence;
+
+        if (usbhs_pipe_is_dcp(pipe))
+                return;
+
+        usbhsp_pipe_select(pipe);
+        /* check if the driver needs to change the BFRE value */
+        if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE)))
+                return;
+
+        sequence = usbhs_pipe_get_data_sequence(pipe);
+        usbhsp_pipe_cfg_set(pipe, BFRE, enable ? BFRE : 0);
+        usbhs_pipe_clear(pipe);
+        usbhs_pipe_data_sequence(pipe, sequence);
+}
+
 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
 {
         struct usbhs_pipe *pos, *pipe;
diff --git a/drivers/usb/renesas_usbhs/pipe.h b/drivers/usb/renesas_usbhs/pipe.h
index d24a05972370..b0bc7b603016 100644
--- a/drivers/usb/renesas_usbhs/pipe.h
+++ b/drivers/usb/renesas_usbhs/pipe.h
@@ -97,6 +97,7 @@ void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len);
 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo);
 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
                               u16 epnum, u16 maxp);
+void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable);
 
 #define usbhs_pipe_sequence_data0(pipe) usbhs_pipe_data_sequence(pipe, 0)
 #define usbhs_pipe_sequence_data1(pipe) usbhs_pipe_data_sequence(pipe, 1)
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index ede4f5fcfadd..c73808f095bb 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -325,7 +325,6 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
         if (r) {
                 dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n",
                         __func__, r);
-                ch341_close(port);
                 goto out;
         }
 
diff --git a/drivers/usb/serial/f81232.c b/drivers/usb/serial/f81232.c
index c5dc233db2d9..972f5a5fe577 100644
--- a/drivers/usb/serial/f81232.c
+++ b/drivers/usb/serial/f81232.c
@@ -19,10 +19,11 @@
 #include <linux/serial.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/serial_reg.h>
 
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1934, 0x0706) },
@@ -30,37 +31,218 @@ static const struct usb_device_id id_table[] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-#define CONTROL_DTR                     0x01
-#define CONTROL_RTS                     0x02
+/* Maximum baudrate for F81232 */
+#define F81232_MAX_BAUDRATE             115200
 
-#define UART_STATE                      0x08
-#define UART_STATE_TRANSIENT_MASK       0x74
-#define UART_DCD                        0x01
-#define UART_DSR                        0x02
-#define UART_BREAK_ERROR                0x04
-#define UART_RING                       0x08
-#define UART_FRAME_ERROR                0x10
-#define UART_PARITY_ERROR               0x20
-#define UART_OVERRUN_ERROR              0x40
-#define UART_CTS                        0x80
+/* USB Control EP parameter */
+#define F81232_REGISTER_REQUEST         0xa0
+#define F81232_GET_REGISTER             0xc0
+#define F81232_SET_REGISTER             0x40
+
+#define SERIAL_BASE_ADDRESS             0x0120
+#define RECEIVE_BUFFER_REGISTER         (0x00 + SERIAL_BASE_ADDRESS)
+#define INTERRUPT_ENABLE_REGISTER       (0x01 + SERIAL_BASE_ADDRESS)
+#define FIFO_CONTROL_REGISTER           (0x02 + SERIAL_BASE_ADDRESS)
+#define LINE_CONTROL_REGISTER           (0x03 + SERIAL_BASE_ADDRESS)
+#define MODEM_CONTROL_REGISTER          (0x04 + SERIAL_BASE_ADDRESS)
+#define MODEM_STATUS_REGISTER           (0x06 + SERIAL_BASE_ADDRESS)
 
 struct f81232_private {
-        spinlock_t lock;
-        u8 line_control;
-        u8 line_status;
+        struct mutex lock;
+        u8 modem_control;
+        u8 modem_status;
+        struct work_struct interrupt_work;
+        struct usb_serial_port *port;
 };
 
+static int calc_baud_divisor(speed_t baudrate)
+{
+        return DIV_ROUND_CLOSEST(F81232_MAX_BAUDRATE, baudrate);
+}
+
+static int f81232_get_register(struct usb_serial_port *port, u16 reg, u8 *val)
+{
+        int status;
+        u8 *tmp;
+        struct usb_device *dev = port->serial->dev;
+
+        tmp = kmalloc(sizeof(*val), GFP_KERNEL);
+        if (!tmp)
+                return -ENOMEM;
+
+        status = usb_control_msg(dev,
+                                usb_rcvctrlpipe(dev, 0),
+                                F81232_REGISTER_REQUEST,
+                                F81232_GET_REGISTER,
+                                reg,
+                                0,
+                                tmp,
+                                sizeof(*val),
+                                USB_CTRL_GET_TIMEOUT);
+        if (status != sizeof(*val)) {
+                dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
+
+                if (status < 0)
+                        status = usb_translate_errors(status);
+                else
+                        status = -EIO;
+        } else {
+                status = 0;
+                *val = *tmp;
+        }
+
+        kfree(tmp);
+        return status;
+}
+
+static int f81232_set_register(struct usb_serial_port *port, u16 reg, u8 val)
+{
+        int status;
+        u8 *tmp;
+        struct usb_device *dev = port->serial->dev;
+
+        tmp = kmalloc(sizeof(val), GFP_KERNEL);
+        if (!tmp)
+                return -ENOMEM;
+
+        *tmp = val;
+
+        status = usb_control_msg(dev,
+                                usb_sndctrlpipe(dev, 0),
+                                F81232_REGISTER_REQUEST,
+                                F81232_SET_REGISTER,
+                                reg,
+                                0,
+                                tmp,
+                                sizeof(val),
+                                USB_CTRL_SET_TIMEOUT);
+        if (status != sizeof(val)) {
+                dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
+
+                if (status < 0)
+                        status = usb_translate_errors(status);
+                else
+                        status = -EIO;
+        } else {
+                status = 0;
+        }
+
+        kfree(tmp);
+        return status;
+}
+
+static void f81232_read_msr(struct usb_serial_port *port)
+{
+        int status;
+        u8 current_msr;
+        struct tty_struct *tty;
+        struct f81232_private *priv = usb_get_serial_port_data(port);
+
+        mutex_lock(&priv->lock);
+        status = f81232_get_register(port, MODEM_STATUS_REGISTER,
+                        &current_msr);
+        if (status) {
+                dev_err(&port->dev, "%s fail, status: %d\n", __func__, status);
+                mutex_unlock(&priv->lock);
+                return;
+        }
+
+        if (!(current_msr & UART_MSR_ANY_DELTA)) {
+                mutex_unlock(&priv->lock);
+                return;
+        }
+
+        priv->modem_status = current_msr;
+
+        if (current_msr & UART_MSR_DCTS)
+                port->icount.cts++;
+        if (current_msr & UART_MSR_DDSR)
+                port->icount.dsr++;
+        if (current_msr & UART_MSR_TERI)
+                port->icount.rng++;
+        if (current_msr & UART_MSR_DDCD) {
+                port->icount.dcd++;
+                tty = tty_port_tty_get(&port->port);
+                if (tty) {
+                        usb_serial_handle_dcd_change(port, tty,
+                                        current_msr & UART_MSR_DCD);
+
+                        tty_kref_put(tty);
+                }
+        }
+
+        wake_up_interruptible(&port->port.delta_msr_wait);
+        mutex_unlock(&priv->lock);
+}
+
+static int f81232_set_mctrl(struct usb_serial_port *port,
+                                           unsigned int set, unsigned int clear)
+{
+        u8 val;
+        int status;
+        struct f81232_private *priv = usb_get_serial_port_data(port);
+
+        if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0)
+                return 0;       /* no change */
+
+        /* 'set' takes precedence over 'clear' */
+        clear &= ~set;
+
+        /* force enable interrupt with OUT2 */
+        mutex_lock(&priv->lock);
+        val = UART_MCR_OUT2 | priv->modem_control;
+
+        if (clear & TIOCM_DTR)
+                val &= ~UART_MCR_DTR;
+
+        if (clear & TIOCM_RTS)
+                val &= ~UART_MCR_RTS;
+
+        if (set & TIOCM_DTR)
+                val |= UART_MCR_DTR;
+
+        if (set & TIOCM_RTS)
+                val |= UART_MCR_RTS;
+
+        dev_dbg(&port->dev, "%s new:%02x old:%02x\n", __func__,
+                        val, priv->modem_control);
+
+        status = f81232_set_register(port, MODEM_CONTROL_REGISTER, val);
+        if (status) {
+                dev_err(&port->dev, "%s set MCR status < 0\n", __func__);
+                mutex_unlock(&priv->lock);
+                return status;
+        }
+
+        priv->modem_control = val;
+        mutex_unlock(&priv->lock);
+
+        return 0;
+}
+
 static void f81232_update_line_status(struct usb_serial_port *port,
                                       unsigned char *data,
-                                      unsigned int actual_length)
+                                      size_t actual_length)
 {
-        /*
-         * FIXME: Update port->icount, and call
-         *
-         *              wake_up_interruptible(&port->port.delta_msr_wait);
-         *
-         *        on MSR changes.
-         */
+        struct f81232_private *priv = usb_get_serial_port_data(port);
+
+        if (!actual_length)
+                return;
+
+        switch (data[0] & 0x07) {
+        case 0x00: /* msr change */
+                dev_dbg(&port->dev, "IIR: MSR Change: %02x\n", data[0]);
+                schedule_work(&priv->interrupt_work);
+                break;
+        case 0x02: /* tx-empty */
+                break;
+        case 0x04: /* rx data available */
+                break;
+        case 0x06: /* lsr change */
+                /* we can forget it. the LSR will read from bulk-in */
+                dev_dbg(&port->dev, "IIR: LSR Change: %02x\n", data[0]);
+                break;
+        }
 }
 
 static void f81232_read_int_callback(struct urb *urb)
@@ -104,55 +286,55 @@ exit:
 static void f81232_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct f81232_private *priv = usb_get_serial_port_data(port);
         unsigned char *data = urb->transfer_buffer;
-        char tty_flag = TTY_NORMAL;
-        unsigned long flags;
-        u8 line_status;
-        int i;
-
-        /* update line status */
-        spin_lock_irqsave(&priv->lock, flags);
-        line_status = priv->line_status;
-        priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
-        spin_unlock_irqrestore(&priv->lock, flags);
-
-        if (!urb->actual_length)
+        char tty_flag;
+        unsigned int i;
+        u8 lsr;
+
+        /*
+         * When opening the port we get a 1-byte packet with the current LSR,
+         * which we discard.
+         */
+        if ((urb->actual_length < 2) || (urb->actual_length % 2))
                 return;
 
-        /* break takes precedence over parity, */
-        /* which takes precedence over framing errors */
-        if (line_status & UART_BREAK_ERROR)
-                tty_flag = TTY_BREAK;
-        else if (line_status & UART_PARITY_ERROR)
-                tty_flag = TTY_PARITY;
-        else if (line_status & UART_FRAME_ERROR)
-                tty_flag = TTY_FRAME;
-        dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
-
-        /* overrun is special, not associated with a char */
-        if (line_status & UART_OVERRUN_ERROR)
-                tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
-
-        if (port->port.console && port->sysrq) {
-                for (i = 0; i < urb->actual_length; ++i)
-                        if (!usb_serial_handle_sysrq_char(port, data[i]))
-                                tty_insert_flip_char(&port->port, data[i],
-                                                tty_flag);
-        } else {
-                tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
-                                                        urb->actual_length);
+        /* bulk-in data: [LSR(1Byte)+DATA(1Byte)][LSR(1Byte)+DATA(1Byte)]... */
+
+        for (i = 0; i < urb->actual_length; i += 2) {
+                tty_flag = TTY_NORMAL;
+                lsr = data[i];
+
+                if (lsr & UART_LSR_BRK_ERROR_BITS) {
+                        if (lsr & UART_LSR_BI) {
+                                tty_flag = TTY_BREAK;
+                                port->icount.brk++;
+                                usb_serial_handle_break(port);
+                        } else if (lsr & UART_LSR_PE) {
+                                tty_flag = TTY_PARITY;
+                                port->icount.parity++;
+                        } else if (lsr & UART_LSR_FE) {
+                                tty_flag = TTY_FRAME;
+                                port->icount.frame++;
+                        }
+
+                        if (lsr & UART_LSR_OE) {
+                                port->icount.overrun++;
+                                tty_insert_flip_char(&port->port, 0,
+                                                TTY_OVERRUN);
+                        }
+                }
+
+                if (port->port.console && port->sysrq) {
+                        if (usb_serial_handle_sysrq_char(port, data[i + 1]))
+                                continue;
+                }
+
+                tty_insert_flip_char(&port->port, data[i + 1], tty_flag);
         }
 
         tty_flip_buffer_push(&port->port);
 }
 
-static int set_control_lines(struct usb_device *dev, u8 value)
-{
-        /* FIXME - Stubbed out for now */
-        return 0;
-}
-
 static void f81232_break_ctl(struct tty_struct *tty, int break_state)
 {
         /* FIXME - Stubbed out for now */
@@ -164,37 +346,198 @@ static void f81232_break_ctl(struct tty_struct *tty, int break_state)
          */
 }
 
+static void f81232_set_baudrate(struct usb_serial_port *port, speed_t baudrate)
+{
+        u8 lcr;
+        int divisor;
+        int status = 0;
+
+        divisor = calc_baud_divisor(baudrate);
+
+        status = f81232_get_register(port, LINE_CONTROL_REGISTER,
+                         &lcr); /* get LCR */
+        if (status) {
+                dev_err(&port->dev, "%s failed to get LCR: %d\n",
+                        __func__, status);
+                return;
+        }
+
+        status = f81232_set_register(port, LINE_CONTROL_REGISTER,
+                         lcr | UART_LCR_DLAB); /* Enable DLAB */
+        if (status) {
+                dev_err(&port->dev, "%s failed to set DLAB: %d\n",
+                        __func__, status);
+                return;
+        }
+
+        status = f81232_set_register(port, RECEIVE_BUFFER_REGISTER,
+                         divisor & 0x00ff); /* low */
+        if (status) {
+                dev_err(&port->dev, "%s failed to set baudrate MSB: %d\n",
+                        __func__, status);
+                goto reapply_lcr;
+        }
+
+        status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
+                         (divisor & 0xff00) >> 8); /* high */
+        if (status) {
+                dev_err(&port->dev, "%s failed to set baudrate LSB: %d\n",
+                        __func__, status);
+        }
+
+reapply_lcr:
+        status = f81232_set_register(port, LINE_CONTROL_REGISTER,
+                        lcr & ~UART_LCR_DLAB);
+        if (status) {
+                dev_err(&port->dev, "%s failed to set DLAB: %d\n",
+                        __func__, status);
+        }
+}
+
+static int f81232_port_enable(struct usb_serial_port *port)
+{
+        u8 val;
+        int status;
+
+        /* fifo on, trigger8, clear TX/RX*/
+        val = UART_FCR_TRIGGER_8 | UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR |
+                        UART_FCR_CLEAR_XMIT;
+
+        status = f81232_set_register(port, FIFO_CONTROL_REGISTER, val);
+        if (status) {
+                dev_err(&port->dev, "%s failed to set FCR: %d\n",
+                        __func__, status);
+                return status;
+        }
+
+        /* MSR Interrupt only, LSR will read from Bulk-in odd byte */
+        status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
+                        UART_IER_MSI);
+        if (status) {
+                dev_err(&port->dev, "%s failed to set IER: %d\n",
+                        __func__, status);
+                return status;
+        }
+
+        return 0;
+}
+
+static int f81232_port_disable(struct usb_serial_port *port)
+{
+        int status;
+
+        status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 0);
+        if (status) {
+                dev_err(&port->dev, "%s failed to set IER: %d\n",
+                        __func__, status);
+                return status;
+        }
+
+        return 0;
+}
+
 static void f81232_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
-        /* FIXME - Stubbed out for now */
+        u8 new_lcr = 0;
+        int status = 0;
+        speed_t baudrate;
 
         /* Don't change anything if nothing has changed */
         if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
                 return;
 
-        /* Do the real work here... */
-        if (old_termios)
-                tty_termios_copy_hw(&tty->termios, old_termios);
+        if (C_BAUD(tty) == B0)
+                f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
+        else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
+                f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
+
+        baudrate = tty_get_baud_rate(tty);
+        if (baudrate > 0) {
+                if (baudrate > F81232_MAX_BAUDRATE) {
+                        baudrate = F81232_MAX_BAUDRATE;
+                        tty_encode_baud_rate(tty, baudrate, baudrate);
+                }
+                f81232_set_baudrate(port, baudrate);
+        }
+
+        if (C_PARENB(tty)) {
+                new_lcr |= UART_LCR_PARITY;
+
+                if (!C_PARODD(tty))
+                        new_lcr |= UART_LCR_EPAR;
+
+                if (C_CMSPAR(tty))
+                        new_lcr |= UART_LCR_SPAR;
+        }
+
+        if (C_CSTOPB(tty))
+                new_lcr |= UART_LCR_STOP;
+
+        switch (C_CSIZE(tty)) {
+        case CS5:
+                new_lcr |= UART_LCR_WLEN5;
+                break;
+        case CS6:
+                new_lcr |= UART_LCR_WLEN6;
+                break;
+        case CS7:
+                new_lcr |= UART_LCR_WLEN7;
+                break;
+        default:
+        case CS8:
+                new_lcr |= UART_LCR_WLEN8;
+                break;
+        }
+
+        status = f81232_set_register(port, LINE_CONTROL_REGISTER, new_lcr);
+        if (status) {
+                dev_err(&port->dev, "%s failed to set LCR: %d\n",
+                        __func__, status);
+        }
 }
 
 static int f81232_tiocmget(struct tty_struct *tty)
 {
-        /* FIXME - Stubbed out for now */
-        return 0;
+        int r;
+        struct usb_serial_port *port = tty->driver_data;
+        struct f81232_private *port_priv = usb_get_serial_port_data(port);
+        u8 mcr, msr;
+
+        /* force get current MSR changed state */
+        f81232_read_msr(port);
+
+        mutex_lock(&port_priv->lock);
+        mcr = port_priv->modem_control;
+        msr = port_priv->modem_status;
+        mutex_unlock(&port_priv->lock);
+
+        r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) |
+                (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) |
+                (msr & UART_MSR_CTS ? TIOCM_CTS : 0) |
+                (msr & UART_MSR_DCD ? TIOCM_CAR : 0) |
+                (msr & UART_MSR_RI ? TIOCM_RI : 0) |
+                (msr & UART_MSR_DSR ? TIOCM_DSR : 0);
+
+        return r;
 }
 
 static int f81232_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear)
 {
-        /* FIXME - Stubbed out for now */
-        return 0;
+        struct usb_serial_port *port = tty->driver_data;
+
+        return f81232_set_mctrl(port, set, clear);
 }
 
 static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int result;
 
+        result = f81232_port_enable(port);
+        if (result)
+                return result;
+
         /* Setup termios */
         if (tty)
                 f81232_set_termios(tty, port, NULL);
@@ -217,59 +560,73 @@ static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port)
 
 static void f81232_close(struct usb_serial_port *port)
 {
+        f81232_port_disable(port);
         usb_serial_generic_close(port);
         usb_kill_urb(port->interrupt_in_urb);
 }
 
 static void f81232_dtr_rts(struct usb_serial_port *port, int on)
 {
-        struct f81232_private *priv = usb_get_serial_port_data(port);
-        unsigned long flags;
-        u8 control;
-
-        spin_lock_irqsave(&priv->lock, flags);
-        /* Change DTR and RTS */
         if (on)
-                priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
+                f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
         else
-                priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
-        control = priv->line_control;
-        spin_unlock_irqrestore(&priv->lock, flags);
-        set_control_lines(port->serial->dev, control);
+                f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
 }
 
 static int f81232_carrier_raised(struct usb_serial_port *port)
 {
+        u8 msr;
         struct f81232_private *priv = usb_get_serial_port_data(port);
-        if (priv->line_status & UART_DCD)
+
+        mutex_lock(&priv->lock);
+        msr = priv->modem_status;
+        mutex_unlock(&priv->lock);
+
+        if (msr & UART_MSR_DCD)
                 return 1;
         return 0;
 }
 
+static int f81232_get_serial_info(struct usb_serial_port *port,
+                unsigned long arg)
+{
+        struct serial_struct ser;
+
+        memset(&ser, 0, sizeof(ser));
+
+        ser.type = PORT_16550A;
+        ser.line = port->minor;
+        ser.port = port->port_number;
+        ser.baud_base = F81232_MAX_BAUDRATE;
+
+        if (copy_to_user((void __user *)arg, &ser, sizeof(ser)))
+                return -EFAULT;
+
+        return 0;
+}
+
 static int f81232_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg)
 {
-        struct serial_struct ser;
         struct usb_serial_port *port = tty->driver_data;
 
         switch (cmd) {
         case TIOCGSERIAL:
-                memset(&ser, 0, sizeof ser);
-                ser.type = PORT_16654;
-                ser.line = port->minor;
-                ser.port = port->port_number;
-                ser.baud_base = 460800;
-
-                if (copy_to_user((void __user *)arg, &ser, sizeof ser))
-                        return -EFAULT;
-
-                return 0;
+                return f81232_get_serial_info(port, arg);
         default:
                 break;
         }
         return -ENOIOCTLCMD;
 }
 
+static void  f81232_interrupt_work(struct work_struct *work)
+{
+        struct f81232_private *priv =
+                container_of(work, struct f81232_private, interrupt_work);
+
+        f81232_read_msr(priv->port);
+}
+
 static int f81232_port_probe(struct usb_serial_port *port)
 {
         struct f81232_private *priv;
@@ -278,11 +635,13 @@ static int f81232_port_probe(struct usb_serial_port *port)
         if (!priv)
                 return -ENOMEM;
 
-        spin_lock_init(&priv->lock);
+        mutex_init(&priv->lock);
+        INIT_WORK(&priv->interrupt_work,  f81232_interrupt_work);
 
         usb_set_serial_port_data(port, priv);
 
         port->port.drain_delay = 256;
+        priv->port = port;
 
         return 0;
 }
@@ -308,7 +667,7 @@ static struct usb_serial_driver f81232_device = {
         .bulk_out_size =        256,
         .open =                 f81232_open,
         .close =                f81232_close,
-        .dtr_rts =              f81232_dtr_rts,
+        .dtr_rts =              f81232_dtr_rts,
         .carrier_raised =       f81232_carrier_raised,
         .ioctl =                f81232_ioctl,
         .break_ctl =            f81232_break_ctl,
@@ -330,5 +689,6 @@ static struct usb_serial_driver * const serial_drivers[] = {
 module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION("Fintek F81232 USB to serial adaptor driver");
-MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org");
+MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org>");
+MODULE_AUTHOR("Peter Hong <peter_hong@fintek.com.tw>");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 3086dec0ef53..8eb68a31cab6 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -604,6 +604,7 @@ static const struct usb_device_id id_table_combined[] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_NT_ORIONLXM_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(FTDI_VID, FTDI_SYNAPSE_SS200_PID) },
         /*
          * ELV devices:
          */
@@ -1883,8 +1884,12 @@ static int ftdi_8u2232c_probe(struct usb_serial *serial)
 {
         struct usb_device *udev = serial->dev;
 
-        if ((udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems")) ||
-            (udev->product && !strcmp(udev->product, "BeagleBone/XDS100V2")))
+        if (udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems"))
+                return ftdi_jtag_probe(serial);
+
+        if (udev->product &&
+                (!strcmp(udev->product, "BeagleBone/XDS100V2") ||
+                 !strcmp(udev->product, "SNAP Connect E10")))
                 return ftdi_jtag_probe(serial);
 
         return 0;
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 56b1b55c4751..4e4f46f3c89c 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -561,6 +561,12 @@
  */
 #define FTDI_NT_ORIONLXM_PID    0x7c90  /* OrionLXm Substation Automation Platform */
 
+/*
+ * Synapse Wireless product ids (FTDI_VID)
+ * http://www.synapse-wireless.com
+ */
+#define FTDI_SYNAPSE_SS200_PID 0x9090 /* SS200 - SNAP Stick 200 */
+
 
 /********************************/
 /** third-party VID/PID combos **/
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index dd97d8b572c3..4f7e072e4e00 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -61,6 +61,7 @@ struct keyspan_pda_private {
 /* For Xircom PGSDB9 and older Entrega version of the same device */
 #define XIRCOM_VENDOR_ID                0x085a
 #define XIRCOM_FAKE_ID                  0x8027
+#define XIRCOM_FAKE_ID_2                0x8025 /* "PGMFHUB" serial */
 #define ENTREGA_VENDOR_ID               0x1645
 #define ENTREGA_FAKE_ID                 0x8093
 
@@ -70,6 +71,7 @@ static const struct usb_device_id id_table_combined[] = {
 #endif
 #ifdef XIRCOM
         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
+        { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 #endif
         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
@@ -93,6 +95,7 @@ static const struct usb_device_id id_table_fake[] = {
 #ifdef XIRCOM
 static const struct usb_device_id id_table_fake_xircom[] = {
         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
+        { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
         { }
 };
diff --git a/drivers/usb/storage/alauda.c b/drivers/usb/storage/alauda.c
index 62c2d9daa7d6..4b55ab66a534 100644
--- a/drivers/usb/storage/alauda.c
+++ b/drivers/usb/storage/alauda.c
@@ -207,7 +207,8 @@ static struct alauda_card_info alauda_card_ids[] = {
         { 0,}
 };
 
-static struct alauda_card_info *alauda_card_find_id(unsigned char id) {
+static struct alauda_card_info *alauda_card_find_id(unsigned char id)
+{
         int i;
 
         for (i = 0; alauda_card_ids[i].id != 0; i++)
@@ -223,7 +224,8 @@ static struct alauda_card_info *alauda_card_find_id(unsigned char id) {
 static unsigned char parity[256];
 static unsigned char ecc2[256];
 
-static void nand_init_ecc(void) {
+static void nand_init_ecc(void)
+{
         int i, j, a;
 
         parity[0] = 0;
@@ -247,7 +249,8 @@ static void nand_init_ecc(void) {
 }
 
 /* compute 3-byte ecc on 256 bytes */
-static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) {
+static void nand_compute_ecc(unsigned char *data, unsigned char *ecc)
+{
         int i, j, a;
         unsigned char par = 0, bit, bits[8] = {0};
 
@@ -270,11 +273,13 @@ static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) {
         ecc[2] = ecc2[par];
 }
 
-static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) {
+static int nand_compare_ecc(unsigned char *data, unsigned char *ecc)
+{
         return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]);
 }
 
-static void nand_store_ecc(unsigned char *data, unsigned char *ecc) {
+static void nand_store_ecc(unsigned char *data, unsigned char *ecc)
+{
         memcpy(data, ecc, 3);
 }
 
diff --git a/drivers/usb/storage/cypress_atacb.c b/drivers/usb/storage/cypress_atacb.c
index 8514a2d82b72..b3466d1395f2 100644
--- a/drivers/usb/storage/cypress_atacb.c
+++ b/drivers/usb/storage/cypress_atacb.c
@@ -96,13 +96,13 @@ static void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
         if (save_cmnd[1] >> 5) /* MULTIPLE_COUNT */
                 goto invalid_fld;
         /* check protocol */
-        switch((save_cmnd[1] >> 1) & 0xf) {
-                case 3: /*no DATA */
-                case 4: /* PIO in */
-                case 5: /* PIO out */
-                        break;
-                default:
-                        goto invalid_fld;
+        switch ((save_cmnd[1] >> 1) & 0xf) {
+        case 3: /*no DATA */
+        case 4: /* PIO in */
+        case 5: /* PIO out */
+                break;
+        default:
+                goto invalid_fld;
         }
 
         /* first build the ATACB command */
@@ -132,8 +132,7 @@ static void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
                                         || save_cmnd[11])
                                 goto invalid_fld;
                 }
-        }
-        else { /* ATA12 */
+        } else { /* ATA12 */
                 srb->cmnd[ 6] = save_cmnd[3]; /* features */
                 srb->cmnd[ 7] = save_cmnd[4]; /* sector count */
                 srb->cmnd[ 8] = save_cmnd[5]; /* lba low */
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 599d8bff26c3..076178645ba4 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -737,7 +737,7 @@ static void isd200_log_config(struct us_data *us, struct isd200_info *info)
                      info->ConfigData.ATAExtraConfig & ATACFGE_CONF_DESC2);
         usb_stor_dbg(us, "      Skip Device Boot: 0x%x\n",
                      info->ConfigData.ATAExtraConfig & ATACFGE_SKIP_BOOT);
-        usb_stor_dbg(us, "      ATA 3 State Supsend: 0x%x\n",
+        usb_stor_dbg(us, "      ATA 3 State Suspend: 0x%x\n",
                      info->ConfigData.ATAExtraConfig & ATACFGE_STATE_SUSPEND);
         usb_stor_dbg(us, "      Descriptor Override: 0x%x\n",
                      info->ConfigData.ATAExtraConfig & ATACFGE_DESC_OVERRIDE);
diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h
index 82570425fdfe..c85ea530085f 100644
--- a/drivers/usb/storage/unusual_uas.h
+++ b/drivers/usb/storage/unusual_uas.h
@@ -113,6 +113,13 @@ UNUSUAL_DEV(0x0bc2, 0xab2a, 0x0000, 0x9999,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_ATA_1X),
 
+/* Reported-by: Benjamin Tissoires <benjamin.tissoires@redhat.com> */
+UNUSUAL_DEV(0x13fd, 0x3940, 0x0000, 0x9999,
+                "Initio Corporation",
+                "",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_ATA_1X),
+
 /* Reported-by: Tom Arild Naess <tanaess@gmail.com> */
 UNUSUAL_DEV(0x152d, 0x0539, 0x0000, 0x9999,
                 "JMicron",
diff --git a/drivers/usb/usbip/vhci_hcd.c b/drivers/usb/usbip/vhci_hcd.c
index 11f6f61c2381..e9ef1eccdace 100644
--- a/drivers/usb/usbip/vhci_hcd.c
+++ b/drivers/usb/usbip/vhci_hcd.c
@@ -216,7 +216,7 @@ done:
 static inline void hub_descriptor(struct usb_hub_descriptor *desc)
 {
         memset(desc, 0, sizeof(*desc));
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         desc->bDescLength = 9;
         desc->wHubCharacteristics = __constant_cpu_to_le16(
                 HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM);
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index aa5af817f31c..a082fe62b1f0 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -182,7 +182,7 @@ static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
         if (wLength < length)
                 return -ENOSPC;
         descr->bDescLength = 7 + 2 * temp;
-        descr->bDescriptorType = 0x29;  /* HUB type */
+        descr->bDescriptorType = USB_DT_HUB; /* HUB type */
         descr->bNbrPorts = wusbhc->ports_max;
         descr->wHubCharacteristics = cpu_to_le16(
                 HUB_CHAR_COMMON_LPSM    /* All ports power at once */