35 files changed, 389 insertions, 138 deletions

diff --git a/Documentation/devicetree/bindings/usb/mxs-phy.txt b/Documentation/devicetree/bindings/usb/mxs-phy.txt
index cef181a9d8bd..96681c93b86d 100644
--- a/Documentation/devicetree/bindings/usb/mxs-phy.txt
+++ b/Documentation/devicetree/bindings/usb/mxs-phy.txt
@@ -5,6 +5,7 @@ Required properties:
         * "fsl,imx23-usbphy" for imx23 and imx28
         * "fsl,imx6q-usbphy" for imx6dq and imx6dl
         * "fsl,imx6sl-usbphy" for imx6sl
+        * "fsl,imx6sx-usbphy" for imx6sx
   "fsl,imx23-usbphy" is still a fallback for other strings
 - reg: Should contain registers location and length
 - interrupts: Should contain phy interrupt
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 5ae8608ca9f5..10d51c2f10d7 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -3541,6 +3541,7 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                                         bogus residue values);
                                 s = SINGLE_LUN (the device has only one
                                         Logical Unit);
+                                u = IGNORE_UAS (don't bind to the uas driver);
                                 w = NO_WP_DETECT (don't test whether the
                                         medium is write-protected).
                         Example: quirks=0419:aaf5:rl,0421:0433:rc
diff --git a/MAINTAINERS b/MAINTAINERS
index 34091d78a4ef..97e92d9dc470 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7913,6 +7913,19 @@ S:	Supported
 L:      netdev@vger.kernel.org
 F:      drivers/net/ethernet/samsung/sxgbe/
 
+SAMSUNG USB2 PHY DRIVER
+M:      Kamil Debski <k.debski@samsung.com>
+L:      linux-kernel@vger.kernel.org
+S:      Supported
+F:      Documentation/devicetree/bindings/phy/samsung-phy.txt
+F:      Documentation/phy/samsung-usb2.txt
+F:      drivers/phy/phy-exynos4210-usb2.c
+F:      drivers/phy/phy-exynos4x12-usb2.c
+F:      drivers/phy/phy-exynos5250-usb2.c
+F:      drivers/phy/phy-s5pv210-usb2.c
+F:      drivers/phy/phy-samsung-usb2.c
+F:      drivers/phy/phy-samsung-usb2.h
+
 SERIAL DRIVERS
 M:      Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 L:      linux-serial@vger.kernel.org
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index 0dd742719154..4ff8cbb620d3 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -41,9 +41,9 @@ config PHY_MVEBU_SATA
 config PHY_MIPHY365X
         tristate "STMicroelectronics MIPHY365X PHY driver for STiH41x series"
         depends on ARCH_STI
-        depends on GENERIC_PHY
         depends on HAS_IOMEM
         depends on OF
+        select GENERIC_PHY
         help
           Enable this to support the miphy transceiver (for SATA/PCIE)
           that is part of STMicroelectronics STiH41x SoC series.
diff --git a/drivers/phy/phy-exynos5-usbdrd.c b/drivers/phy/phy-exynos5-usbdrd.c
index b05302b09c9f..392101c8d6b0 100644
--- a/drivers/phy/phy-exynos5-usbdrd.c
+++ b/drivers/phy/phy-exynos5-usbdrd.c
@@ -542,6 +542,7 @@ static const struct of_device_id exynos5_usbdrd_phy_of_match[] = {
         },
         { },
 };
+MODULE_DEVICE_TABLE(of, exynos5_usbdrd_phy_of_match);
 
 static int exynos5_usbdrd_phy_probe(struct platform_device *pdev)
 {
diff --git a/drivers/phy/phy-twl4030-usb.c b/drivers/phy/phy-twl4030-usb.c
index e1a6623d4696..9cd33a4bcfb1 100644
--- a/drivers/phy/phy-twl4030-usb.c
+++ b/drivers/phy/phy-twl4030-usb.c
@@ -34,6 +34,7 @@
 #include <linux/delay.h>
 #include <linux/usb/otg.h>
 #include <linux/phy/phy.h>
+#include <linux/pm_runtime.h>
 #include <linux/usb/musb-omap.h>
 #include <linux/usb/ulpi.h>
 #include <linux/i2c/twl.h>
@@ -422,37 +423,55 @@ static void twl4030_phy_power(struct twl4030_usb *twl, int on)
         }
 }
 
-static int twl4030_phy_power_off(struct phy *phy)
+static int twl4030_usb_runtime_suspend(struct device *dev)
 {
-        struct twl4030_usb *twl = phy_get_drvdata(phy);
+        struct twl4030_usb *twl = dev_get_drvdata(dev);
 
+        dev_dbg(twl->dev, "%s\n", __func__);
         if (twl->asleep)
                 return 0;
 
         twl4030_phy_power(twl, 0);
         twl->asleep = 1;
-        dev_dbg(twl->dev, "%s\n", __func__);
+
         return 0;
 }
 
-static void __twl4030_phy_power_on(struct twl4030_usb *twl)
+static int twl4030_usb_runtime_resume(struct device *dev)
 {
+        struct twl4030_usb *twl = dev_get_drvdata(dev);
+
+        dev_dbg(twl->dev, "%s\n", __func__);
+        if (!twl->asleep)
+                return 0;
+
         twl4030_phy_power(twl, 1);
-        twl4030_i2c_access(twl, 1);
-        twl4030_usb_set_mode(twl, twl->usb_mode);
-        if (twl->usb_mode == T2_USB_MODE_ULPI)
-                twl4030_i2c_access(twl, 0);
+        twl->asleep = 0;
+
+        return 0;
+}
+
+static int twl4030_phy_power_off(struct phy *phy)
+{
+        struct twl4030_usb *twl = phy_get_drvdata(phy);
+
+        dev_dbg(twl->dev, "%s\n", __func__);
+        pm_runtime_mark_last_busy(twl->dev);
+        pm_runtime_put_autosuspend(twl->dev);
+
+        return 0;
 }
 
 static int twl4030_phy_power_on(struct phy *phy)
 {
         struct twl4030_usb *twl = phy_get_drvdata(phy);
 
-        if (!twl->asleep)
-                return 0;
-        __twl4030_phy_power_on(twl);
-        twl->asleep = 0;
         dev_dbg(twl->dev, "%s\n", __func__);
+        pm_runtime_get_sync(twl->dev);
+        twl4030_i2c_access(twl, 1);
+        twl4030_usb_set_mode(twl, twl->usb_mode);
+        if (twl->usb_mode == T2_USB_MODE_ULPI)
+                twl4030_i2c_access(twl, 0);
 
         /*
          * XXX When VBUS gets driven after musb goes to A mode,
@@ -558,9 +577,27 @@ static irqreturn_t twl4030_usb_irq(int irq, void *_twl)
                  * USB_LINK_VBUS state.  musb_hdrc won't care until it
                  * starts to handle softconnect right.
                  */
+                if ((status == OMAP_MUSB_VBUS_VALID) ||
+                    (status == OMAP_MUSB_ID_GROUND)) {
+                        if (twl->asleep)
+                                pm_runtime_get_sync(twl->dev);
+                } else {
+                        if (!twl->asleep) {
+                                pm_runtime_mark_last_busy(twl->dev);
+                                pm_runtime_put_autosuspend(twl->dev);
+                        }
+                }
                 omap_musb_mailbox(status);
         }
-        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
+
+        /* don't schedule during sleep - irq works right then */
+        if (status == OMAP_MUSB_ID_GROUND && !twl->asleep) {
+                cancel_delayed_work(&twl->id_workaround_work);
+                schedule_delayed_work(&twl->id_workaround_work, HZ);
+        }
+
+        if (irq)
+                sysfs_notify(&twl->dev->kobj, NULL, "vbus");
 
         return IRQ_HANDLED;
 }
@@ -569,29 +606,8 @@ static void twl4030_id_workaround_work(struct work_struct *work)
 {
         struct twl4030_usb *twl = container_of(work, struct twl4030_usb,
                 id_workaround_work.work);
-        enum omap_musb_vbus_id_status status;
-        bool status_changed = false;
-
-        status = twl4030_usb_linkstat(twl);
-
-        spin_lock_irq(&twl->lock);
-        if (status >= 0 && status != twl->linkstat) {
-                twl->linkstat = status;
-                status_changed = true;
-        }
-        spin_unlock_irq(&twl->lock);
-
-        if (status_changed) {
-                dev_dbg(twl->dev, "handle missing status change to %d\n",
-                                status);
-                omap_musb_mailbox(status);
-        }
 
-        /* don't schedule during sleep - irq works right then */
-        if (status == OMAP_MUSB_ID_GROUND && !twl->asleep) {
-                cancel_delayed_work(&twl->id_workaround_work);
-                schedule_delayed_work(&twl->id_workaround_work, HZ);
-        }
+        twl4030_usb_irq(0, twl);
 }
 
 static int twl4030_phy_init(struct phy *phy)
@@ -599,22 +615,17 @@ static int twl4030_phy_init(struct phy *phy)
         struct twl4030_usb *twl = phy_get_drvdata(phy);
         enum omap_musb_vbus_id_status status;
 
-        /*
-         * Start in sleep state, we'll get called through set_suspend()
-         * callback when musb is runtime resumed and it's time to start.
-         */
-        __twl4030_phy_power(twl, 0);
-        twl->asleep = 1;
-
+        pm_runtime_get_sync(twl->dev);
         status = twl4030_usb_linkstat(twl);
         twl->linkstat = status;
 
-        if (status == OMAP_MUSB_ID_GROUND || status == OMAP_MUSB_VBUS_VALID) {
+        if (status == OMAP_MUSB_ID_GROUND || status == OMAP_MUSB_VBUS_VALID)
                 omap_musb_mailbox(twl->linkstat);
-                twl4030_phy_power_on(phy);
-        }
 
         sysfs_notify(&twl->dev->kobj, NULL, "vbus");
+        pm_runtime_mark_last_busy(twl->dev);
+        pm_runtime_put_autosuspend(twl->dev);
+
         return 0;
 }
 
@@ -650,6 +661,11 @@ static const struct phy_ops ops = {
         .owner          = THIS_MODULE,
 };
 
+static const struct dev_pm_ops twl4030_usb_pm_ops = {
+        SET_RUNTIME_PM_OPS(twl4030_usb_runtime_suspend,
+                           twl4030_usb_runtime_resume, NULL)
+};
+
 static int twl4030_usb_probe(struct platform_device *pdev)
 {
         struct twl4030_usb_data *pdata = dev_get_platdata(&pdev->dev);
@@ -726,6 +742,11 @@ static int twl4030_usb_probe(struct platform_device *pdev)
 
         ATOMIC_INIT_NOTIFIER_HEAD(&twl->phy.notifier);
 
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_runtime_set_autosuspend_delay(&pdev->dev, 2000);
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_get_sync(&pdev->dev);
+
         /* Our job is to use irqs and status from the power module
          * to keep the transceiver disabled when nothing's connected.
          *
@@ -744,6 +765,9 @@ static int twl4030_usb_probe(struct platform_device *pdev)
                 return status;
         }
 
+        pm_runtime_mark_last_busy(&pdev->dev);
+        pm_runtime_put_autosuspend(twl->dev);
+
         dev_info(&pdev->dev, "Initialized TWL4030 USB module\n");
         return 0;
 }
@@ -753,6 +777,7 @@ static int twl4030_usb_remove(struct platform_device *pdev)
         struct twl4030_usb *twl = platform_get_drvdata(pdev);
         int val;
 
+        pm_runtime_get_sync(twl->dev);
         cancel_delayed_work(&twl->id_workaround_work);
         device_remove_file(twl->dev, &dev_attr_vbus);
 
@@ -772,9 +797,8 @@ static int twl4030_usb_remove(struct platform_device *pdev)
 
         /* disable complete OTG block */
         twl4030_usb_clear_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
-
-        if (!twl->asleep)
-                twl4030_phy_power(twl, 0);
+        pm_runtime_mark_last_busy(twl->dev);
+        pm_runtime_put(twl->dev);
 
         return 0;
 }
@@ -792,6 +816,7 @@ static struct platform_driver twl4030_usb_driver = {
         .remove         = twl4030_usb_remove,
         .driver         = {
                 .name   = "twl4030_usb",
+                .pm     = &twl4030_usb_pm_ops,
                 .owner  = THIS_MODULE,
                 .of_match_table = of_match_ptr(twl4030_usb_id_table),
         },
diff --git a/drivers/usb/chipidea/ci_hdrc_msm.c b/drivers/usb/chipidea/ci_hdrc_msm.c
index d72b9d2de2c5..4935ac38fd00 100644
--- a/drivers/usb/chipidea/ci_hdrc_msm.c
+++ b/drivers/usb/chipidea/ci_hdrc_msm.c
@@ -20,13 +20,13 @@
 static void ci_hdrc_msm_notify_event(struct ci_hdrc *ci, unsigned event)
 {
         struct device *dev = ci->gadget.dev.parent;
-        int val;
 
         switch (event) {
         case CI_HDRC_CONTROLLER_RESET_EVENT:
                 dev_dbg(dev, "CI_HDRC_CONTROLLER_RESET_EVENT received\n");
                 writel(0, USB_AHBBURST);
                 writel(0, USB_AHBMODE);
+                usb_phy_init(ci->transceiver);
                 break;
         case CI_HDRC_CONTROLLER_STOPPED_EVENT:
                 dev_dbg(dev, "CI_HDRC_CONTROLLER_STOPPED_EVENT received\n");
@@ -34,10 +34,7 @@ static void ci_hdrc_msm_notify_event(struct ci_hdrc *ci, unsigned event)
                  * Put the transceiver in non-driving mode. Otherwise host
                  * may not detect soft-disconnection.
                  */
-                val = usb_phy_io_read(ci->transceiver, ULPI_FUNC_CTRL);
-                val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
-                val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
-                usb_phy_io_write(ci->transceiver, val, ULPI_FUNC_CTRL);
+                usb_phy_notify_disconnect(ci->transceiver, USB_SPEED_UNKNOWN);
                 break;
         default:
                 dev_dbg(dev, "unknown ci_hdrc event\n");
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 46f5161c7891..d481c99a20d7 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -5024,9 +5024,10 @@ static void hub_events(void)
 
                 hub = list_entry(tmp, struct usb_hub, event_list);
                 kref_get(&hub->kref);
+                hdev = hub->hdev;
+                usb_get_dev(hdev);
                 spin_unlock_irq(&hub_event_lock);
 
-                hdev = hub->hdev;
                 hub_dev = hub->intfdev;
                 intf = to_usb_interface(hub_dev);
                 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
@@ -5139,6 +5140,7 @@ static void hub_events(void)
                 usb_autopm_put_interface(intf);
  loop_disconnected:
                 usb_unlock_device(hdev);
+                usb_put_dev(hdev);
                 kref_put(&hub->kref, hub_release);
 
         } /* end while (1) */
diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c
index 7c9618e916e2..ce6071d65d51 100644
--- a/drivers/usb/dwc2/gadget.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -1649,6 +1649,7 @@ static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
                         dev_err(hsotg->dev,
                                 "%s: timeout flushing fifo (GRSTCTL=%08x)\n",
                                 __func__, val);
+                        break;
                 }
 
                 udelay(1);
@@ -2747,13 +2748,14 @@ static void s3c_hsotg_phy_enable(struct s3c_hsotg *hsotg)
 
         dev_dbg(hsotg->dev, "pdev 0x%p\n", pdev);
 
-        if (hsotg->phy) {
-                phy_init(hsotg->phy);
-                phy_power_on(hsotg->phy);
-        } else if (hsotg->uphy)
+        if (hsotg->uphy)
                 usb_phy_init(hsotg->uphy);
-        else if (hsotg->plat->phy_init)
+        else if (hsotg->plat && hsotg->plat->phy_init)
                 hsotg->plat->phy_init(pdev, hsotg->plat->phy_type);
+        else {
+                phy_init(hsotg->phy);
+                phy_power_on(hsotg->phy);
+        }
 }
 
 /**
@@ -2767,13 +2769,14 @@ static void s3c_hsotg_phy_disable(struct s3c_hsotg *hsotg)
 {
         struct platform_device *pdev = to_platform_device(hsotg->dev);
 
-        if (hsotg->phy) {
-                phy_power_off(hsotg->phy);
-                phy_exit(hsotg->phy);
-        } else if (hsotg->uphy)
+        if (hsotg->uphy)
                 usb_phy_shutdown(hsotg->uphy);
-        else if (hsotg->plat->phy_exit)
+        else if (hsotg->plat && hsotg->plat->phy_exit)
                 hsotg->plat->phy_exit(pdev, hsotg->plat->phy_type);
+        else {
+                phy_power_off(hsotg->phy);
+                phy_exit(hsotg->phy);
+        }
 }
 
 /**
@@ -2892,13 +2895,11 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget,
                 return -ENODEV;
 
         /* all endpoints should be shutdown */
-        for (ep = 0; ep < hsotg->num_of_eps; ep++)
+        for (ep = 1; ep < hsotg->num_of_eps; ep++)
                 s3c_hsotg_ep_disable(&hsotg->eps[ep].ep);
 
         spin_lock_irqsave(&hsotg->lock, flags);
 
-        s3c_hsotg_phy_disable(hsotg);
-
         if (!driver)
                 hsotg->driver = NULL;
 
@@ -2941,7 +2942,6 @@ static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
                 s3c_hsotg_phy_enable(hsotg);
                 s3c_hsotg_core_init(hsotg);
         } else {
-                s3c_hsotg_disconnect(hsotg);
                 s3c_hsotg_phy_disable(hsotg);
         }
 
@@ -3441,13 +3441,6 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
 
         hsotg->irq = ret;
 
-        ret = devm_request_irq(&pdev->dev, hsotg->irq, s3c_hsotg_irq, 0,
-                                dev_name(dev), hsotg);
-        if (ret < 0) {
-                dev_err(dev, "cannot claim IRQ\n");
-                goto err_clk;
-        }
-
         dev_info(dev, "regs %p, irq %d\n", hsotg->regs, hsotg->irq);
 
         hsotg->gadget.max_speed = USB_SPEED_HIGH;
@@ -3488,9 +3481,6 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
         if (hsotg->phy && (phy_get_bus_width(phy) == 8))
                 hsotg->phyif = GUSBCFG_PHYIF8;
 
-        if (hsotg->phy)
-                phy_init(hsotg->phy);
-
         /* usb phy enable */
         s3c_hsotg_phy_enable(hsotg);
 
@@ -3498,6 +3488,17 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
         s3c_hsotg_init(hsotg);
         s3c_hsotg_hw_cfg(hsotg);
 
+        ret = devm_request_irq(&pdev->dev, hsotg->irq, s3c_hsotg_irq, 0,
+                                dev_name(dev), hsotg);
+        if (ret < 0) {
+                s3c_hsotg_phy_disable(hsotg);
+                clk_disable_unprepare(hsotg->clk);
+                regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
+                                       hsotg->supplies);
+                dev_err(dev, "cannot claim IRQ\n");
+                goto err_clk;
+        }
+
         /* hsotg->num_of_eps holds number of EPs other than ep0 */
 
         if (hsotg->num_of_eps == 0) {
@@ -3582,9 +3583,6 @@ static int s3c_hsotg_remove(struct platform_device *pdev)
                 usb_gadget_unregister_driver(hsotg->driver);
         }
 
-        s3c_hsotg_phy_disable(hsotg);
-        if (hsotg->phy)
-                phy_exit(hsotg->phy);
         clk_disable_unprepare(hsotg->clk);
 
         return 0;
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index b769c1faaf03..9069984fe5cf 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -799,20 +799,21 @@ static int dwc3_remove(struct platform_device *pdev)
 {
         struct dwc3     *dwc = platform_get_drvdata(pdev);
 
+        dwc3_debugfs_exit(dwc);
+        dwc3_core_exit_mode(dwc);
+        dwc3_event_buffers_cleanup(dwc);
+        dwc3_free_event_buffers(dwc);
+
         usb_phy_set_suspend(dwc->usb2_phy, 1);
         usb_phy_set_suspend(dwc->usb3_phy, 1);
         phy_power_off(dwc->usb2_generic_phy);
         phy_power_off(dwc->usb3_generic_phy);
 
+        dwc3_core_exit(dwc);
+
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
-        dwc3_debugfs_exit(dwc);
-        dwc3_core_exit_mode(dwc);
-        dwc3_event_buffers_cleanup(dwc);
-        dwc3_free_event_buffers(dwc);
-        dwc3_core_exit(dwc);
-
         return 0;
 }
 
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 9dcfbe7cd5f5..fc0de3753648 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -576,9 +576,9 @@ 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);
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
-        device_for_each_child(&pdev->dev, NULL, dwc3_omap_remove_core);
 
         return 0;
 }
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 349cacc577d8..490a6ca00733 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -527,7 +527,7 @@ static int dwc3_gadget_set_ep_config(struct dwc3 *dwc, struct dwc3_ep *dep,
                 dep->stream_capable = true;
         }
 
-        if (usb_endpoint_xfer_isoc(desc))
+        if (!usb_endpoint_xfer_control(desc))
                 params.param1 |= DWC3_DEPCFG_XFER_IN_PROGRESS_EN;
 
         /*
@@ -1225,16 +1225,17 @@ static int dwc3_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request,
 
         int                             ret;
 
+        spin_lock_irqsave(&dwc->lock, flags);
         if (!dep->endpoint.desc) {
                 dev_dbg(dwc->dev, "trying to queue request %p to disabled %s\n",
                                 request, ep->name);
+                spin_unlock_irqrestore(&dwc->lock, flags);
                 return -ESHUTDOWN;
         }
 
         dev_vdbg(dwc->dev, "queing request %p to %s length %d\n",
                         request, ep->name, request->length);
 
-        spin_lock_irqsave(&dwc->lock, flags);
         ret = __dwc3_gadget_ep_queue(dep, req);
         spin_unlock_irqrestore(&dwc->lock, flags);
 
@@ -2041,12 +2042,6 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
                 dwc3_endpoint_transfer_complete(dwc, dep, event);
                 break;
         case DWC3_DEPEVT_XFERINPROGRESS:
-                if (!usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
-                        dev_dbg(dwc->dev, "%s is not an Isochronous endpoint\n",
-                                        dep->name);
-                        return;
-                }
-
                 dwc3_endpoint_transfer_complete(dwc, dep, event);
                 break;
         case DWC3_DEPEVT_XFERNOTREADY:
diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
index dc30adf15a01..0dc3552d1360 100644
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@ -155,6 +155,12 @@ struct ffs_io_data {
         struct usb_request *req;
 };
 
+struct ffs_desc_helper {
+        struct ffs_data *ffs;
+        unsigned interfaces_count;
+        unsigned eps_count;
+};
+
 static int  __must_check ffs_epfiles_create(struct ffs_data *ffs);
 static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);
 
@@ -1830,7 +1836,8 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
                                 u8 *valuep, struct usb_descriptor_header *desc,
                                 void *priv)
 {
-        struct ffs_data *ffs = priv;
+        struct ffs_desc_helper *helper = priv;
+        struct usb_endpoint_descriptor *d;
 
         ENTER();
 
@@ -1844,8 +1851,8 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
                  * encountered interface "n" then there are at least
                  * "n+1" interfaces.
                  */
-                if (*valuep >= ffs->interfaces_count)
-                        ffs->interfaces_count = *valuep + 1;
+                if (*valuep >= helper->interfaces_count)
+                        helper->interfaces_count = *valuep + 1;
                 break;
 
         case FFS_STRING:
@@ -1853,14 +1860,22 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
                  * Strings are indexed from 1 (0 is magic ;) reserved
                  * for languages list or some such)
                  */
-                if (*valuep > ffs->strings_count)
-                        ffs->strings_count = *valuep;
+                if (*valuep > helper->ffs->strings_count)
+                        helper->ffs->strings_count = *valuep;
                 break;
 
         case FFS_ENDPOINT:
-                /* Endpoints are indexed from 1 as well. */
-                if ((*valuep & USB_ENDPOINT_NUMBER_MASK) > ffs->eps_count)
-                        ffs->eps_count = (*valuep & USB_ENDPOINT_NUMBER_MASK);
+                d = (void *)desc;
+                helper->eps_count++;
+                if (helper->eps_count >= 15)
+                        return -EINVAL;
+                /* Check if descriptors for any speed were already parsed */
+                if (!helper->ffs->eps_count && !helper->ffs->interfaces_count)
+                        helper->ffs->eps_addrmap[helper->eps_count] =
+                                d->bEndpointAddress;
+                else if (helper->ffs->eps_addrmap[helper->eps_count] !=
+                                d->bEndpointAddress)
+                        return -EINVAL;
                 break;
         }
 
@@ -2053,6 +2068,7 @@ static int __ffs_data_got_descs(struct ffs_data *ffs,
         char *data = _data, *raw_descs;
         unsigned os_descs_count = 0, counts[3], flags;
         int ret = -EINVAL, i;
+        struct ffs_desc_helper helper;
 
         ENTER();
 
@@ -2101,13 +2117,29 @@ static int __ffs_data_got_descs(struct ffs_data *ffs,
 
         /* Read descriptors */
         raw_descs = data;
+        helper.ffs = ffs;
         for (i = 0; i < 3; ++i) {
                 if (!counts[i])
                         continue;
+                helper.interfaces_count = 0;
+                helper.eps_count = 0;
                 ret = ffs_do_descs(counts[i], data, len,
-                                   __ffs_data_do_entity, ffs);
+                                   __ffs_data_do_entity, &helper);
                 if (ret < 0)
                         goto error;
+                if (!ffs->eps_count && !ffs->interfaces_count) {
+                        ffs->eps_count = helper.eps_count;
+                        ffs->interfaces_count = helper.interfaces_count;
+                } else {
+                        if (ffs->eps_count != helper.eps_count) {
+                                ret = -EINVAL;
+                                goto error;
+                        }
+                        if (ffs->interfaces_count != helper.interfaces_count) {
+                                ret = -EINVAL;
+                                goto error;
+                        }
+                }
                 data += ret;
                 len  -= ret;
         }
@@ -2342,9 +2374,18 @@ static void ffs_event_add(struct ffs_data *ffs,
         spin_unlock_irqrestore(&ffs->ev.waitq.lock, flags);
 }
 
-
 /* Bind/unbind USB function hooks *******************************************/
 
+static int ffs_ep_addr2idx(struct ffs_data *ffs, u8 endpoint_address)
+{
+        int i;
+
+        for (i = 1; i < ARRAY_SIZE(ffs->eps_addrmap); ++i)
+                if (ffs->eps_addrmap[i] == endpoint_address)
+                        return i;
+        return -ENOENT;
+}
+
 static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
                                     struct usb_descriptor_header *desc,
                                     void *priv)
@@ -2378,7 +2419,10 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         if (!desc || desc->bDescriptorType != USB_DT_ENDPOINT)
                 return 0;
 
-        idx = (ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK) - 1;
+        idx = ffs_ep_addr2idx(func->ffs, ds->bEndpointAddress) - 1;
+        if (idx < 0)
+                return idx;
+
         ffs_ep = func->eps + idx;
 
         if (unlikely(ffs_ep->descs[ep_desc_id])) {
diff --git a/drivers/usb/gadget/function/u_fs.h b/drivers/usb/gadget/function/u_fs.h
index 63d6e71569c1..d48897e8ffeb 100644
--- a/drivers/usb/gadget/function/u_fs.h
+++ b/drivers/usb/gadget/function/u_fs.h
@@ -224,6 +224,8 @@ struct ffs_data {
         void                            *ms_os_descs_ext_prop_name_avail;
         void                            *ms_os_descs_ext_prop_data_avail;
 
+        u8                              eps_addrmap[15];
+
         unsigned short                  strings_count;
         unsigned short                  interfaces_count;
         unsigned short                  eps_count;
diff --git a/drivers/usb/gadget/udc/fusb300_udc.h b/drivers/usb/gadget/udc/fusb300_udc.h
index ae811d8d38b4..ad39f892d200 100644
--- a/drivers/usb/gadget/udc/fusb300_udc.h
+++ b/drivers/usb/gadget/udc/fusb300_udc.h
@@ -12,7 +12,7 @@
 
 
 #ifndef __FUSB300_UDC_H__
-#define __FUSB300_UDC_H_
+#define __FUSB300_UDC_H__
 
 #include <linux/kernel.h>
 
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index f4eac113690e..2e95715b50c0 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -3320,7 +3320,7 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
         if (stat & tmp) {
                 writel(tmp, &dev->regs->irqstat1);
                 if ((((stat & BIT(ROOT_PORT_RESET_INTERRUPT)) &&
-                                (readl(&dev->usb->usbstat) & mask)) ||
+                                ((readl(&dev->usb->usbstat) & mask) == 0)) ||
                                 ((readl(&dev->usb->usbctl) &
                                         BIT(VBUS_PIN)) == 0)) &&
                                 (dev->gadget.speed != USB_SPEED_UNKNOWN)) {
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index aa79e8749040..69aece31143a 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -468,7 +468,8 @@ static void xhci_hub_report_usb2_link_state(u32 *status, u32 status_reg)
 }
 
 /* Updates Link Status for super Speed port */
-static void xhci_hub_report_usb3_link_state(u32 *status, u32 status_reg)
+static void xhci_hub_report_usb3_link_state(struct xhci_hcd *xhci,
+                u32 *status, u32 status_reg)
 {
         u32 pls = status_reg & PORT_PLS_MASK;
 
@@ -507,7 +508,8 @@ static void xhci_hub_report_usb3_link_state(u32 *status, u32 status_reg)
                  * in which sometimes the port enters compliance mode
                  * caused by a delay on the host-device negotiation.
                  */
-                if (pls == USB_SS_PORT_LS_COMP_MOD)
+                if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
+                                (pls == USB_SS_PORT_LS_COMP_MOD))
                         pls |= USB_PORT_STAT_CONNECTION;
         }
 
@@ -666,7 +668,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd,
         }
         /* Update Port Link State */
         if (hcd->speed == HCD_USB3) {
-                xhci_hub_report_usb3_link_state(&status, raw_port_status);
+                xhci_hub_report_usb3_link_state(xhci, &status, raw_port_status);
                 /*
                  * Verify if all USB3 Ports Have entered U0 already.
                  * Delete Compliance Mode Timer if so.
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 8056d90690ee..8936211b161d 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1812,6 +1812,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
 
         if (xhci->lpm_command)
                 xhci_free_command(xhci, xhci->lpm_command);
+        xhci->lpm_command = NULL;
         if (xhci->cmd_ring)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
@@ -1819,7 +1820,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci_cleanup_command_queue(xhci);
 
         num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
-        for (i = 0; i < num_ports; i++) {
+        for (i = 0; i < num_ports && xhci->rh_bw; i++) {
                 struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table;
                 for (j = 0; j < XHCI_MAX_INTERVAL; j++) {
                         struct list_head *ep = &bwt->interval_bw[j].endpoints;
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index c020b094fe7d..c4a8fca8ae93 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -3971,13 +3971,21 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
         int ret;
 
         spin_lock_irqsave(&xhci->lock, flags);
-        if (max_exit_latency == xhci->devs[udev->slot_id]->current_mel) {
+
+        virt_dev = xhci->devs[udev->slot_id];
+
+        /*
+         * virt_dev might not exists yet if xHC resumed from hibernate (S4) and
+         * xHC was re-initialized. Exit latency will be set later after
+         * hub_port_finish_reset() is done and xhci->devs[] are re-allocated
+         */
+
+        if (!virt_dev || max_exit_latency == virt_dev->current_mel) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return 0;
         }
 
         /* Attempt to issue an Evaluate Context command to change the MEL. */
-        virt_dev = xhci->devs[udev->slot_id];
         command = xhci->lpm_command;
         ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
         if (!ctrl_ctx) {
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index 47ae6455d073..3ee133f675ab 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -39,6 +39,7 @@ struct cppi41_dma_channel {
         u32 transferred;
         u32 packet_sz;
         struct list_head tx_check;
+        int tx_zlp;
 };
 
 #define MUSB_DMA_NUM_CHANNELS 15
@@ -122,6 +123,8 @@ static void cppi41_trans_done(struct cppi41_dma_channel *cppi41_channel)
 {
         struct musb_hw_ep *hw_ep = cppi41_channel->hw_ep;
         struct musb *musb = hw_ep->musb;
+        void __iomem *epio = hw_ep->regs;
+        u16 csr;
 
         if (!cppi41_channel->prog_len ||
             (cppi41_channel->channel.status == MUSB_DMA_STATUS_FREE)) {
@@ -131,15 +134,24 @@ static void cppi41_trans_done(struct cppi41_dma_channel *cppi41_channel)
                         cppi41_channel->transferred;
                 cppi41_channel->channel.status = MUSB_DMA_STATUS_FREE;
                 cppi41_channel->channel.rx_packet_done = true;
+
+                /*
+                 * transmit ZLP using PIO mode for transfers which size is
+                 * multiple of EP packet size.
+                 */
+                if (cppi41_channel->tx_zlp && (cppi41_channel->transferred %
+                                        cppi41_channel->packet_sz) == 0) {
+                        musb_ep_select(musb->mregs, hw_ep->epnum);
+                        csr = MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY;
+                        musb_writew(epio, MUSB_TXCSR, csr);
+                }
                 musb_dma_completion(musb, hw_ep->epnum, cppi41_channel->is_tx);
         } else {
                 /* next iteration, reload */
                 struct dma_chan *dc = cppi41_channel->dc;
                 struct dma_async_tx_descriptor *dma_desc;
                 enum dma_transfer_direction direction;
-                u16 csr;
                 u32 remain_bytes;
-                void __iomem *epio = cppi41_channel->hw_ep->regs;
 
                 cppi41_channel->buf_addr += cppi41_channel->packet_sz;
 
@@ -363,6 +375,7 @@ static bool cppi41_configure_channel(struct dma_channel *channel,
         cppi41_channel->total_len = len;
         cppi41_channel->transferred = 0;
         cppi41_channel->packet_sz = packet_sz;
+        cppi41_channel->tx_zlp = (cppi41_channel->is_tx && mode) ? 1 : 0;
 
         /*
          * Due to AM335x' Advisory 1.0.13 we are not allowed to transfer more
diff --git a/drivers/usb/phy/phy-mxs-usb.c b/drivers/usb/phy/phy-mxs-usb.c
index c42bdf0c4a1f..00972eca04e7 100644
--- a/drivers/usb/phy/phy-mxs-usb.c
+++ b/drivers/usb/phy/phy-mxs-usb.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2013 Freescale Semiconductor, Inc.
+ * Copyright 2012-2014 Freescale Semiconductor, Inc.
  * Copyright (C) 2012 Marek Vasut <marex@denx.de>
  * on behalf of DENX Software Engineering GmbH
  *
@@ -125,7 +125,13 @@ static const struct mxs_phy_data imx6sl_phy_data = {
                 MXS_PHY_NEED_IP_FIX,
 };
 
+static const struct mxs_phy_data imx6sx_phy_data = {
+        .flags = MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS |
+                MXS_PHY_NEED_IP_FIX,
+};
+
 static const struct of_device_id mxs_phy_dt_ids[] = {
+        { .compatible = "fsl,imx6sx-usbphy", .data = &imx6sx_phy_data, },
         { .compatible = "fsl,imx6sl-usbphy", .data = &imx6sl_phy_data, },
         { .compatible = "fsl,imx6q-usbphy", .data = &imx6q_phy_data, },
         { .compatible = "fsl,imx23-usbphy", .data = &imx23_phy_data, },
diff --git a/drivers/usb/phy/phy-tegra-usb.c b/drivers/usb/phy/phy-tegra-usb.c
index 13b4fa287da8..886f1807a67b 100644
--- a/drivers/usb/phy/phy-tegra-usb.c
+++ b/drivers/usb/phy/phy-tegra-usb.c
@@ -878,8 +878,8 @@ static int utmi_phy_probe(struct tegra_usb_phy *tegra_phy,
                 return -ENOMEM;
         }
 
-        tegra_phy->config = devm_kzalloc(&pdev->dev,
-                sizeof(*tegra_phy->config), GFP_KERNEL);
+        tegra_phy->config = devm_kzalloc(&pdev->dev, sizeof(*config),
+                                         GFP_KERNEL);
         if (!tegra_phy->config) {
                 dev_err(&pdev->dev,
                         "unable to allocate memory for USB UTMIP config\n");
diff --git a/drivers/usb/renesas_usbhs/fifo.c b/drivers/usb/renesas_usbhs/fifo.c
index 4fd36530bfa3..b0c97a3f1bfe 100644
--- a/drivers/usb/renesas_usbhs/fifo.c
+++ b/drivers/usb/renesas_usbhs/fifo.c
@@ -108,19 +108,45 @@ static struct usbhs_pkt *__usbhsf_pkt_get(struct usbhs_pipe *pipe)
         return list_first_entry(&pipe->list, struct usbhs_pkt, node);
 }
 
+static void usbhsf_fifo_clear(struct usbhs_pipe *pipe,
+                              struct usbhs_fifo *fifo);
+static void usbhsf_fifo_unselect(struct usbhs_pipe *pipe,
+                                 struct usbhs_fifo *fifo);
+static struct dma_chan *usbhsf_dma_chan_get(struct usbhs_fifo *fifo,
+                                            struct usbhs_pkt *pkt);
+#define usbhsf_dma_map(p)       __usbhsf_dma_map_ctrl(p, 1)
+#define usbhsf_dma_unmap(p)     __usbhsf_dma_map_ctrl(p, 0)
+static int __usbhsf_dma_map_ctrl(struct usbhs_pkt *pkt, int map);
 struct usbhs_pkt *usbhs_pkt_pop(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt)
 {
         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+        struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
         unsigned long flags;
 
         /********************  spin lock ********************/
         usbhs_lock(priv, flags);
 
+        usbhs_pipe_disable(pipe);
+
         if (!pkt)
                 pkt = __usbhsf_pkt_get(pipe);
 
-        if (pkt)
+        if (pkt) {
+                struct dma_chan *chan = NULL;
+
+                if (fifo)
+                        chan = usbhsf_dma_chan_get(fifo, pkt);
+                if (chan) {
+                        dmaengine_terminate_all(chan);
+                        usbhsf_fifo_clear(pipe, fifo);
+                        usbhsf_dma_unmap(pkt);
+                }
+
                 __usbhsf_pkt_del(pkt);
+        }
+
+        if (fifo)
+                usbhsf_fifo_unselect(pipe, fifo);
 
         usbhs_unlock(priv, flags);
         /********************  spin unlock ******************/
@@ -544,6 +570,7 @@ static int usbhsf_pio_try_push(struct usbhs_pkt *pkt, int *is_done)
                 usbhsf_send_terminator(pipe, fifo);
 
         usbhsf_tx_irq_ctrl(pipe, !*is_done);
+        usbhs_pipe_running(pipe, !*is_done);
         usbhs_pipe_enable(pipe);
 
         dev_dbg(dev, "  send %d (%d/ %d/ %d/ %d)\n",
@@ -570,12 +597,21 @@ usbhs_fifo_write_busy:
          * retry in interrupt
          */
         usbhsf_tx_irq_ctrl(pipe, 1);
+        usbhs_pipe_running(pipe, 1);
 
         return ret;
 }
 
+static int usbhsf_pio_prepare_push(struct usbhs_pkt *pkt, int *is_done)
+{
+        if (usbhs_pipe_is_running(pkt->pipe))
+                return 0;
+
+        return usbhsf_pio_try_push(pkt, is_done);
+}
+
 struct usbhs_pkt_handle usbhs_fifo_pio_push_handler = {
-        .prepare = usbhsf_pio_try_push,
+        .prepare = usbhsf_pio_prepare_push,
         .try_run = usbhsf_pio_try_push,
 };
 
@@ -589,6 +625,9 @@ static int usbhsf_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
         if (usbhs_pipe_is_busy(pipe))
                 return 0;
 
+        if (usbhs_pipe_is_running(pipe))
+                return 0;
+
         /*
          * pipe enable to prepare packet receive
          */
@@ -597,6 +636,7 @@ static int usbhsf_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
 
         usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
         usbhs_pipe_enable(pipe);
+        usbhs_pipe_running(pipe, 1);
         usbhsf_rx_irq_ctrl(pipe, 1);
 
         return 0;
@@ -642,6 +682,7 @@ static int usbhsf_pio_try_pop(struct usbhs_pkt *pkt, int *is_done)
             (total_len < maxp)) {               /* short packet */
                 *is_done = 1;
                 usbhsf_rx_irq_ctrl(pipe, 0);
+                usbhs_pipe_running(pipe, 0);
                 usbhs_pipe_disable(pipe);       /* disable pipe first */
         }
 
@@ -763,8 +804,6 @@ static void __usbhsf_dma_ctrl(struct usbhs_pipe *pipe,
         usbhs_bset(priv, fifo->sel, DREQE, dreqe);
 }
 
-#define usbhsf_dma_map(p)       __usbhsf_dma_map_ctrl(p, 1)
-#define usbhsf_dma_unmap(p)     __usbhsf_dma_map_ctrl(p, 0)
 static int __usbhsf_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
@@ -805,6 +844,7 @@ static void xfer_work(struct work_struct *work)
         dev_dbg(dev, "  %s %d (%d/ %d)\n",
                 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);
@@ -836,6 +876,10 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
         if ((uintptr_t)(pkt->buf + pkt->actual) & 0x7) /* 8byte alignment */
                 goto usbhsf_pio_prepare_push;
 
+        /* return at this time if the pipe is running */
+        if (usbhs_pipe_is_running(pipe))
+                return 0;
+
         /* get enable DMA fifo */
         fifo = usbhsf_get_dma_fifo(priv, pkt);
         if (!fifo)
@@ -869,15 +913,29 @@ usbhsf_pio_prepare_push:
 static int usbhsf_dma_push_done(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
+        int is_short = pkt->trans % usbhs_pipe_get_maxpacket(pipe);
+
+        pkt->actual += pkt->trans;
 
-        pkt->actual = pkt->trans;
+        if (pkt->actual < pkt->length)
+                *is_done = 0;           /* there are remainder data */
+        else if (is_short)
+                *is_done = 1;           /* short packet */
+        else
+                *is_done = !pkt->zero;  /* send zero packet? */
 
-        *is_done = !pkt->zero;  /* send zero packet ? */
+        usbhs_pipe_running(pipe, !*is_done);
 
         usbhsf_dma_stop(pipe, pipe->fifo);
         usbhsf_dma_unmap(pkt);
         usbhsf_fifo_unselect(pipe, pipe->fifo);
 
+        if (!*is_done) {
+                /* change handler to PIO */
+                pkt->handler = &usbhs_fifo_pio_push_handler;
+                return pkt->handler->try_run(pkt, is_done);
+        }
+
         return 0;
 }
 
@@ -972,8 +1030,10 @@ static int usbhsf_dma_pop_done(struct usbhs_pkt *pkt, int *is_done)
         if ((pkt->actual == pkt->length) ||     /* receive all data */
             (pkt->trans < maxp)) {              /* short packet */
                 *is_done = 1;
+                usbhs_pipe_running(pipe, 0);
         } else {
                 /* re-enable */
+                usbhs_pipe_running(pipe, 0);
                 usbhsf_prepare_pop(pkt, is_done);
         }
 
diff --git a/drivers/usb/renesas_usbhs/mod.c b/drivers/usb/renesas_usbhs/mod.c
index 6a030b931a3b..9a705b15b3a1 100644
--- a/drivers/usb/renesas_usbhs/mod.c
+++ b/drivers/usb/renesas_usbhs/mod.c
@@ -213,7 +213,10 @@ static int usbhs_status_get_each_irq(struct usbhs_priv *priv,
 {
         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
         u16 intenb0, intenb1;
+        unsigned long flags;
 
+        /********************  spin lock ********************/
+        usbhs_lock(priv, flags);
         state->intsts0 = usbhs_read(priv, INTSTS0);
         state->intsts1 = usbhs_read(priv, INTSTS1);
 
@@ -229,6 +232,8 @@ static int usbhs_status_get_each_irq(struct usbhs_priv *priv,
                 state->bempsts &= mod->irq_bempsts;
                 state->brdysts &= mod->irq_brdysts;
         }
+        usbhs_unlock(priv, flags);
+        /********************  spin unlock ******************/
 
         /*
          * Check whether the irq enable registers and the irq status are set
diff --git a/drivers/usb/renesas_usbhs/pipe.c b/drivers/usb/renesas_usbhs/pipe.c
index 75fbcf6b102e..040bcefcb040 100644
--- a/drivers/usb/renesas_usbhs/pipe.c
+++ b/drivers/usb/renesas_usbhs/pipe.c
@@ -578,6 +578,19 @@ int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
         return usbhsp_flags_has(pipe, IS_DIR_HOST);
 }
 
+int usbhs_pipe_is_running(struct usbhs_pipe *pipe)
+{
+        return usbhsp_flags_has(pipe, IS_RUNNING);
+}
+
+void usbhs_pipe_running(struct usbhs_pipe *pipe, int running)
+{
+        if (running)
+                usbhsp_flags_set(pipe, IS_RUNNING);
+        else
+                usbhsp_flags_clr(pipe, IS_RUNNING);
+}
+
 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
 {
         u16 mask = (SQCLR | SQSET);
diff --git a/drivers/usb/renesas_usbhs/pipe.h b/drivers/usb/renesas_usbhs/pipe.h
index 406f36d050e4..d24a05972370 100644
--- a/drivers/usb/renesas_usbhs/pipe.h
+++ b/drivers/usb/renesas_usbhs/pipe.h
@@ -36,6 +36,7 @@ struct usbhs_pipe {
 #define USBHS_PIPE_FLAGS_IS_USED                (1 << 0)
 #define USBHS_PIPE_FLAGS_IS_DIR_IN              (1 << 1)
 #define USBHS_PIPE_FLAGS_IS_DIR_HOST            (1 << 2)
+#define USBHS_PIPE_FLAGS_IS_RUNNING             (1 << 3)
 
         struct usbhs_pkt_handle *handler;
 
@@ -80,6 +81,9 @@ int usbhs_pipe_probe(struct usbhs_priv *priv);
 void usbhs_pipe_remove(struct usbhs_priv *priv);
 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe);
 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe);
+int usbhs_pipe_is_running(struct usbhs_pipe *pipe);
+void usbhs_pipe_running(struct usbhs_pipe *pipe, int running);
+
 void usbhs_pipe_init(struct usbhs_priv *priv,
                      int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map));
 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe);
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 824ea5e7ec8b..dc72b924c399 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -728,6 +728,7 @@ static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
         { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
+        { USB_DEVICE(NOVITUS_VID, NOVITUS_BONO_E_PID) },
         { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S03_PID) },
         { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_59_PID) },
         { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_57A_PID) },
@@ -939,6 +940,8 @@ static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(FTDI_VID, FTDI_EKEY_CONV_USB_PID) },
         /* Infineon Devices */
         { USB_DEVICE_INTERFACE_NUMBER(INFINEON_VID, INFINEON_TRIBOARD_PID, 1) },
+        /* GE Healthcare devices */
+        { USB_DEVICE(GE_HEALTHCARE_VID, GE_HEALTHCARE_NEMO_TRACKER_PID) },
         { }                                     /* Terminating entry */
 };
 
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 70b0b1d88ae9..5937b2d242f2 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -837,6 +837,12 @@
 #define TELLDUS_TELLSTICK_PID           0x0C30  /* RF control dongle 433 MHz using FT232RL */
 
 /*
+ * NOVITUS printers
+ */
+#define NOVITUS_VID                     0x1a28
+#define NOVITUS_BONO_E_PID              0x6010
+
+/*
  * RT Systems programming cables for various ham radios
  */
 #define RTSYSTEMS_VID           0x2100  /* Vendor ID */
@@ -1385,3 +1391,9 @@
  * ekey biometric systems GmbH (http://ekey.net/)
  */
 #define FTDI_EKEY_CONV_USB_PID          0xCB08  /* Converter USB */
+
+/*
+ * GE Healthcare devices
+ */
+#define GE_HEALTHCARE_VID               0x1901
+#define GE_HEALTHCARE_NEMO_TRACKER_PID  0x0015
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 6f7f01eb556a..46179a0828eb 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -282,14 +282,19 @@ static const struct usb_device_id id_table[] = {
         /* Sierra Wireless HSPA Non-Composite Device */
         { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)},
         { USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */
-        { USB_DEVICE(0x1199, 0x68A3),   /* Sierra Wireless Direct IP modems */
+        /* Sierra Wireless Direct IP modems */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68A3, 0xFF, 0xFF, 0xFF),
+          .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
+        },
+        { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68AA, 0xFF, 0xFF, 0xFF),
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
         /* AT&T Direct IP LTE modems */
         { USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68AA, 0xFF, 0xFF, 0xFF),
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
-        { USB_DEVICE(0x0f3d, 0x68A3),   /* Airprime/Sierra Wireless Direct IP modems */
+        /* Airprime/Sierra Wireless Direct IP modems */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68A3, 0xFF, 0xFF, 0xFF),
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
 
diff --git a/drivers/usb/serial/zte_ev.c b/drivers/usb/serial/zte_ev.c
index 1a132e9e947a..c9bb107d5e5c 100644
--- a/drivers/usb/serial/zte_ev.c
+++ b/drivers/usb/serial/zte_ev.c
@@ -272,6 +272,14 @@ static void zte_ev_usb_serial_close(struct usb_serial_port *port)
 }
 
 static const struct usb_device_id id_table[] = {
+        { USB_DEVICE(0x19d2, 0xffec) },
+        { USB_DEVICE(0x19d2, 0xffee) },
+        { USB_DEVICE(0x19d2, 0xfff6) },
+        { USB_DEVICE(0x19d2, 0xfff7) },
+        { USB_DEVICE(0x19d2, 0xfff8) },
+        { USB_DEVICE(0x19d2, 0xfff9) },
+        { USB_DEVICE(0x19d2, 0xfffb) },
+        { USB_DEVICE(0x19d2, 0xfffc) },
         /* MG880 */
         { USB_DEVICE(0x19d2, 0xfffd) },
         { },
diff --git a/drivers/usb/storage/uas-detect.h b/drivers/usb/storage/uas-detect.h
index 503ac5c8d80f..8a6f371ed6e7 100644
--- a/drivers/usb/storage/uas-detect.h
+++ b/drivers/usb/storage/uas-detect.h
@@ -59,10 +59,6 @@ static int uas_use_uas_driver(struct usb_interface *intf,
         unsigned long flags = id->driver_info;
         int r, alt;
 
-        usb_stor_adjust_quirks(udev, &flags);
-
-        if (flags & US_FL_IGNORE_UAS)
-                return 0;
 
         alt = uas_find_uas_alt_setting(intf);
         if (alt < 0)
@@ -72,6 +68,29 @@ static int uas_use_uas_driver(struct usb_interface *intf,
         if (r < 0)
                 return 0;
 
+        /*
+         * ASM1051 and older ASM1053 devices have the same usb-id, and UAS is
+         * broken on the ASM1051, use the number of streams to differentiate.
+         * New ASM1053-s also support 32 streams, but have a different prod-id.
+         */
+        if (le16_to_cpu(udev->descriptor.idVendor) == 0x174c &&
+                        le16_to_cpu(udev->descriptor.idProduct) == 0x55aa) {
+                if (udev->speed < USB_SPEED_SUPER) {
+                        /* No streams info, assume ASM1051 */
+                        flags |= US_FL_IGNORE_UAS;
+                } else if (usb_ss_max_streams(&eps[1]->ss_ep_comp) == 32) {
+                        flags |= US_FL_IGNORE_UAS;
+                }
+        }
+
+        usb_stor_adjust_quirks(udev, &flags);
+
+        if (flags & US_FL_IGNORE_UAS) {
+                dev_warn(&udev->dev,
+                        "UAS is blacklisted for this device, using usb-storage instead\n");
+                return 0;
+        }
+
         if (udev->bus->sg_tablesize == 0) {
                 dev_warn(&udev->dev,
                         "The driver for the USB controller %s does not support scatter-gather which is\n",
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 7ef99b2f3aaf..60cfcbc78552 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -741,6 +741,12 @@ UNUSUAL_DEV(  0x059b, 0x0001, 0x0100, 0x0100,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
+UNUSUAL_DEV(  0x059b, 0x0040, 0x0100, 0x0100,
+                "Iomega",
+                "Jaz USB Adapter",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_SINGLE_LUN ),
+
 /* Reported by <Hendryk.Pfeiffer@gmx.de> */
 UNUSUAL_DEV(  0x059f, 0x0643, 0x0000, 0x0000,
                 "LaCie",
diff --git a/drivers/uwb/lc-dev.c b/drivers/uwb/lc-dev.c
index 80079b8fed15..d0303f0dbe15 100644
--- a/drivers/uwb/lc-dev.c
+++ b/drivers/uwb/lc-dev.c
@@ -431,16 +431,19 @@ void uwbd_dev_onair(struct uwb_rc *rc, struct uwb_beca_e *bce)
         uwb_dev->mac_addr = *bce->mac_addr;
         uwb_dev->dev_addr = bce->dev_addr;
         dev_set_name(&uwb_dev->dev, "%s", macbuf);
+
+        /* plug the beacon cache */
+        bce->uwb_dev = uwb_dev;
+        uwb_dev->bce = bce;
+        uwb_bce_get(bce);               /* released in uwb_dev_sys_release() */
+
         result = uwb_dev_add(uwb_dev, &rc->uwb_dev.dev, rc);
         if (result < 0) {
                 dev_err(dev, "new device %s: cannot instantiate device\n",
                         macbuf);
                 goto error_dev_add;
         }
-        /* plug the beacon cache */
-        bce->uwb_dev = uwb_dev;
-        uwb_dev->bce = bce;
-        uwb_bce_get(bce);               /* released in uwb_dev_sys_release() */
+
         dev_info(dev, "uwb device (mac %s dev %s) connected to %s %s\n",
                  macbuf, devbuf, rc->uwb_dev.dev.parent->bus->name,
                  dev_name(rc->uwb_dev.dev.parent));
@@ -448,6 +451,8 @@ void uwbd_dev_onair(struct uwb_rc *rc, struct uwb_beca_e *bce)
         return;
 
 error_dev_add:
+        bce->uwb_dev = NULL;
+        uwb_bce_put(bce);
         kfree(uwb_dev);
         return;
 }
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index 939df6973102..be88166349a1 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -396,6 +396,7 @@ header-y += un.h
 header-y += unistd.h
 header-y += unix_diag.h
 header-y += usbdevice_fs.h
+header-y += usbip.h
 header-y += utime.h
 header-y += utsname.h
 header-y += uuid.h
diff --git a/tools/usb/usbip/libsrc/usbip_common.h b/tools/usb/usbip/libsrc/usbip_common.h
index 5a0e95edf4df..15fe792e1e96 100644
--- a/tools/usb/usbip/libsrc/usbip_common.h
+++ b/tools/usb/usbip/libsrc/usbip_common.h
@@ -15,7 +15,7 @@
 #include <syslog.h>
 #include <unistd.h>
 #include <linux/usb/ch9.h>
-#include "../../uapi/usbip.h"
+#include <linux/usbip.h>
 
 #ifndef USBIDS_FILE
 #define USBIDS_FILE "/usr/share/hwdata/usb.ids"