Merge tag 'usb-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB patches from Greg KH:
 "Here's the big USB pull request for 3.15-rc1.

  The normal set of patches, lots of controller driver updates, and a
  smattering of individual USB driver updates as well.

  All have been in linux-next for a while"

* tag 'usb-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (249 commits)
  xhci: Transition maintainership to Mathias Nyman.
  USB: disable reset-resume when USB_QUIRK_RESET is set
  USB: unbind all interfaces before rebinding any
  usb: phy: Add ulpi IDs for SMSC USB3320 and TI TUSB1210
  usb: gadget: tcm_usb_gadget: stop format strings
  usb: gadget: f_fs: add missing spinlock and mutex unlock
  usb: gadget: composite: switch over to ERR_CAST()
  usb: gadget: inode: switch over to memdup_user()
  usb: gadget: f_subset: switch over to PTR_RET
  usb: gadget: lpc32xx_udc: fix wrong clk_put() sequence
  USB: keyspan: remove dead debugging code
  USB: serial: add missing newlines to dev_<level> messages.
  USB: serial: add missing braces
  USB: serial: continue to write on errors
  USB: serial: continue to read on errors
  USB: serial: make bulk_out_size a lower limit
  USB: cypress_m8: fix potential scheduling while atomic
  devicetree: bindings: document lsi,zevio-usb
  usb: chipidea: add support for USB OTG controller on LSI Zevio SoCs
  usb: chipidea: imx: Use dev_name() for ci_hdrc name to distinguish USBs
  ...

13 files changed, 674 insertions, 181 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index a9707da7da0b..e22b82660831 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -584,7 +584,6 @@ config FHCI_DEBUG
 config USB_U132_HCD
         tristate "Elan U132 Adapter Host Controller"
         depends on USB_FTDI_ELAN
-        default M
         help
           The U132 adapter is a USB to CardBus adapter specifically designed
           for PC cards that contain an OHCI host controller. Typical PC cards
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index 01536cfd361d..b3a0e11073aa 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Steven Brown <sbrown@cortland.com>
  * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
+ * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
  *
  * Derived from the ohci-ssb driver
  * Copyright 2007 Michael Buesch <m@bues.ch>
@@ -18,6 +19,7 @@
  *
  * Licensed under the GNU/GPL. See COPYING for details.
  */
+#include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
@@ -25,6 +27,7 @@
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/phy/phy.h>
 #include <linux/platform_device.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -33,6 +36,13 @@
 #include "ehci.h"
 
 #define DRIVER_DESC "EHCI generic platform driver"
+#define EHCI_MAX_CLKS 3
+#define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)
+
+struct ehci_platform_priv {
+        struct clk *clks[EHCI_MAX_CLKS];
+        struct phy *phy;
+};
 
 static const char hcd_name[] = "ehci-platform";
 
@@ -45,8 +55,6 @@ static int ehci_platform_reset(struct usb_hcd *hcd)
 
         hcd->has_tt = pdata->has_tt;
         ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
-        ehci->big_endian_desc = pdata->big_endian_desc;
-        ehci->big_endian_mmio = pdata->big_endian_mmio;
 
         if (pdata->pre_setup) {
                 retval = pdata->pre_setup(hcd);
@@ -64,38 +72,91 @@ static int ehci_platform_reset(struct usb_hcd *hcd)
         return 0;
 }
 
+static int ehci_platform_power_on(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk, ret;
+
+        for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) {
+                ret = clk_prepare_enable(priv->clks[clk]);
+                if (ret)
+                        goto err_disable_clks;
+        }
+
+        if (priv->phy) {
+                ret = phy_init(priv->phy);
+                if (ret)
+                        goto err_disable_clks;
+
+                ret = phy_power_on(priv->phy);
+                if (ret)
+                        goto err_exit_phy;
+        }
+
+        return 0;
+
+err_exit_phy:
+        phy_exit(priv->phy);
+err_disable_clks:
+        while (--clk >= 0)
+                clk_disable_unprepare(priv->clks[clk]);
+
+        return ret;
+}
+
+static void ehci_platform_power_off(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk;
+
+        if (priv->phy) {
+                phy_power_off(priv->phy);
+                phy_exit(priv->phy);
+        }
+
+        for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--)
+                if (priv->clks[clk])
+                        clk_disable_unprepare(priv->clks[clk]);
+}
+
 static struct hc_driver __read_mostly ehci_platform_hc_driver;
 
 static const struct ehci_driver_overrides platform_overrides __initconst = {
-        .reset =        ehci_platform_reset,
+        .reset =                ehci_platform_reset,
+        .extra_priv_size =      sizeof(struct ehci_platform_priv),
 };
 
-static struct usb_ehci_pdata ehci_platform_defaults;
+static struct usb_ehci_pdata ehci_platform_defaults = {
+        .power_on =             ehci_platform_power_on,
+        .power_suspend =        ehci_platform_power_off,
+        .power_off =            ehci_platform_power_off,
+};
 
 static int ehci_platform_probe(struct platform_device *dev)
 {
         struct usb_hcd *hcd;
         struct resource *res_mem;
-        struct usb_ehci_pdata *pdata;
-        int irq;
-        int err;
+        struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
+        struct ehci_platform_priv *priv;
+        struct ehci_hcd *ehci;
+        int err, irq, clk = 0;
 
         if (usb_disabled())
                 return -ENODEV;
 
         /*
-         * use reasonable defaults so platforms don't have to provide these.
-         * with DT probing on ARM, none of these are set.
+         * Use reasonable defaults so platforms don't have to provide these
+         * with DT probing on ARM.
          */
-        if (!dev_get_platdata(&dev->dev))
-                dev->dev.platform_data = &ehci_platform_defaults;
+        if (!pdata)
+                pdata = &ehci_platform_defaults;
 
         err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
         if (err)
                 return err;
 
-        pdata = dev_get_platdata(&dev->dev);
-
         irq = platform_get_irq(dev, 0);
         if (irq < 0) {
                 dev_err(&dev->dev, "no irq provided");
@@ -107,17 +168,72 @@ static int ehci_platform_probe(struct platform_device *dev)
                 return -ENXIO;
         }
 
+        hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
+                             dev_name(&dev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        platform_set_drvdata(dev, hcd);
+        dev->dev.platform_data = pdata;
+        priv = hcd_to_ehci_priv(hcd);
+        ehci = hcd_to_ehci(hcd);
+
+        if (pdata == &ehci_platform_defaults && dev->dev.of_node) {
+                if (of_property_read_bool(dev->dev.of_node, "big-endian-regs"))
+                        ehci->big_endian_mmio = 1;
+
+                if (of_property_read_bool(dev->dev.of_node, "big-endian-desc"))
+                        ehci->big_endian_desc = 1;
+
+                if (of_property_read_bool(dev->dev.of_node, "big-endian"))
+                        ehci->big_endian_mmio = ehci->big_endian_desc = 1;
+
+                priv->phy = devm_phy_get(&dev->dev, "usb");
+                if (IS_ERR(priv->phy)) {
+                        err = PTR_ERR(priv->phy);
+                        if (err == -EPROBE_DEFER)
+                                goto err_put_hcd;
+                        priv->phy = NULL;
+                }
+
+                for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
+                        priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
+                        if (IS_ERR(priv->clks[clk])) {
+                                err = PTR_ERR(priv->clks[clk]);
+                                if (err == -EPROBE_DEFER)
+                                        goto err_put_clks;
+                                priv->clks[clk] = NULL;
+                                break;
+                        }
+                }
+        }
+
+        if (pdata->big_endian_desc)
+                ehci->big_endian_desc = 1;
+        if (pdata->big_endian_mmio)
+                ehci->big_endian_mmio = 1;
+
+#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
+        if (ehci->big_endian_mmio) {
+                dev_err(&dev->dev,
+                        "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
+                err = -EINVAL;
+                goto err_put_clks;
+        }
+#endif
+#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
+        if (ehci->big_endian_desc) {
+                dev_err(&dev->dev,
+                        "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
+                err = -EINVAL;
+                goto err_put_clks;
+        }
+#endif
+
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        return err;
-        }
-
-        hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
-                             dev_name(&dev->dev));
-        if (!hcd) {
-                err = -ENOMEM;
-                goto err_power;
+                        goto err_put_clks;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -126,22 +242,28 @@ static int ehci_platform_probe(struct platform_device *dev)
         hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
         if (IS_ERR(hcd->regs)) {
                 err = PTR_ERR(hcd->regs);
-                goto err_put_hcd;
+                goto err_power;
         }
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
-                goto err_put_hcd;
+                goto err_power;
 
         device_wakeup_enable(hcd->self.controller);
         platform_set_drvdata(dev, hcd);
 
         return err;
 
-err_put_hcd:
-        usb_put_hcd(hcd);
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_put_clks:
+        while (--clk >= 0)
+                clk_put(priv->clks[clk]);
+err_put_hcd:
+        if (pdata == &ehci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        usb_put_hcd(hcd);
 
         return err;
 }
@@ -150,13 +272,19 @@ static int ehci_platform_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
+        struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk;
 
         usb_remove_hcd(hcd);
-        usb_put_hcd(hcd);
 
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
+                clk_put(priv->clks[clk]);
+
+        usb_put_hcd(hcd);
+
         if (pdata == &ehci_platform_defaults)
                 dev->dev.platform_data = NULL;
 
@@ -207,8 +335,10 @@ static int ehci_platform_resume(struct device *dev)
 static const struct of_device_id vt8500_ehci_ids[] = {
         { .compatible = "via,vt8500-ehci", },
         { .compatible = "wm,prizm-ehci", },
+        { .compatible = "generic-ehci", },
         {}
 };
+MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
 
 static const struct platform_device_id ehci_platform_table[] = {
         { "ehci-platform", 0 },
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index af28b748e87a..27ac6ad53c3d 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -38,10 +38,6 @@
 
 #include "ehci.h"
 
-#define TEGRA_USB_BASE                  0xC5000000
-#define TEGRA_USB2_BASE                 0xC5004000
-#define TEGRA_USB3_BASE                 0xC5008000
-
 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
 
 #define TEGRA_USB_DMA_ALIGN 32
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index e07669993f58..d0d8fadf7066 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -261,8 +261,44 @@ static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc)
                 dev_err(dev, "cannot listen to notifications: %d\n", result);
                 goto error_stop;
         }
+        /*
+         * If WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS is set,
+         *  disable transfer notifications.
+         */
+        if (hwahc->wa.quirks &
+                WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS) {
+                struct usb_host_interface *cur_altsetting =
+                        hwahc->wa.usb_iface->cur_altsetting;
+
+                result = usb_control_msg(hwahc->wa.usb_dev,
+                                usb_sndctrlpipe(hwahc->wa.usb_dev, 0),
+                                WA_REQ_ALEREON_DISABLE_XFER_NOTIFICATIONS,
+                                USB_DIR_OUT | USB_TYPE_VENDOR |
+                                        USB_RECIP_INTERFACE,
+                                WA_REQ_ALEREON_FEATURE_SET,
+                                cur_altsetting->desc.bInterfaceNumber,
+                                NULL, 0,
+                                USB_CTRL_SET_TIMEOUT);
+                /*
+                 * If we successfully sent the control message, start DTI here
+                 * because no transfer notifications will be received which is
+                 * where DTI is normally started.
+                 */
+                if (result == 0)
+                        result = wa_dti_start(&hwahc->wa);
+                else
+                        result = 0;     /* OK.  Continue normally. */
+
+                if (result < 0) {
+                        dev_err(dev, "cannot start DTI: %d\n", result);
+                        goto error_dti_start;
+                }
+        }
+
         return result;
 
+error_dti_start:
+        wa_nep_disarm(&hwahc->wa);
 error_stop:
         __wa_clear_feature(&hwahc->wa, WA_ENABLE);
         return result;
@@ -827,10 +863,12 @@ static void hwahc_disconnect(struct usb_interface *usb_iface)
 static struct usb_device_id hwahc_id_table[] = {
         /* Alereon 5310 */
         { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5310, 0xe0, 0x02, 0x01),
-          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC },
+          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC |
+                WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS },
         /* Alereon 5611 */
         { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5611, 0xe0, 0x02, 0x01),
-          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC },
+          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC |
+                WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS },
         /* FIXME: use class labels for this */
         { USB_INTERFACE_INFO(0xe0, 0x02, 0x01), },
         {},
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index 68f674cd095f..b6002c951c5c 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Michael Buesch <m@bues.ch>
  * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de>
+ * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
  *
  * Derived from the OCHI-SSB driver
  * Derived from the OHCI-PCI driver
@@ -14,11 +15,14 @@
  * Licensed under the GNU/GPL. See COPYING for details.
  */
 
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
 #include <linux/hrtimer.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/err.h>
+#include <linux/phy/phy.h>
 #include <linux/platform_device.h>
 #include <linux/usb/ohci_pdriver.h>
 #include <linux/usb.h>
@@ -27,6 +31,13 @@
 #include "ohci.h"
 
 #define DRIVER_DESC "OHCI generic platform driver"
+#define OHCI_MAX_CLKS 3
+#define hcd_to_ohci_priv(h) ((struct ohci_platform_priv *)hcd_to_ohci(h)->priv)
+
+struct ohci_platform_priv {
+        struct clk *clks[OHCI_MAX_CLKS];
+        struct phy *phy;
+};
 
 static const char hcd_name[] = "ohci-platform";
 
@@ -36,10 +47,6 @@ static int ohci_platform_reset(struct usb_hcd *hcd)
         struct usb_ohci_pdata *pdata = dev_get_platdata(&pdev->dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 
-        if (pdata->big_endian_desc)
-                ohci->flags |= OHCI_QUIRK_BE_DESC;
-        if (pdata->big_endian_mmio)
-                ohci->flags |= OHCI_QUIRK_BE_MMIO;
         if (pdata->no_big_frame_no)
                 ohci->flags |= OHCI_QUIRK_FRAME_NO;
         if (pdata->num_ports)
@@ -48,11 +55,67 @@ static int ohci_platform_reset(struct usb_hcd *hcd)
         return ohci_setup(hcd);
 }
 
+static int ohci_platform_power_on(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+        int clk, ret;
+
+        for (clk = 0; clk < OHCI_MAX_CLKS && priv->clks[clk]; clk++) {
+                ret = clk_prepare_enable(priv->clks[clk]);
+                if (ret)
+                        goto err_disable_clks;
+        }
+
+        if (priv->phy) {
+                ret = phy_init(priv->phy);
+                if (ret)
+                        goto err_disable_clks;
+
+                ret = phy_power_on(priv->phy);
+                if (ret)
+                        goto err_exit_phy;
+        }
+
+        return 0;
+
+err_exit_phy:
+        phy_exit(priv->phy);
+err_disable_clks:
+        while (--clk >= 0)
+                clk_disable_unprepare(priv->clks[clk]);
+
+        return ret;
+}
+
+static void ohci_platform_power_off(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+        int clk;
+
+        if (priv->phy) {
+                phy_power_off(priv->phy);
+                phy_exit(priv->phy);
+        }
+
+        for (clk = OHCI_MAX_CLKS - 1; clk >= 0; clk--)
+                if (priv->clks[clk])
+                        clk_disable_unprepare(priv->clks[clk]);
+}
+
 static struct hc_driver __read_mostly ohci_platform_hc_driver;
 
 static const struct ohci_driver_overrides platform_overrides __initconst = {
-        .product_desc = "Generic Platform OHCI controller",
-        .reset =        ohci_platform_reset,
+        .product_desc =         "Generic Platform OHCI controller",
+        .reset =                ohci_platform_reset,
+        .extra_priv_size =      sizeof(struct ohci_platform_priv),
+};
+
+static struct usb_ohci_pdata ohci_platform_defaults = {
+        .power_on =             ohci_platform_power_on,
+        .power_suspend =        ohci_platform_power_off,
+        .power_off =            ohci_platform_power_off,
 };
 
 static int ohci_platform_probe(struct platform_device *dev)
@@ -60,17 +123,24 @@ static int ohci_platform_probe(struct platform_device *dev)
         struct usb_hcd *hcd;
         struct resource *res_mem;
         struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
-        int irq;
-        int err = -ENOMEM;
-
-        if (!pdata) {
-                WARN_ON(1);
-                return -ENODEV;
-        }
+        struct ohci_platform_priv *priv;
+        struct ohci_hcd *ohci;
+        int err, irq, clk = 0;
 
         if (usb_disabled())
                 return -ENODEV;
 
+        /*
+         * Use reasonable defaults so platforms don't have to provide these
+         * with DT probing on ARM.
+         */
+        if (!pdata)
+                pdata = &ohci_platform_defaults;
+
+        err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
+
         irq = platform_get_irq(dev, 0);
         if (irq < 0) {
                 dev_err(&dev->dev, "no irq provided");
@@ -83,17 +153,72 @@ static int ohci_platform_probe(struct platform_device *dev)
                 return -ENXIO;
         }
 
+        hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
+                        dev_name(&dev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        platform_set_drvdata(dev, hcd);
+        dev->dev.platform_data = pdata;
+        priv = hcd_to_ohci_priv(hcd);
+        ohci = hcd_to_ohci(hcd);
+
+        if (pdata == &ohci_platform_defaults && dev->dev.of_node) {
+                if (of_property_read_bool(dev->dev.of_node, "big-endian-regs"))
+                        ohci->flags |= OHCI_QUIRK_BE_MMIO;
+
+                if (of_property_read_bool(dev->dev.of_node, "big-endian-desc"))
+                        ohci->flags |= OHCI_QUIRK_BE_DESC;
+
+                if (of_property_read_bool(dev->dev.of_node, "big-endian"))
+                        ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;
+
+                priv->phy = devm_phy_get(&dev->dev, "usb");
+                if (IS_ERR(priv->phy)) {
+                        err = PTR_ERR(priv->phy);
+                        if (err == -EPROBE_DEFER)
+                                goto err_put_hcd;
+                        priv->phy = NULL;
+                }
+
+                for (clk = 0; clk < OHCI_MAX_CLKS; clk++) {
+                        priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
+                        if (IS_ERR(priv->clks[clk])) {
+                                err = PTR_ERR(priv->clks[clk]);
+                                if (err == -EPROBE_DEFER)
+                                        goto err_put_clks;
+                                priv->clks[clk] = NULL;
+                                break;
+                        }
+                }
+        }
+
+        if (pdata->big_endian_desc)
+                ohci->flags |= OHCI_QUIRK_BE_DESC;
+        if (pdata->big_endian_mmio)
+                ohci->flags |= OHCI_QUIRK_BE_MMIO;
+
+#ifndef CONFIG_USB_OHCI_BIG_ENDIAN_MMIO
+        if (ohci->flags & OHCI_QUIRK_BE_MMIO) {
+                dev_err(&dev->dev,
+                        "Error: CONFIG_USB_OHCI_BIG_ENDIAN_MMIO not set\n");
+                err = -EINVAL;
+                goto err_put_clks;
+        }
+#endif
+#ifndef CONFIG_USB_OHCI_BIG_ENDIAN_DESC
+        if (ohci->flags & OHCI_QUIRK_BE_DESC) {
+                dev_err(&dev->dev,
+                        "Error: CONFIG_USB_OHCI_BIG_ENDIAN_DESC not set\n");
+                err = -EINVAL;
+                goto err_put_clks;
+        }
+#endif
+
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        return err;
-        }
-
-        hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
-                        dev_name(&dev->dev));
-        if (!hcd) {
-                err = -ENOMEM;
-                goto err_power;
+                        goto err_put_clks;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -102,11 +227,11 @@ static int ohci_platform_probe(struct platform_device *dev)
         hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
         if (IS_ERR(hcd->regs)) {
                 err = PTR_ERR(hcd->regs);
-                goto err_put_hcd;
+                goto err_power;
         }
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
-                goto err_put_hcd;
+                goto err_power;
 
         device_wakeup_enable(hcd->self.controller);
 
@@ -114,11 +239,17 @@ static int ohci_platform_probe(struct platform_device *dev)
 
         return err;
 
-err_put_hcd:
-        usb_put_hcd(hcd);
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_put_clks:
+        while (--clk >= 0)
+                clk_put(priv->clks[clk]);
+err_put_hcd:
+        if (pdata == &ohci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        usb_put_hcd(hcd);
 
         return err;
 }
@@ -127,13 +258,22 @@ static int ohci_platform_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
+        struct ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+        int clk;
 
         usb_remove_hcd(hcd);
-        usb_put_hcd(hcd);
 
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        for (clk = 0; clk < OHCI_MAX_CLKS && priv->clks[clk]; clk++)
+                clk_put(priv->clks[clk]);
+
+        usb_put_hcd(hcd);
+
+        if (pdata == &ohci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
         return 0;
 }
 
@@ -180,6 +320,12 @@ static int ohci_platform_resume(struct device *dev)
 #define ohci_platform_resume    NULL
 #endif /* CONFIG_PM */
 
+static const struct of_device_id ohci_platform_ids[] = {
+        { .compatible = "generic-ohci", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, ohci_platform_ids);
+
 static const struct platform_device_id ohci_platform_table[] = {
         { "ohci-platform", 0 },
         { }
@@ -200,6 +346,7 @@ static struct platform_driver ohci_platform_driver = {
                 .owner  = THIS_MODULE,
                 .name   = "ohci-platform",
                 .pm     = &ohci_platform_pm_ops,
+                .of_match_table = ohci_platform_ids,
         }
 };
 
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
index 44e6c9da8892..01833ab2b5c3 100644
--- a/drivers/usb/host/uhci-platform.c
+++ b/drivers/usb/host/uhci-platform.c
@@ -148,6 +148,7 @@ static void uhci_hcd_platform_shutdown(struct platform_device *op)
 }
 
 static const struct of_device_id platform_uhci_ids[] = {
+        { .compatible = "generic-uhci", },
         { .compatible = "platform-uhci", },
         {}
 };
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 9992fbfec85f..1ad6bc1951c7 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -732,9 +732,11 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 /* Set the U1 and U2 exit latencies. */
                 memcpy(buf, &usb_bos_descriptor,
                                 USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);
-                temp = readl(&xhci->cap_regs->hcs_params3);
-                buf[12] = HCS_U1_LATENCY(temp);
-                put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
+                if ((xhci->quirks & XHCI_LPM_SUPPORT)) {
+                        temp = readl(&xhci->cap_regs->hcs_params3);
+                        buf[12] = HCS_U1_LATENCY(temp);
+                        put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
+                }
 
                 /* Indicate whether the host has LTM support. */
                 temp = readl(&xhci->cap_regs->hcc_params);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index bce4391a0e7d..c089668308ad 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -149,14 +149,140 @@ static void xhci_link_rings(struct xhci_hcd *xhci, struct xhci_ring *ring,
         }
 }
 
+/*
+ * We need a radix tree for mapping physical addresses of TRBs to which stream
+ * ID they belong to.  We need to do this because the host controller won't tell
+ * us which stream ring the TRB came from.  We could store the stream ID in an
+ * event data TRB, but that doesn't help us for the cancellation case, since the
+ * endpoint may stop before it reaches that event data TRB.
+ *
+ * The radix tree maps the upper portion of the TRB DMA address to a ring
+ * segment that has the same upper portion of DMA addresses.  For example, say I
+ * have segments of size 1KB, that are always 1KB aligned.  A segment may
+ * start at 0x10c91000 and end at 0x10c913f0.  If I use the upper 10 bits, the
+ * key to the stream ID is 0x43244.  I can use the DMA address of the TRB to
+ * pass the radix tree a key to get the right stream ID:
+ *
+ *      0x10c90fff >> 10 = 0x43243
+ *      0x10c912c0 >> 10 = 0x43244
+ *      0x10c91400 >> 10 = 0x43245
+ *
+ * Obviously, only those TRBs with DMA addresses that are within the segment
+ * will make the radix tree return the stream ID for that ring.
+ *
+ * Caveats for the radix tree:
+ *
+ * The radix tree uses an unsigned long as a key pair.  On 32-bit systems, an
+ * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be
+ * 64-bits.  Since we only request 32-bit DMA addresses, we can use that as the
+ * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit
+ * PCI DMA addresses on a 64-bit system).  There might be a problem on 32-bit
+ * extended systems (where the DMA address can be bigger than 32-bits),
+ * if we allow the PCI dma mask to be bigger than 32-bits.  So don't do that.
+ */
+static int xhci_insert_segment_mapping(struct radix_tree_root *trb_address_map,
+                struct xhci_ring *ring,
+                struct xhci_segment *seg,
+                gfp_t mem_flags)
+{
+        unsigned long key;
+        int ret;
+
+        key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT);
+        /* Skip any segments that were already added. */
+        if (radix_tree_lookup(trb_address_map, key))
+                return 0;
+
+        ret = radix_tree_maybe_preload(mem_flags);
+        if (ret)
+                return ret;
+        ret = radix_tree_insert(trb_address_map,
+                        key, ring);
+        radix_tree_preload_end();
+        return ret;
+}
+
+static void xhci_remove_segment_mapping(struct radix_tree_root *trb_address_map,
+                struct xhci_segment *seg)
+{
+        unsigned long key;
+
+        key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT);
+        if (radix_tree_lookup(trb_address_map, key))
+                radix_tree_delete(trb_address_map, key);
+}
+
+static int xhci_update_stream_segment_mapping(
+                struct radix_tree_root *trb_address_map,
+                struct xhci_ring *ring,
+                struct xhci_segment *first_seg,
+                struct xhci_segment *last_seg,
+                gfp_t mem_flags)
+{
+        struct xhci_segment *seg;
+        struct xhci_segment *failed_seg;
+        int ret;
+
+        if (WARN_ON_ONCE(trb_address_map == NULL))
+                return 0;
+
+        seg = first_seg;
+        do {
+                ret = xhci_insert_segment_mapping(trb_address_map,
+                                ring, seg, mem_flags);
+                if (ret)
+                        goto remove_streams;
+                if (seg == last_seg)
+                        return 0;
+                seg = seg->next;
+        } while (seg != first_seg);
+
+        return 0;
+
+remove_streams:
+        failed_seg = seg;
+        seg = first_seg;
+        do {
+                xhci_remove_segment_mapping(trb_address_map, seg);
+                if (seg == failed_seg)
+                        return ret;
+                seg = seg->next;
+        } while (seg != first_seg);
+
+        return ret;
+}
+
+static void xhci_remove_stream_mapping(struct xhci_ring *ring)
+{
+        struct xhci_segment *seg;
+
+        if (WARN_ON_ONCE(ring->trb_address_map == NULL))
+                return;
+
+        seg = ring->first_seg;
+        do {
+                xhci_remove_segment_mapping(ring->trb_address_map, seg);
+                seg = seg->next;
+        } while (seg != ring->first_seg);
+}
+
+static int xhci_update_stream_mapping(struct xhci_ring *ring, gfp_t mem_flags)
+{
+        return xhci_update_stream_segment_mapping(ring->trb_address_map, ring,
+                        ring->first_seg, ring->last_seg, mem_flags);
+}
+
 /* XXX: Do we need the hcd structure in all these functions? */
 void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
 {
         if (!ring)
                 return;
 
-        if (ring->first_seg)
+        if (ring->first_seg) {
+                if (ring->type == TYPE_STREAM)
+                        xhci_remove_stream_mapping(ring);
                 xhci_free_segments_for_ring(xhci, ring->first_seg);
+        }
 
         kfree(ring);
 }
@@ -349,6 +475,21 @@ int xhci_ring_expansion(struct xhci_hcd *xhci, struct xhci_ring *ring,
         if (ret)
                 return -ENOMEM;
 
+        if (ring->type == TYPE_STREAM)
+                ret = xhci_update_stream_segment_mapping(ring->trb_address_map,
+                                                ring, first, last, flags);
+        if (ret) {
+                struct xhci_segment *next;
+                do {
+                        next = first->next;
+                        xhci_segment_free(xhci, first);
+                        if (first == last)
+                                break;
+                        first = next;
+                } while (true);
+                return ret;
+        }
+
         xhci_link_rings(xhci, ring, first, last, num_segs);
         xhci_dbg_trace(xhci, trace_xhci_dbg_ring_expansion,
                         "ring expansion succeed, now has %d segments",
@@ -434,12 +575,12 @@ static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
                 struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
 {
         struct device *dev = xhci_to_hcd(xhci)->self.controller;
+        size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;
 
-        if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
-                dma_free_coherent(dev,
-                                sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
+        if (size > MEDIUM_STREAM_ARRAY_SIZE)
+                dma_free_coherent(dev, size,
                                 stream_ctx, dma);
-        else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
+        else if (size <= SMALL_STREAM_ARRAY_SIZE)
                 return dma_pool_free(xhci->small_streams_pool,
                                 stream_ctx, dma);
         else
@@ -462,12 +603,12 @@ static struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
                 gfp_t mem_flags)
 {
         struct device *dev = xhci_to_hcd(xhci)->self.controller;
+        size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;
 
-        if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
-                return dma_alloc_coherent(dev,
-                                sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
+        if (size > MEDIUM_STREAM_ARRAY_SIZE)
+                return dma_alloc_coherent(dev, size,
                                 dma, mem_flags);
-        else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
+        else if (size <= SMALL_STREAM_ARRAY_SIZE)
                 return dma_pool_alloc(xhci->small_streams_pool,
                                 mem_flags, dma);
         else
@@ -510,36 +651,6 @@ struct xhci_ring *xhci_stream_id_to_ring(
  * The number of stream contexts in the stream context array may be bigger than
  * the number of streams the driver wants to use.  This is because the number of
  * stream context array entries must be a power of two.
- *
- * We need a radix tree for mapping physical addresses of TRBs to which stream
- * ID they belong to.  We need to do this because the host controller won't tell
- * us which stream ring the TRB came from.  We could store the stream ID in an
- * event data TRB, but that doesn't help us for the cancellation case, since the
- * endpoint may stop before it reaches that event data TRB.
- *
- * The radix tree maps the upper portion of the TRB DMA address to a ring
- * segment that has the same upper portion of DMA addresses.  For example, say I
- * have segments of size 1KB, that are always 64-byte aligned.  A segment may
- * start at 0x10c91000 and end at 0x10c913f0.  If I use the upper 10 bits, the
- * key to the stream ID is 0x43244.  I can use the DMA address of the TRB to
- * pass the radix tree a key to get the right stream ID:
- *
- *      0x10c90fff >> 10 = 0x43243
- *      0x10c912c0 >> 10 = 0x43244
- *      0x10c91400 >> 10 = 0x43245
- *
- * Obviously, only those TRBs with DMA addresses that are within the segment
- * will make the radix tree return the stream ID for that ring.
- *
- * Caveats for the radix tree:
- *
- * The radix tree uses an unsigned long as a key pair.  On 32-bit systems, an
- * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be
- * 64-bits.  Since we only request 32-bit DMA addresses, we can use that as the
- * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit
- * PCI DMA addresses on a 64-bit system).  There might be a problem on 32-bit
- * extended systems (where the DMA address can be bigger than 32-bits),
- * if we allow the PCI dma mask to be bigger than 32-bits.  So don't do that.
  */
 struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 unsigned int num_stream_ctxs,
@@ -548,7 +659,6 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
         struct xhci_stream_info *stream_info;
         u32 cur_stream;
         struct xhci_ring *cur_ring;
-        unsigned long key;
         u64 addr;
         int ret;
 
@@ -603,6 +713,7 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 if (!cur_ring)
                         goto cleanup_rings;
                 cur_ring->stream_id = cur_stream;
+                cur_ring->trb_address_map = &stream_info->trb_address_map;
                 /* Set deq ptr, cycle bit, and stream context type */
                 addr = cur_ring->first_seg->dma |
                         SCT_FOR_CTX(SCT_PRI_TR) |
@@ -612,10 +723,7 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
                                 cur_stream, (unsigned long long) addr);
 
-                key = (unsigned long)
-                        (cur_ring->first_seg->dma >> TRB_SEGMENT_SHIFT);
-                ret = radix_tree_insert(&stream_info->trb_address_map,
-                                key, cur_ring);
+                ret = xhci_update_stream_mapping(cur_ring, mem_flags);
                 if (ret) {
                         xhci_ring_free(xhci, cur_ring);
                         stream_info->stream_rings[cur_stream] = NULL;
@@ -635,9 +743,6 @@ cleanup_rings:
         for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
                 cur_ring = stream_info->stream_rings[cur_stream];
                 if (cur_ring) {
-                        addr = cur_ring->first_seg->dma;
-                        radix_tree_delete(&stream_info->trb_address_map,
-                                        addr >> TRB_SEGMENT_SHIFT);
                         xhci_ring_free(xhci, cur_ring);
                         stream_info->stream_rings[cur_stream] = NULL;
                 }
@@ -698,7 +803,6 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
 {
         int cur_stream;
         struct xhci_ring *cur_ring;
-        dma_addr_t addr;
 
         if (!stream_info)
                 return;
@@ -707,9 +811,6 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
                         cur_stream++) {
                 cur_ring = stream_info->stream_rings[cur_stream];
                 if (cur_ring) {
-                        addr = cur_ring->first_seg->dma;
-                        radix_tree_delete(&stream_info->trb_address_map,
-                                        addr >> TRB_SEGMENT_SHIFT);
                         xhci_ring_free(xhci, cur_ring);
                         stream_info->stream_rings[cur_stream] = NULL;
                 }
@@ -1711,7 +1812,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
 
         if (xhci->lpm_command)
                 xhci_free_command(xhci, xhci->lpm_command);
-        xhci->cmd_ring_reserved_trbs = 0;
         if (xhci->cmd_ring)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
@@ -1776,6 +1876,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         }
 
 no_bw:
+        xhci->cmd_ring_reserved_trbs = 0;
         xhci->num_usb2_ports = 0;
         xhci->num_usb3_ports = 0;
         xhci->num_active_eps = 0;
@@ -2274,11 +2375,12 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         /*
          * Initialize the ring segment pool.  The ring must be a contiguous
          * structure comprised of TRBs.  The TRBs must be 16 byte aligned,
-         * however, the command ring segment needs 64-byte aligned segments,
-         * so we pick the greater alignment need.
+         * however, the command ring segment needs 64-byte aligned segments
+         * and our use of dma addresses in the trb_address_map radix tree needs
+         * TRB_SEGMENT_SIZE alignment, so we pick the greater alignment need.
          */
         xhci->segment_pool = dma_pool_create("xHCI ring segments", dev,
-                        TRB_SEGMENT_SIZE, 64, xhci->page_size);
+                        TRB_SEGMENT_SIZE, TRB_SEGMENT_SIZE, xhci->page_size);
 
         /* See Table 46 and Note on Figure 55 */
         xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev,
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 04f986d9234f..47390e369cd4 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -190,6 +190,10 @@ static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         struct usb_hcd *hcd;
 
         driver = (struct hc_driver *)id->driver_data;
+
+        /* Prevent runtime suspending between USB-2 and USB-3 initialization */
+        pm_runtime_get_noresume(&dev->dev);
+
         /* Register the USB 2.0 roothub.
          * FIXME: USB core must know to register the USB 2.0 roothub first.
          * This is sort of silly, because we could just set the HCD driver flags
@@ -199,7 +203,7 @@ static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         retval = usb_hcd_pci_probe(dev, id);
 
         if (retval)
-                return retval;
+                goto put_runtime_pm;
 
         /* USB 2.0 roothub is stored in the PCI device now. */
         hcd = dev_get_drvdata(&dev->dev);
@@ -222,11 +226,11 @@ static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 goto put_usb3_hcd;
         /* Roothub already marked as USB 3.0 speed */
 
-        /* We know the LPM timeout algorithms for this host, let the USB core
-         * enable and disable LPM for devices under the USB 3.0 roothub.
-         */
-        if (xhci->quirks & XHCI_LPM_SUPPORT)
-                hcd_to_bus(xhci->shared_hcd)->root_hub->lpm_capable = 1;
+        if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
+                xhci->shared_hcd->can_do_streams = 1;
+
+        /* USB-2 and USB-3 roothubs initialized, allow runtime pm suspend */
+        pm_runtime_put_noidle(&dev->dev);
 
         return 0;
 
@@ -234,6 +238,8 @@ put_usb3_hcd:
         usb_put_hcd(xhci->shared_hcd);
 dealloc_usb2_hcd:
         usb_hcd_pci_remove(dev);
+put_runtime_pm:
+        pm_runtime_put_noidle(&dev->dev);
         return retval;
 }
 
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 8abda5c73ca1..151901ce1ba9 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -158,6 +158,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
          */
         *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
 
+        if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
+                xhci->shared_hcd->can_do_streams = 1;
+
         ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
         if (ret)
                 goto put_usb3_hcd;
@@ -226,6 +229,7 @@ static const struct dev_pm_ops xhci_plat_pm_ops = {
 
 #ifdef CONFIG_OF
 static const struct of_device_id usb_xhci_of_match[] = {
+        { .compatible = "generic-xhci" },
         { .compatible = "xhci-platform" },
         { },
 };
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 0ed64eb68e48..5f926bea5ab1 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -546,9 +546,9 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 struct xhci_dequeue_state *state)
 {
         struct xhci_virt_device *dev = xhci->devs[slot_id];
+        struct xhci_virt_ep *ep = &dev->eps[ep_index];
         struct xhci_ring *ep_ring;
         struct xhci_generic_trb *trb;
-        struct xhci_ep_ctx *ep_ctx;
         dma_addr_t addr;
 
         ep_ring = xhci_triad_to_transfer_ring(xhci, slot_id,
@@ -573,8 +573,16 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         /* Dig out the cycle state saved by the xHC during the stop ep cmd */
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                         "Finding endpoint context");
-        ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
-        state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq);
+        /* 4.6.9 the css flag is written to the stream context for streams */
+        if (ep->ep_state & EP_HAS_STREAMS) {
+                struct xhci_stream_ctx *ctx =
+                        &ep->stream_info->stream_ctx_array[stream_id];
+                state->new_cycle_state = 0x1 & le64_to_cpu(ctx->stream_ring);
+        } else {
+                struct xhci_ep_ctx *ep_ctx
+                        = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
+                state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq);
+        }
 
         state->new_deq_ptr = cur_td->last_trb;
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
@@ -892,6 +900,57 @@ remove_finished_td:
         /* Return to the event handler with xhci->lock re-acquired */
 }
 
+static void xhci_kill_ring_urbs(struct xhci_hcd *xhci, struct xhci_ring *ring)
+{
+        struct xhci_td *cur_td;
+
+        while (!list_empty(&ring->td_list)) {
+                cur_td = list_first_entry(&ring->td_list,
+                                struct xhci_td, td_list);
+                list_del_init(&cur_td->td_list);
+                if (!list_empty(&cur_td->cancelled_td_list))
+                        list_del_init(&cur_td->cancelled_td_list);
+                xhci_giveback_urb_in_irq(xhci, cur_td, -ESHUTDOWN);
+        }
+}
+
+static void xhci_kill_endpoint_urbs(struct xhci_hcd *xhci,
+                int slot_id, int ep_index)
+{
+        struct xhci_td *cur_td;
+        struct xhci_virt_ep *ep;
+        struct xhci_ring *ring;
+
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+        if ((ep->ep_state & EP_HAS_STREAMS) ||
+                        (ep->ep_state & EP_GETTING_NO_STREAMS)) {
+                int stream_id;
+
+                for (stream_id = 0; stream_id < ep->stream_info->num_streams;
+                                stream_id++) {
+                        xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
+                                        "Killing URBs for slot ID %u, ep index %u, stream %u",
+                                        slot_id, ep_index, stream_id + 1);
+                        xhci_kill_ring_urbs(xhci,
+                                        ep->stream_info->stream_rings[stream_id]);
+                }
+        } else {
+                ring = ep->ring;
+                if (!ring)
+                        return;
+                xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
+                                "Killing URBs for slot ID %u, ep index %u",
+                                slot_id, ep_index);
+                xhci_kill_ring_urbs(xhci, ring);
+        }
+        while (!list_empty(&ep->cancelled_td_list)) {
+                cur_td = list_first_entry(&ep->cancelled_td_list,
+                                struct xhci_td, cancelled_td_list);
+                list_del_init(&cur_td->cancelled_td_list);
+                xhci_giveback_urb_in_irq(xhci, cur_td, -ESHUTDOWN);
+        }
+}
+
 /* Watchdog timer function for when a stop endpoint command fails to complete.
  * In this case, we assume the host controller is broken or dying or dead.  The
  * host may still be completing some other events, so we have to be careful to
@@ -915,9 +974,6 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
 {
         struct xhci_hcd *xhci;
         struct xhci_virt_ep *ep;
-        struct xhci_virt_ep *temp_ep;
-        struct xhci_ring *ring;
-        struct xhci_td *cur_td;
         int ret, i, j;
         unsigned long flags;
 
@@ -974,34 +1030,8 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
         for (i = 0; i < MAX_HC_SLOTS; i++) {
                 if (!xhci->devs[i])
                         continue;
-                for (j = 0; j < 31; j++) {
-                        temp_ep = &xhci->devs[i]->eps[j];
-                        ring = temp_ep->ring;
-                        if (!ring)
-                                continue;
-                        xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
-                                        "Killing URBs for slot ID %u, "
-                                        "ep index %u", i, j);
-                        while (!list_empty(&ring->td_list)) {
-                                cur_td = list_first_entry(&ring->td_list,
-                                                struct xhci_td,
-                                                td_list);
-                                list_del_init(&cur_td->td_list);
-                                if (!list_empty(&cur_td->cancelled_td_list))
-                                        list_del_init(&cur_td->cancelled_td_list);
-                                xhci_giveback_urb_in_irq(xhci, cur_td,
-                                                -ESHUTDOWN);
-                        }
-                        while (!list_empty(&temp_ep->cancelled_td_list)) {
-                                cur_td = list_first_entry(
-                                                &temp_ep->cancelled_td_list,
-                                                struct xhci_td,
-                                                cancelled_td_list);
-                                list_del_init(&cur_td->cancelled_td_list);
-                                xhci_giveback_urb_in_irq(xhci, cur_td,
-                                                -ESHUTDOWN);
-                        }
-                }
+                for (j = 0; j < 31; j++)
+                        xhci_kill_endpoint_urbs(xhci, i, j);
         }
         spin_unlock_irqrestore(&xhci->lock, flags);
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
@@ -1073,17 +1103,18 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
         unsigned int stream_id;
         struct xhci_ring *ep_ring;
         struct xhci_virt_device *dev;
+        struct xhci_virt_ep *ep;
         struct xhci_ep_ctx *ep_ctx;
         struct xhci_slot_ctx *slot_ctx;
 
         ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         stream_id = TRB_TO_STREAM_ID(le32_to_cpu(trb->generic.field[2]));
         dev = xhci->devs[slot_id];
+        ep = &dev->eps[ep_index];
 
         ep_ring = xhci_stream_id_to_ring(dev, ep_index, stream_id);
         if (!ep_ring) {
-                xhci_warn(xhci, "WARN Set TR deq ptr command for "
-                                "freed stream ID %u\n",
+                xhci_warn(xhci, "WARN Set TR deq ptr command for freed stream ID %u\n",
                                 stream_id);
                 /* XXX: Harmless??? */
                 dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
@@ -1099,12 +1130,10 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
 
                 switch (cmd_comp_code) {
                 case COMP_TRB_ERR:
-                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because "
-                                        "of stream ID configuration\n");
+                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because of stream ID configuration\n");
                         break;
                 case COMP_CTX_STATE:
-                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed due "
-                                        "to incorrect slot or ep state.\n");
+                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed due to incorrect slot or ep state.\n");
                         ep_state = le32_to_cpu(ep_ctx->ep_info);
                         ep_state &= EP_STATE_MASK;
                         slot_state = le32_to_cpu(slot_ctx->dev_state);
@@ -1114,13 +1143,12 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
                                         slot_state, ep_state);
                         break;
                 case COMP_EBADSLT:
-                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed because "
-                                        "slot %u was not enabled.\n", slot_id);
+                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed because slot %u was not enabled.\n",
+                                        slot_id);
                         break;
                 default:
-                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown "
-                                        "completion code of %u.\n",
-                                  cmd_comp_code);
+                        xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown completion code of %u.\n",
+                                        cmd_comp_code);
                         break;
                 }
                 /* OK what do we do now?  The endpoint state is hosed, and we
@@ -1130,23 +1158,28 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
                  * cancelling URBs, which might not be an error...
                  */
         } else {
+                u64 deq;
+                /* 4.6.10 deq ptr is written to the stream ctx for streams */
+                if (ep->ep_state & EP_HAS_STREAMS) {
+                        struct xhci_stream_ctx *ctx =
+                                &ep->stream_info->stream_ctx_array[stream_id];
+                        deq = le64_to_cpu(ctx->stream_ring) & SCTX_DEQ_MASK;
+                } else {
+                        deq = le64_to_cpu(ep_ctx->deq) & ~EP_CTX_CYCLE_MASK;
+                }
                 xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
-                        "Successful Set TR Deq Ptr cmd, deq = @%08llx",
-                         le64_to_cpu(ep_ctx->deq));
-                if (xhci_trb_virt_to_dma(dev->eps[ep_index].queued_deq_seg,
-                                         dev->eps[ep_index].queued_deq_ptr) ==
-                    (le64_to_cpu(ep_ctx->deq) & ~(EP_CTX_CYCLE_MASK))) {
+                        "Successful Set TR Deq Ptr cmd, deq = @%08llx", deq);
+                if (xhci_trb_virt_to_dma(ep->queued_deq_seg,
+                                         ep->queued_deq_ptr) == deq) {
                         /* Update the ring's dequeue segment and dequeue pointer
                          * to reflect the new position.
                          */
                         update_ring_for_set_deq_completion(xhci, dev,
                                 ep_ring, ep_index);
                 } else {
-                        xhci_warn(xhci, "Mismatch between completed Set TR Deq "
-                                        "Ptr command & xHCI internal state.\n");
+                        xhci_warn(xhci, "Mismatch between completed Set TR Deq Ptr command & xHCI internal state.\n");
                         xhci_warn(xhci, "ep deq seg = %p, deq ptr = %p\n",
-                                        dev->eps[ep_index].queued_deq_seg,
-                                        dev->eps[ep_index].queued_deq_ptr);
+                                  ep->queued_deq_seg, ep->queued_deq_ptr);
                 }
         }
 
@@ -4070,6 +4103,7 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 trb_stream_id = STREAM_ID_FOR_TRB(stream_id);
+        u32 trb_sct = 0;
         u32 type = TRB_TYPE(TRB_SET_DEQ);
         struct xhci_virt_ep *ep;
 
@@ -4088,7 +4122,9 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         }
         ep->queued_deq_seg = deq_seg;
         ep->queued_deq_ptr = deq_ptr;
-        return queue_command(xhci, lower_32_bits(addr) | cycle_state,
+        if (stream_id)
+                trb_sct = SCT_FOR_TRB(SCT_PRI_TR);
+        return queue_command(xhci, lower_32_bits(addr) | trb_sct | cycle_state,
                         upper_32_bits(addr), trb_stream_id,
                         trb_slot_id | trb_ep_index | type, false);
 }
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 924a6ccdb622..8fe4e124ddd4 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -390,6 +390,10 @@ static int xhci_try_enable_msi(struct usb_hcd *hcd)
         }
 
  legacy_irq:
+        if (!strlen(hcd->irq_descr))
+                snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
+                         hcd->driver->description, hcd->self.busnum);
+
         /* fall back to legacy interrupt*/
         ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
                         hcd->irq_descr, hcd);
@@ -2678,6 +2682,20 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         return ret;
 }
 
+static void xhci_check_bw_drop_ep_streams(struct xhci_hcd *xhci,
+        struct xhci_virt_device *vdev, int i)
+{
+        struct xhci_virt_ep *ep = &vdev->eps[i];
+
+        if (ep->ep_state & EP_HAS_STREAMS) {
+                xhci_warn(xhci, "WARN: endpoint 0x%02x has streams on set_interface, freeing streams.\n",
+                                xhci_get_endpoint_address(i));
+                xhci_free_stream_info(xhci, ep->stream_info);
+                ep->stream_info = NULL;
+                ep->ep_state &= ~EP_HAS_STREAMS;
+        }
+}
+
 /* Called after one or more calls to xhci_add_endpoint() or
  * xhci_drop_endpoint().  If this call fails, the USB core is expected
  * to call xhci_reset_bandwidth().
@@ -2742,8 +2760,10 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         /* Free any rings that were dropped, but not changed. */
         for (i = 1; i < 31; ++i) {
                 if ((le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1))) &&
-                    !(le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1))))
+                    !(le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1)))) {
                         xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
+                        xhci_check_bw_drop_ep_streams(xhci, virt_dev, i);
+                }
         }
         xhci_zero_in_ctx(xhci, virt_dev);
         /*
@@ -2759,6 +2779,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                 if (virt_dev->eps[i].ring) {
                         xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
                 }
+                xhci_check_bw_drop_ep_streams(xhci, virt_dev, i);
                 virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
                 virt_dev->eps[i].new_ring = NULL;
         }
@@ -2954,7 +2975,7 @@ static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
         ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, true, __func__);
         if (ret <= 0)
                 return -EINVAL;
-        if (ep->ss_ep_comp.bmAttributes == 0) {
+        if (usb_ss_max_streams(&ep->ss_ep_comp) == 0) {
                 xhci_warn(xhci, "WARN: SuperSpeed Endpoint Companion"
                                 " descriptor for ep 0x%x does not support streams\n",
                                 ep->desc.bEndpointAddress);
@@ -3121,6 +3142,12 @@ int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
         xhci_dbg(xhci, "Driver wants %u stream IDs (including stream 0).\n",
                         num_streams);
 
+        /* MaxPSASize value 0 (2 streams) means streams are not supported */
+        if (HCC_MAX_PSA(xhci->hcc_params) < 4) {
+                xhci_dbg(xhci, "xHCI controller does not support streams.\n");
+                return -ENOSYS;
+        }
+
         config_cmd = xhci_alloc_command(xhci, true, true, mem_flags);
         if (!config_cmd) {
                 xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
@@ -3519,6 +3546,8 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                 struct xhci_virt_ep *ep = &virt_dev->eps[i];
 
                 if (ep->ep_state & EP_HAS_STREAMS) {
+                        xhci_warn(xhci, "WARN: endpoint 0x%02x has streams on device reset, freeing streams.\n",
+                                        xhci_get_endpoint_address(i));
                         xhci_free_stream_info(xhci, ep->stream_info);
                         ep->stream_info = NULL;
                         ep->ep_state &= ~EP_HAS_STREAMS;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 58ed9d088e63..d280e9213d08 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -703,6 +703,7 @@ struct xhci_ep_ctx {
 
 /* deq bitmasks */
 #define EP_CTX_CYCLE_MASK               (1 << 0)
+#define SCTX_DEQ_MASK                   (~0xfL)
 
 
 /**
@@ -1118,9 +1119,10 @@ enum xhci_setup_dev {
 #define TRB_TO_SUSPEND_PORT(p)          (((p) & (1 << 23)) >> 23)
 #define LAST_EP_INDEX                   30
 
-/* Set TR Dequeue Pointer command TRB fields */
+/* Set TR Dequeue Pointer command TRB fields, 6.4.3.9 */
 #define TRB_TO_STREAM_ID(p)             ((((p) & (0xffff << 16)) >> 16))
 #define STREAM_ID_FOR_TRB(p)            ((((p)) & 0xffff) << 16)
+#define SCT_FOR_TRB(p)                  (((p) << 1) & 0x7)
 
 
 /* Port Status Change Event TRB fields */
@@ -1341,6 +1343,7 @@ struct xhci_ring {
         unsigned int            num_trbs_free_temp;
         enum xhci_ring_type     type;
         bool                    last_td_was_short;
+        struct radix_tree_root  *trb_address_map;
 };
 
 struct xhci_erst_entry {