Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (229 commits)
  USB: remove unused usb_buffer_alloc and usb_buffer_free macros
  usb: musb: update gfp/slab.h includes
  USB: ftdi_sio: fix legacy SIO-device header
  USB: kl5usb105: reimplement using generic framework
  USB: kl5usb105: minor clean ups
  USB: kl5usb105: fix memory leak
  USB: io_ti: use kfifo to implement write buffering
  USB: io_ti: remove unsused private counter
  USB: ti_usb: use kfifo to implement write buffering
  USB: ir-usb: fix incorrect write-buffer length
  USB: aircable: fix incorrect write-buffer length
  USB: safe_serial: straighten out read processing
  USB: safe_serial: reimplement read using generic framework
  USB: safe_serial: reimplement write using generic framework
  usb-storage: always print quirks
  USB: usb-storage: trivial debug improvements
  USB: oti6858: use port write fifo
  USB: oti6858: use kfifo to implement write buffering
  USB: cypress_m8: use kfifo to implement write buffering
  USB: cypress_m8: remove unused drain define
  ...

Fix up conflicts (due to usb_buffer_alloc/free renaming) in
	drivers/input/tablet/acecad.c
	drivers/input/tablet/kbtab.c
	drivers/input/tablet/wacom_sys.c
	drivers/media/video/gspca/gspca.c
	sound/usb/usbaudio.c

38 files changed, 2358 insertions, 338 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 8d3df0397de3..f865be2276d4 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -207,6 +207,21 @@ config USB_OHCI_HCD
           To compile this driver as a module, choose M here: the
           module will be called ohci-hcd.
 
+config USB_OHCI_HCD_OMAP1
+        bool "OHCI support for OMAP1/2 chips"
+        depends on USB_OHCI_HCD && (ARCH_OMAP1 || ARCH_OMAP2)
+        default y
+        ---help---
+          Enables support for the OHCI controller on OMAP1/2 chips.
+
+config USB_OHCI_HCD_OMAP3
+        bool "OHCI support for OMAP3 and later chips"
+        depends on USB_OHCI_HCD && (ARCH_OMAP3 || ARCH_OMAP4)
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          OMAP3 and later chips.
+
 config USB_OHCI_HCD_PPC_SOC
         bool "OHCI support for on-chip PPC USB controller"
         depends on USB_OHCI_HCD && (STB03xxx || PPC_MPC52xx)
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index e3a74e75e822..faa61748db70 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -69,6 +69,15 @@ static void au1xxx_stop_ehc(void)
         au_sync();
 }
 
+static int au1xxx_ehci_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int ret = ehci_init(hcd);
+
+        ehci->need_io_watchdog = 0;
+        return ret;
+}
+
 static const struct hc_driver ehci_au1xxx_hc_driver = {
         .description            = hcd_name,
         .product_desc           = "Au1xxx EHCI",
@@ -86,7 +95,7 @@ static const struct hc_driver ehci_au1xxx_hc_driver = {
          * FIXME -- ehci_init() doesn't do enough here.
          * See ehci-ppc-soc for a complete implementation.
          */
-        .reset                  = ehci_init,
+        .reset                  = au1xxx_ehci_setup,
         .start                  = ehci_run,
         .stop                   = ehci_stop,
         .shutdown               = ehci_shutdown,
@@ -215,26 +224,17 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
                 msleep(10);
 
         /* Root hub was already suspended. Disable irq emission and
-         * mark HW unaccessible, bail out if RH has been resumed. Use
-         * the spinlock to properly synchronize with possible pending
-         * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
+         * mark HW unaccessible.  The PM and USB cores make sure that
+         * the root hub is either suspended or stopped.
          */
         spin_lock_irqsave(&ehci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
-                rc = -EINVAL;
-                goto bail;
-        }
+        ehci_prepare_ports_for_controller_suspend(ehci);
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         au1xxx_stop_ehc();
-
-bail:
         spin_unlock_irqrestore(&ehci->lock, flags);
 
         // could save FLADJ in case of Vaux power loss
@@ -264,6 +264,7 @@ static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
         if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
                 int     mask = INTR_MASK;
 
+                ehci_prepare_ports_for_controller_resume(ehci);
                 if (!hcd->self.root_hub->do_remote_wakeup)
                         mask &= ~STS_PCD;
                 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 0e26aa13f158..5cd967d28938 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -313,6 +313,7 @@ static int ehci_fsl_drv_suspend(struct device *dev)
         struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd));
         if (!fsl_deep_sleep())
                 return 0;
 
@@ -327,6 +328,7 @@ static int ehci_fsl_drv_resume(struct device *dev)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        ehci_prepare_ports_for_controller_resume(ehci);
         if (!fsl_deep_sleep())
                 return 0;
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 13ead00aecd5..ef3e88f0b3c3 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -31,13 +31,12 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
 #include <linux/debugfs.h>
 #include <linux/slab.h>
 
-#include "../core/hcd.h"
-
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <asm/irq.h>
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index c7178bcde67a..e7d3d8def282 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -106,12 +106,75 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
         ehci->owned_ports = 0;
 }
 
+static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
+                bool suspending)
+{
+        int             port;
+        u32             temp;
+
+        /* If remote wakeup is enabled for the root hub but disabled
+         * for the controller, we must adjust all the port wakeup flags
+         * when the controller is suspended or resumed.  In all other
+         * cases they don't need to be changed.
+         */
+        if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup ||
+                        device_may_wakeup(ehci_to_hcd(ehci)->self.controller))
+                return;
+
+        /* clear phy low-power mode before changing wakeup flags */
+        if (ehci->has_hostpc) {
+                port = HCS_N_PORTS(ehci->hcs_params);
+                while (port--) {
+                        u32 __iomem     *hostpc_reg;
+
+                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
+                                        + HOSTPC0 + 4 * port);
+                        temp = ehci_readl(ehci, hostpc_reg);
+                        ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg);
+                }
+                msleep(5);
+        }
+
+        port = HCS_N_PORTS(ehci->hcs_params);
+        while (port--) {
+                u32 __iomem     *reg = &ehci->regs->port_status[port];
+                u32             t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
+                u32             t2 = t1 & ~PORT_WAKE_BITS;
+
+                /* If we are suspending the controller, clear the flags.
+                 * If we are resuming the controller, set the wakeup flags.
+                 */
+                if (!suspending) {
+                        if (t1 & PORT_CONNECT)
+                                t2 |= PORT_WKOC_E | PORT_WKDISC_E;
+                        else
+                                t2 |= PORT_WKOC_E | PORT_WKCONN_E;
+                }
+                ehci_vdbg(ehci, "port %d, %08x -> %08x\n",
+                                port + 1, t1, t2);
+                ehci_writel(ehci, t2, reg);
+        }
+
+        /* enter phy low-power mode again */
+        if (ehci->has_hostpc) {
+                port = HCS_N_PORTS(ehci->hcs_params);
+                while (port--) {
+                        u32 __iomem     *hostpc_reg;
+
+                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
+                                        + HOSTPC0 + 4 * port);
+                        temp = ehci_readl(ehci, hostpc_reg);
+                        ehci_writel(ehci, temp | HOSTPC_PHCD, hostpc_reg);
+                }
+        }
+}
+
 static int ehci_bus_suspend (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         int                     port;
         int                     mask;
-        u32 __iomem             *hostpc_reg = NULL;
+        int                     changed;
 
         ehci_dbg(ehci, "suspend root hub\n");
 
@@ -155,15 +218,13 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
          */
         ehci->bus_suspended = 0;
         ehci->owned_ports = 0;
+        changed = 0;
         port = HCS_N_PORTS(ehci->hcs_params);
         while (port--) {
                 u32 __iomem     *reg = &ehci->regs->port_status [port];
                 u32             t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
-                u32             t2 = t1;
+                u32             t2 = t1 & ~PORT_WAKE_BITS;
 
-                if (ehci->has_hostpc)
-                        hostpc_reg = (u32 __iomem *)((u8 *)ehci->regs
-                                + HOSTPC0 + 4 * (port & 0xff));
                 /* keep track of which ports we suspend */
                 if (t1 & PORT_OWNER)
                         set_bit(port, &ehci->owned_ports);
@@ -172,40 +233,45 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                         set_bit(port, &ehci->bus_suspended);
                 }
 
-                /* enable remote wakeup on all ports */
+                /* enable remote wakeup on all ports, if told to do so */
                 if (hcd->self.root_hub->do_remote_wakeup) {
                         /* only enable appropriate wake bits, otherwise the
                          * hardware can not go phy low power mode. If a race
                          * condition happens here(connection change during bits
                          * set), the port change detection will finally fix it.
                          */
-                        if (t1 & PORT_CONNECT) {
+                        if (t1 & PORT_CONNECT)
                                 t2 |= PORT_WKOC_E | PORT_WKDISC_E;
-                                t2 &= ~PORT_WKCONN_E;
-                        } else {
+                        else
                                 t2 |= PORT_WKOC_E | PORT_WKCONN_E;
-                                t2 &= ~PORT_WKDISC_E;
-                        }
-                } else
-                        t2 &= ~PORT_WAKE_BITS;
+                }
 
                 if (t1 != t2) {
                         ehci_vdbg (ehci, "port %d, %08x -> %08x\n",
                                 port + 1, t1, t2);
                         ehci_writel(ehci, t2, reg);
-                        if (hostpc_reg) {
-                                u32     t3;
+                        changed = 1;
+                }
+        }
 
-                                spin_unlock_irq(&ehci->lock);
-                                msleep(5);/* 5ms for HCD enter low pwr mode */
-                                spin_lock_irq(&ehci->lock);
-                                t3 = ehci_readl(ehci, hostpc_reg);
-                                ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
-                                t3 = ehci_readl(ehci, hostpc_reg);
-                                ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
+        if (changed && ehci->has_hostpc) {
+                spin_unlock_irq(&ehci->lock);
+                msleep(5);      /* 5 ms for HCD to enter low-power mode */
+                spin_lock_irq(&ehci->lock);
+
+                port = HCS_N_PORTS(ehci->hcs_params);
+                while (port--) {
+                        u32 __iomem     *hostpc_reg;
+                        u32             t3;
+
+                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
+                                        + HOSTPC0 + 4 * port);
+                        t3 = ehci_readl(ehci, hostpc_reg);
+                        ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
+                        t3 = ehci_readl(ehci, hostpc_reg);
+                        ehci_dbg(ehci, "Port %d phy low-power mode %s\n",
                                         port, (t3 & HOSTPC_PHCD) ?
                                         "succeeded" : "failed");
-                        }
                 }
         }
 
@@ -291,6 +357,25 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         msleep(8);
         spin_lock_irq(&ehci->lock);
 
+        /* clear phy low-power mode before resume */
+        if (ehci->bus_suspended && ehci->has_hostpc) {
+                i = HCS_N_PORTS(ehci->hcs_params);
+                while (i--) {
+                        if (test_bit(i, &ehci->bus_suspended)) {
+                                u32 __iomem     *hostpc_reg;
+
+                                hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
+                                                + HOSTPC0 + 4 * i);
+                                temp = ehci_readl(ehci, hostpc_reg);
+                                ehci_writel(ehci, temp & ~HOSTPC_PHCD,
+                                                hostpc_reg);
+                        }
+                }
+                spin_unlock_irq(&ehci->lock);
+                msleep(5);
+                spin_lock_irq(&ehci->lock);
+        }
+
         /* manually resume the ports we suspended during bus_suspend() */
         i = HCS_N_PORTS (ehci->hcs_params);
         while (i--) {
@@ -659,7 +744,7 @@ static int ehci_hub_control (
                  * Even if OWNER is set, so the port is owned by the
                  * companion controller, khubd needs to be able to clear
                  * the port-change status bits (especially
-                 * USB_PORT_FEAT_C_CONNECTION).
+                 * USB_PORT_STAT_C_CONNECTION).
                  */
 
                 switch (wValue) {
@@ -675,16 +760,25 @@ static int ehci_hub_control (
                                 goto error;
                         if (ehci->no_selective_suspend)
                                 break;
-                        if (temp & PORT_SUSPEND) {
-                                if ((temp & PORT_PE) == 0)
-                                        goto error;
-                                /* resume signaling for 20 msec */
-                                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
-                                ehci_writel(ehci, temp | PORT_RESUME,
-                                                status_reg);
-                                ehci->reset_done [wIndex] = jiffies
-                                                + msecs_to_jiffies (20);
+                        if (!(temp & PORT_SUSPEND))
+                                break;
+                        if ((temp & PORT_PE) == 0)
+                                goto error;
+
+                        /* clear phy low-power mode before resume */
+                        if (hostpc_reg) {
+                                temp1 = ehci_readl(ehci, hostpc_reg);
+                                ehci_writel(ehci, temp1 & ~HOSTPC_PHCD,
+                                                hostpc_reg);
+                                spin_unlock_irqrestore(&ehci->lock, flags);
+                                msleep(5);/* wait to leave low-power mode */
+                                spin_lock_irqsave(&ehci->lock, flags);
                         }
+                        /* resume signaling for 20 msec */
+                        temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                        ehci_writel(ehci, temp | PORT_RESUME, status_reg);
+                        ehci->reset_done[wIndex] = jiffies
+                                        + msecs_to_jiffies(20);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(wIndex, &ehci->port_c_suspend);
@@ -729,12 +823,12 @@ static int ehci_hub_control (
 
                 // wPortChange bits
                 if (temp & PORT_CSC)
-                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                        status |= USB_PORT_STAT_C_CONNECTION << 16;
                 if (temp & PORT_PEC)
-                        status |= 1 << USB_PORT_FEAT_C_ENABLE;
+                        status |= USB_PORT_STAT_C_ENABLE << 16;
 
                 if ((temp & PORT_OCC) && !ignore_oc){
-                        status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
+                        status |= USB_PORT_STAT_C_OVERCURRENT << 16;
 
                         /*
                          * Hubs should disable port power on over-current.
@@ -791,7 +885,7 @@ static int ehci_hub_control (
                 if ((temp & PORT_RESET)
                                 && time_after_eq(jiffies,
                                         ehci->reset_done[wIndex])) {
-                        status |= 1 << USB_PORT_FEAT_C_RESET;
+                        status |= USB_PORT_STAT_C_RESET << 16;
                         ehci->reset_done [wIndex] = 0;
 
                         /* force reset to complete */
@@ -833,7 +927,7 @@ static int ehci_hub_control (
                  */
 
                 if (temp & PORT_CONNECT) {
-                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        status |= USB_PORT_STAT_CONNECTION;
                         // status may be from integrated TT
                         if (ehci->has_hostpc) {
                                 temp1 = ehci_readl(ehci, hostpc_reg);
@@ -842,11 +936,11 @@ static int ehci_hub_control (
                                 status |= ehci_port_speed(ehci, temp);
                 }
                 if (temp & PORT_PE)
-                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                        status |= USB_PORT_STAT_ENABLE;
 
                 /* maybe the port was unsuspended without our knowledge */
                 if (temp & (PORT_SUSPEND|PORT_RESUME)) {
-                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                        status |= USB_PORT_STAT_SUSPEND;
                 } else if (test_bit(wIndex, &ehci->suspended_ports)) {
                         clear_bit(wIndex, &ehci->suspended_ports);
                         ehci->reset_done[wIndex] = 0;
@@ -855,13 +949,13 @@ static int ehci_hub_control (
                 }
 
                 if (temp & PORT_OC)
-                        status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
+                        status |= USB_PORT_STAT_OVERCURRENT;
                 if (temp & PORT_RESET)
-                        status |= 1 << USB_PORT_FEAT_RESET;
+                        status |= USB_PORT_STAT_RESET;
                 if (temp & PORT_POWER)
-                        status |= 1 << USB_PORT_FEAT_POWER;
+                        status |= USB_PORT_STAT_POWER;
                 if (test_bit(wIndex, &ehci->port_c_suspend))
-                        status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                        status |= USB_PORT_STAT_C_SUSPEND << 16;
 
 #ifndef VERBOSE_DEBUG
         if (status & ~0xffff)   /* only if wPortChange is interesting */
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 0cd6c7795d90..5450e628157f 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -116,6 +116,8 @@
 #define OMAP_UHH_DEBUG_CSR                              (0x44)
 
 /* EHCI Register Set */
+#define EHCI_INSNREG04                                  (0xA0)
+#define EHCI_INSNREG04_DISABLE_UNSUSPEND                (1 << 5)
 #define EHCI_INSNREG05_ULPI                             (0xA4)
 #define EHCI_INSNREG05_ULPI_CONTROL_SHIFT               31
 #define EHCI_INSNREG05_ULPI_PORTSEL_SHIFT               24
@@ -352,8 +354,8 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
                 reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
 
         /* Bypass the TLL module for PHY mode operation */
-         if (omap_rev() <= OMAP3430_REV_ES2_1) {
-                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1 \n");
+        if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) {
+                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
                 if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY) ||
                         (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY) ||
                                 (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY))
@@ -382,6 +384,18 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
         dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
 
 
+        /*
+         * An undocumented "feature" in the OMAP3 EHCI controller,
+         * causes suspended ports to be taken out of suspend when
+         * the USBCMD.Run/Stop bit is cleared (for example when
+         * we do ehci_bus_suspend).
+         * This breaks suspend-resume if the root-hub is allowed
+         * to suspend. Writing 1 to this undocumented register bit
+         * disables this feature and restores normal behavior.
+         */
+        ehci_omap_writel(omap->ehci_base, EHCI_INSNREG04,
+                                EHCI_INSNREG04_DISABLE_UNSUSPEND);
+
         if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL) ||
                 (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL) ||
                         (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)) {
@@ -659,6 +673,9 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 goto err_add_hcd;
         }
 
+        /* root ports should always stay powered */
+        ehci_port_power(omap->ehci, 1);
+
         return 0;
 
 err_add_hcd:
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index ead5f4f2aa5a..d43d176161aa 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -109,6 +109,9 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 return retval;
 
         switch (pdev->vendor) {
+        case PCI_VENDOR_ID_NEC:
+                ehci->need_io_watchdog = 0;
+                break;
         case PCI_VENDOR_ID_INTEL:
                 ehci->need_io_watchdog = 0;
                 if (pdev->device == 0x27cc) {
@@ -284,23 +287,15 @@ static int ehci_pci_suspend(struct usb_hcd *hcd)
                 msleep(10);
 
         /* Root hub was already suspended. Disable irq emission and
-         * mark HW unaccessible, bail out if RH has been resumed. Use
-         * the spinlock to properly synchronize with possible pending
-         * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
+         * mark HW unaccessible.  The PM and USB cores make sure that
+         * the root hub is either suspended or stopped.
          */
         spin_lock_irqsave (&ehci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
-                rc = -EINVAL;
-                goto bail;
-        }
+        ehci_prepare_ports_for_controller_suspend(ehci);
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
- bail:
         spin_unlock_irqrestore (&ehci->lock, flags);
 
         // could save FLADJ in case of Vaux power loss
@@ -330,6 +325,7 @@ static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated)
                                 !hibernated) {
                 int     mask = INTR_MASK;
 
+                ehci_prepare_ports_for_controller_resume(ehci);
                 if (!hcd->self.root_hub->do_remote_wakeup)
                         mask &= ~STS_PCD;
                 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 89521775c567..11a79c4f4a9d 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -663,7 +663,7 @@ qh_urb_transaction (
          */
         i = urb->num_sgs;
         if (len > 0 && i > 0) {
-                sg = urb->sg->sg;
+                sg = urb->sg;
                 buf = sg_dma_address(sg);
 
                 /* urb->transfer_buffer_length may be smaller than the
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 556c0b48f3ab..650a687f2854 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -536,6 +536,16 @@ struct ehci_fstn {
 
 /*-------------------------------------------------------------------------*/
 
+/* Prepare the PORTSC wakeup flags during controller suspend/resume */
+
+#define ehci_prepare_ports_for_controller_suspend(ehci)         \
+                ehci_adjust_port_wakeup_flags(ehci, true);
+
+#define ehci_prepare_ports_for_controller_resume(ehci)          \
+                ehci_adjust_port_wakeup_flags(ehci, false);
+
+/*-------------------------------------------------------------------------*/
+
 #ifdef CONFIG_USB_EHCI_ROOT_HUB_TT
 
 /*
@@ -556,20 +566,20 @@ ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
                 case 0:
                         return 0;
                 case 1:
-                        return (1<<USB_PORT_FEAT_LOWSPEED);
+                        return USB_PORT_STAT_LOW_SPEED;
                 case 2:
                 default:
-                        return (1<<USB_PORT_FEAT_HIGHSPEED);
+                        return USB_PORT_STAT_HIGH_SPEED;
                 }
         }
-        return (1<<USB_PORT_FEAT_HIGHSPEED);
+        return USB_PORT_STAT_HIGH_SPEED;
 }
 
 #else
 
 #define ehci_is_TDI(e)                  (0)
 
-#define ehci_port_speed(ehci, portsc)   (1<<USB_PORT_FEAT_HIGHSPEED)
+#define ehci_port_speed(ehci, portsc)   USB_PORT_STAT_HIGH_SPEED
 #endif
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/fhci-dbg.c b/drivers/usb/host/fhci-dbg.c
index e799f86dab11..6fe550049119 100644
--- a/drivers/usb/host/fhci-dbg.c
+++ b/drivers/usb/host/fhci-dbg.c
@@ -20,7 +20,7 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/usb.h>
-#include "../core/hcd.h"
+#include <linux/usb/hcd.h>
 #include "fhci.h"
 
 void fhci_dbg_isr(struct fhci_hcd *fhci, int usb_er)
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 15379c636143..90453379a434 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -25,12 +25,12 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
 #include <linux/slab.h>
 #include <asm/qe.h>
 #include <asm/fsl_gtm.h>
-#include "../core/hcd.h"
 #include "fhci.h"
 
 void fhci_start_sof_timer(struct fhci_hcd *fhci)
diff --git a/drivers/usb/host/fhci-hub.c b/drivers/usb/host/fhci-hub.c
index 0cfaedc3e124..348fe62e94f7 100644
--- a/drivers/usb/host/fhci-hub.c
+++ b/drivers/usb/host/fhci-hub.c
@@ -22,9 +22,9 @@
 #include <linux/errno.h>
 #include <linux/io.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/gpio.h>
 #include <asm/qe.h>
-#include "../core/hcd.h"
 #include "fhci.h"
 
 /* virtual root hub specific descriptor */
diff --git a/drivers/usb/host/fhci-mem.c b/drivers/usb/host/fhci-mem.c
index 5591bfb499d1..b0b88f57a5ac 100644
--- a/drivers/usb/host/fhci-mem.c
+++ b/drivers/usb/host/fhci-mem.c
@@ -21,7 +21,7 @@
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/usb.h>
-#include "../core/hcd.h"
+#include <linux/usb/hcd.h>
 #include "fhci.h"
 
 static void init_td(struct td *td)
diff --git a/drivers/usb/host/fhci-q.c b/drivers/usb/host/fhci-q.c
index f73c92359beb..03be7494a476 100644
--- a/drivers/usb/host/fhci-q.c
+++ b/drivers/usb/host/fhci-q.c
@@ -22,7 +22,7 @@
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/usb.h>
-#include "../core/hcd.h"
+#include <linux/usb/hcd.h>
 #include "fhci.h"
 
 /* maps the hardware error code to the USB error code */
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index ff43747a614f..4f2cbdcc0273 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -24,9 +24,9 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <asm/qe.h>
 #include <asm/fsl_gtm.h>
-#include "../core/hcd.h"
 #include "fhci.h"
 
 static void recycle_frame(struct fhci_usb *usb, struct packet *pkt)
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 57013479d7f7..7be548ca2183 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -22,7 +22,7 @@
 #include <linux/list.h>
 #include <linux/io.h>
 #include <linux/usb.h>
-#include "../core/hcd.h"
+#include <linux/usb/hcd.h>
 #include "fhci.h"
 
 #define DUMMY_BD_BUFFER  0xdeadbeef
diff --git a/drivers/usb/host/fhci.h b/drivers/usb/host/fhci.h
index 72dae1c5ab38..71c3caaea4c1 100644
--- a/drivers/usb/host/fhci.h
+++ b/drivers/usb/host/fhci.h
@@ -20,13 +20,14 @@
 
 #include <linux/kernel.h>
 #include <linux/types.h>
+#include <linux/bug.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/kfifo.h>
 #include <linux/io.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <asm/qe.h>
-#include "../core/hcd.h"
 
 #define USB_CLOCK       48000000
 
@@ -515,9 +516,13 @@ static inline int cq_put(struct kfifo *kfifo, void *p)
 
 static inline void *cq_get(struct kfifo *kfifo)
 {
-        void *p = NULL;
+        unsigned int sz;
+        void *p;
+
+        sz = kfifo_out(kfifo, (void *)&p, sizeof(p));
+        if (sz != sizeof(p))
+                return NULL;
 
-        kfifo_out(kfifo, (void *)&p, sizeof(p));
         return p;
 }
 
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index 8a12f297645f..ca0e98d8e1f4 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -56,8 +56,8 @@
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 
-#include "../core/hcd.h"
 #include "imx21-hcd.h"
 
 #ifdef DEBUG
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 92de71dc7729..d9e82123de2a 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -65,6 +65,7 @@
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/isp116x.h>
+#include <linux/usb/hcd.h>
 #include <linux/platform_device.h>
 
 #include <asm/io.h>
@@ -72,7 +73,6 @@
 #include <asm/system.h>
 #include <asm/byteorder.h>
 
-#include "../core/hcd.h"
 #include "isp116x.h"
 
 #define DRIVER_VERSION  "03 Nov 2005"
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 217fb5170200..20a0dfe0fe36 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -77,6 +77,7 @@
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/usb/isp1362.h>
+#include <linux/usb/hcd.h>
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 #include <linux/io.h>
@@ -95,7 +96,6 @@ module_param(dbg_level, int, 0);
 #define STUB_DEBUG_FILE
 #endif
 
-#include "../core/hcd.h"
 #include "../core/usb.h"
 #include "isp1362.h"
 
@@ -1265,7 +1265,7 @@ static int isp1362_urb_enqueue(struct usb_hcd *hcd,
 
         /* don't submit to a dead or disabled port */
         if (!((isp1362_hcd->rhport[0] | isp1362_hcd->rhport[1]) &
-              (1 << USB_PORT_FEAT_ENABLE)) ||
+              USB_PORT_STAT_ENABLE) ||
             !HC_IS_RUNNING(hcd->state)) {
                 kfree(ep);
                 retval = -ENODEV;
@@ -2217,7 +2217,7 @@ static void create_debug_file(struct isp1362_hcd *isp1362_hcd)
 static void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
 {
         if (isp1362_hcd->pde)
-                remove_proc_entry(proc_filename, 0);
+                remove_proc_entry(proc_filename, NULL);
 }
 
 #endif
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 9f01293600b0..dbcafa29c775 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
@@ -21,7 +22,6 @@
 #include <asm/unaligned.h>
 #include <asm/cacheflush.h>
 
-#include "../core/hcd.h"
 #include "isp1760-hcd.h"
 
 static struct kmem_cache *qtd_cachep;
@@ -111,7 +111,7 @@ struct isp1760_qh {
         u32 ping;
 };
 
-#define ehci_port_speed(priv, portsc) (1 << USB_PORT_FEAT_HIGHSPEED)
+#define ehci_port_speed(priv, portsc) USB_PORT_STAT_HIGH_SPEED
 
 static unsigned int isp1760_readl(__u32 __iomem *regs)
 {
@@ -713,12 +713,11 @@ static int check_error(struct ptd *ptd)
         u32 dw3;
 
         dw3 = le32_to_cpu(ptd->dw3);
-        if (dw3 & DW3_HALT_BIT)
+        if (dw3 & DW3_HALT_BIT) {
                 error = -EPIPE;
 
-        if (dw3 & DW3_ERROR_BIT) {
-                printk(KERN_ERR "error bit is set in DW3\n");
-                error = -EPIPE;
+                if (dw3 & DW3_ERROR_BIT)
+                        pr_err("error bit is set in DW3\n");
         }
 
         if (dw3 & DW3_QTD_ACTIVE) {
@@ -1923,7 +1922,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                  * Even if OWNER is set, so the port is owned by the
                  * companion controller, khubd needs to be able to clear
                  * the port-change status bits (especially
-                 * USB_PORT_FEAT_C_CONNECTION).
+                 * USB_PORT_STAT_C_CONNECTION).
                  */
 
                 switch (wValue) {
@@ -1987,7 +1986,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 /* wPortChange bits */
                 if (temp & PORT_CSC)
-                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                        status |= USB_PORT_STAT_C_CONNECTION << 16;
 
 
                 /* whoever resumes must GetPortStatus to complete it!! */
@@ -2007,7 +2006,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         /* resume completed? */
                         else if (time_after_eq(jiffies,
                                         priv->reset_done)) {
-                                status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                                status |= USB_PORT_STAT_C_SUSPEND << 16;
                                 priv->reset_done = 0;
 
                                 /* stop resume signaling */
@@ -2031,7 +2030,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 if ((temp & PORT_RESET)
                                 && time_after_eq(jiffies,
                                         priv->reset_done)) {
-                        status |= 1 << USB_PORT_FEAT_C_RESET;
+                        status |= USB_PORT_STAT_C_RESET << 16;
                         priv->reset_done = 0;
 
                         /* force reset to complete */
@@ -2062,18 +2061,18 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         printk(KERN_ERR "Warning: PORT_OWNER is set\n");
 
                 if (temp & PORT_CONNECT) {
-                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        status |= USB_PORT_STAT_CONNECTION;
                         /* status may be from integrated TT */
                         status |= ehci_port_speed(priv, temp);
                 }
                 if (temp & PORT_PE)
-                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                        status |= USB_PORT_STAT_ENABLE;
                 if (temp & (PORT_SUSPEND|PORT_RESUME))
-                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                        status |= USB_PORT_STAT_SUSPEND;
                 if (temp & PORT_RESET)
-                        status |= 1 << USB_PORT_FEAT_RESET;
+                        status |= USB_PORT_STAT_RESET;
                 if (temp & PORT_POWER)
-                        status |= 1 << USB_PORT_FEAT_POWER;
+                        status |= USB_PORT_STAT_POWER;
 
                 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
                 break;
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 4293cfd28d61..8f0259eaa2c7 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -13,8 +13,8 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/usb/isp1760.h>
+#include <linux/usb/hcd.h>
 
-#include "../core/hcd.h"
 #include "isp1760-hcd.h"
 
 #ifdef CONFIG_PPC_OF
@@ -36,7 +36,7 @@ static int of_isp1760_probe(struct of_device *dev,
         struct resource memory;
         struct of_irq oirq;
         int virq;
-        u64 res_len;
+        resource_size_t res_len;
         int ret;
         const unsigned int *prop;
         unsigned int devflags = 0;
@@ -45,13 +45,12 @@ static int of_isp1760_probe(struct of_device *dev,
         if (ret)
                 return -ENXIO;
 
-        res = request_mem_region(memory.start, memory.end - memory.start + 1,
-                        dev_name(&dev->dev));
+        res_len = resource_size(&memory);
+
+        res = request_mem_region(memory.start, res_len, dev_name(&dev->dev));
         if (!res)
                 return -EBUSY;
 
-        res_len = memory.end - memory.start + 1;
-
         if (of_irq_map_one(dp, 0, &oirq)) {
                 ret = -ENODEV;
                 goto release_reg;
@@ -92,7 +91,7 @@ static int of_isp1760_probe(struct of_device *dev,
         return ret;
 
 release_reg:
-        release_mem_region(memory.start, memory.end - memory.start + 1);
+        release_mem_region(memory.start, res_len);
         return ret;
 }
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index afe59be23645..fc576557d8a5 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -32,6 +32,7 @@
 #include <linux/list.h>
 #include <linux/usb.h>
 #include <linux/usb/otg.h>
+#include <linux/usb/hcd.h>
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/workqueue.h>
@@ -43,7 +44,6 @@
 #include <asm/unaligned.h>
 #include <asm/byteorder.h>
 
-#include "../core/hcd.h"
 
 #define DRIVER_AUTHOR "Roman Weissgaerber, David Brownell"
 #define DRIVER_DESC "USB 1.1 'Open' Host Controller (OHCI) Driver"
@@ -1006,9 +1006,14 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_s3c2410_driver
 #endif
 
-#ifdef CONFIG_ARCH_OMAP
+#ifdef CONFIG_USB_OHCI_HCD_OMAP1
 #include "ohci-omap.c"
-#define PLATFORM_DRIVER         ohci_hcd_omap_driver
+#define OMAP1_PLATFORM_DRIVER   ohci_hcd_omap_driver
+#endif
+
+#ifdef CONFIG_USB_OHCI_HCD_OMAP3
+#include "ohci-omap3.c"
+#define OMAP3_PLATFORM_DRIVER   ohci_hcd_omap3_driver
 #endif
 
 #ifdef CONFIG_ARCH_LH7A404
@@ -1092,6 +1097,8 @@ MODULE_LICENSE ("GPL");
 
 #if     !defined(PCI_DRIVER) &&         \
         !defined(PLATFORM_DRIVER) &&    \
+        !defined(OMAP1_PLATFORM_DRIVER) &&      \
+        !defined(OMAP3_PLATFORM_DRIVER) &&      \
         !defined(OF_PLATFORM_DRIVER) && \
         !defined(SA1111_DRIVER) &&      \
         !defined(PS3_SYSTEM_BUS_DRIVER) && \
@@ -1133,6 +1140,18 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_platform;
 #endif
 
+#ifdef OMAP1_PLATFORM_DRIVER
+        retval = platform_driver_register(&OMAP1_PLATFORM_DRIVER);
+        if (retval < 0)
+                goto error_omap1_platform;
+#endif
+
+#ifdef OMAP3_PLATFORM_DRIVER
+        retval = platform_driver_register(&OMAP3_PLATFORM_DRIVER);
+        if (retval < 0)
+                goto error_omap3_platform;
+#endif
+
 #ifdef OF_PLATFORM_DRIVER
         retval = of_register_platform_driver(&OF_PLATFORM_DRIVER);
         if (retval < 0)
@@ -1200,6 +1219,14 @@ static int __init ohci_hcd_mod_init(void)
         platform_driver_unregister(&PLATFORM_DRIVER);
  error_platform:
 #endif
+#ifdef OMAP1_PLATFORM_DRIVER
+        platform_driver_unregister(&OMAP1_PLATFORM_DRIVER);
+ error_omap1_platform:
+#endif
+#ifdef OMAP3_PLATFORM_DRIVER
+        platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
+ error_omap3_platform:
+#endif
 #ifdef PS3_SYSTEM_BUS_DRIVER
         ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
  error_ps3:
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
new file mode 100644
index 000000000000..2cc8a504b18c
--- /dev/null
+++ b/drivers/usb/host/ohci-omap3.c
@@ -0,0 +1,735 @@
+/*
+ * ohci-omap3.c - driver for OHCI on OMAP3 and later processors
+ *
+ * Bus Glue for OMAP3 USBHOST 3 port OHCI controller
+ * This controller is also used in later OMAPs and AM35x chips
+ *
+ * Copyright (C) 2007-2010 Texas Instruments, Inc.
+ * Author: Vikram Pandita <vikram.pandita@ti.com>
+ * Author: Anand Gadiyar <gadiyar@ti.com>
+ *
+ * Based on ehci-omap.c and some other ohci glue layers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ * TODO (last updated Mar 10th, 2010):
+ *      - add kernel-doc
+ *      - Factor out code common to EHCI to a separate file
+ *      - Make EHCI and OHCI coexist together
+ *        - needs newer silicon versions to actually work
+ *        - the last one to be loaded currently steps on the other's toes
+ *      - Add hooks for configuring transceivers, etc. at init/exit
+ *      - Add aggressive clock-management code
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#include <plat/usb.h>
+
+/*
+ * OMAP USBHOST Register addresses: VIRTUAL ADDRESSES
+ *      Use ohci_omap_readl()/ohci_omap_writel() functions
+ */
+
+/* TLL Register Set */
+#define OMAP_USBTLL_REVISION                            (0x00)
+#define OMAP_USBTLL_SYSCONFIG                           (0x10)
+#define OMAP_USBTLL_SYSCONFIG_CACTIVITY                 (1 << 8)
+#define OMAP_USBTLL_SYSCONFIG_SIDLEMODE                 (1 << 3)
+#define OMAP_USBTLL_SYSCONFIG_ENAWAKEUP                 (1 << 2)
+#define OMAP_USBTLL_SYSCONFIG_SOFTRESET                 (1 << 1)
+#define OMAP_USBTLL_SYSCONFIG_AUTOIDLE                  (1 << 0)
+
+#define OMAP_USBTLL_SYSSTATUS                           (0x14)
+#define OMAP_USBTLL_SYSSTATUS_RESETDONE                 (1 << 0)
+
+#define OMAP_USBTLL_IRQSTATUS                           (0x18)
+#define OMAP_USBTLL_IRQENABLE                           (0x1C)
+
+#define OMAP_TLL_SHARED_CONF                            (0x30)
+#define OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN             (1 << 6)
+#define OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN            (1 << 5)
+#define OMAP_TLL_SHARED_CONF_USB_DIVRATION              (1 << 2)
+#define OMAP_TLL_SHARED_CONF_FCLK_REQ                   (1 << 1)
+#define OMAP_TLL_SHARED_CONF_FCLK_IS_ON                 (1 << 0)
+
+#define OMAP_TLL_CHANNEL_CONF(num)                      (0x040 + 0x004 * num)
+#define OMAP_TLL_CHANNEL_CONF_FSLSMODE_SHIFT            24
+#define OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF            (1 << 11)
+#define OMAP_TLL_CHANNEL_CONF_ULPI_ULPIAUTOIDLE         (1 << 10)
+#define OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE              (1 << 9)
+#define OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE               (1 << 8)
+#define OMAP_TLL_CHANNEL_CONF_CHANMODE_FSLS             (1 << 1)
+#define OMAP_TLL_CHANNEL_CONF_CHANEN                    (1 << 0)
+
+#define OMAP_TLL_CHANNEL_COUNT                          3
+
+/* UHH Register Set */
+#define OMAP_UHH_REVISION                               (0x00)
+#define OMAP_UHH_SYSCONFIG                              (0x10)
+#define OMAP_UHH_SYSCONFIG_MIDLEMODE                    (1 << 12)
+#define OMAP_UHH_SYSCONFIG_CACTIVITY                    (1 << 8)
+#define OMAP_UHH_SYSCONFIG_SIDLEMODE                    (1 << 3)
+#define OMAP_UHH_SYSCONFIG_ENAWAKEUP                    (1 << 2)
+#define OMAP_UHH_SYSCONFIG_SOFTRESET                    (1 << 1)
+#define OMAP_UHH_SYSCONFIG_AUTOIDLE                     (1 << 0)
+
+#define OMAP_UHH_SYSSTATUS                              (0x14)
+#define OMAP_UHH_SYSSTATUS_UHHRESETDONE                 (1 << 0)
+#define OMAP_UHH_SYSSTATUS_OHCIRESETDONE                (1 << 1)
+#define OMAP_UHH_SYSSTATUS_EHCIRESETDONE                (1 << 2)
+#define OMAP_UHH_HOSTCONFIG                             (0x40)
+#define OMAP_UHH_HOSTCONFIG_ULPI_BYPASS                 (1 << 0)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS              (1 << 0)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS              (1 << 11)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS              (1 << 12)
+#define OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN              (1 << 2)
+#define OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN              (1 << 3)
+#define OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN             (1 << 4)
+#define OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN              (1 << 5)
+#define OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS           (1 << 8)
+#define OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS           (1 << 9)
+#define OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS           (1 << 10)
+
+#define OMAP_UHH_DEBUG_CSR                              (0x44)
+
+/*-------------------------------------------------------------------------*/
+
+static inline void ohci_omap_writel(void __iomem *base, u32 reg, u32 val)
+{
+        __raw_writel(val, base + reg);
+}
+
+static inline u32 ohci_omap_readl(void __iomem *base, u32 reg)
+{
+        return __raw_readl(base + reg);
+}
+
+static inline void ohci_omap_writeb(void __iomem *base, u8 reg, u8 val)
+{
+        __raw_writeb(val, base + reg);
+}
+
+static inline u8 ohci_omap_readb(void __iomem *base, u8 reg)
+{
+        return __raw_readb(base + reg);
+}
+
+/*-------------------------------------------------------------------------*/
+
+struct ohci_hcd_omap3 {
+        struct ohci_hcd         *ohci;
+        struct device           *dev;
+
+        struct clk              *usbhost_ick;
+        struct clk              *usbhost2_120m_fck;
+        struct clk              *usbhost1_48m_fck;
+        struct clk              *usbtll_fck;
+        struct clk              *usbtll_ick;
+
+        /* port_mode: TLL/PHY, 2/3/4/6-PIN, DP-DM/DAT-SE0 */
+        enum ohci_omap3_port_mode       port_mode[OMAP3_HS_USB_PORTS];
+        void __iomem            *uhh_base;
+        void __iomem            *tll_base;
+        void __iomem            *ohci_base;
+
+        unsigned                es2_compatibility:1;
+};
+
+/*-------------------------------------------------------------------------*/
+
+static void ohci_omap3_clock_power(struct ohci_hcd_omap3 *omap, int on)
+{
+        if (on) {
+                clk_enable(omap->usbtll_ick);
+                clk_enable(omap->usbtll_fck);
+                clk_enable(omap->usbhost_ick);
+                clk_enable(omap->usbhost1_48m_fck);
+                clk_enable(omap->usbhost2_120m_fck);
+        } else {
+                clk_disable(omap->usbhost2_120m_fck);
+                clk_disable(omap->usbhost1_48m_fck);
+                clk_disable(omap->usbhost_ick);
+                clk_disable(omap->usbtll_fck);
+                clk_disable(omap->usbtll_ick);
+        }
+}
+
+static int ohci_omap3_init(struct usb_hcd *hcd)
+{
+        dev_dbg(hcd->self.controller, "starting OHCI controller\n");
+
+        return ohci_init(hcd_to_ohci(hcd));
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int ohci_omap3_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        /*
+         * RemoteWakeupConnected has to be set explicitly before
+         * calling ohci_run. The reset value of RWC is 0.
+         */
+        ohci->hc_control = OHCI_CTRL_RWC;
+        writel(OHCI_CTRL_RWC, &ohci->regs->control);
+
+        ret = ohci_run(ohci);
+
+        if (ret < 0) {
+                dev_err(hcd->self.controller, "can't start\n");
+                ohci_stop(hcd);
+        }
+
+        return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * convert the port-mode enum to a value we can use in the FSLSMODE
+ * field of USBTLL_CHANNEL_CONF
+ */
+static unsigned ohci_omap3_fslsmode(enum ohci_omap3_port_mode mode)
+{
+        switch (mode) {
+        case OMAP_OHCI_PORT_MODE_UNUSED:
+        case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
+                return 0x0;
+
+        case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
+                return 0x1;
+
+        case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
+                return 0x2;
+
+        case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
+                return 0x3;
+
+        case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
+                return 0x4;
+
+        case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
+                return 0x5;
+
+        case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
+                return 0x6;
+
+        case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
+                return 0x7;
+
+        case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
+                return 0xA;
+
+        case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
+                return 0xB;
+        default:
+                pr_warning("Invalid port mode, using default\n");
+                return 0x0;
+        }
+}
+
+static void ohci_omap3_tll_config(struct ohci_hcd_omap3 *omap)
+{
+        u32 reg;
+        int i;
+
+        /* Program TLL SHARED CONF */
+        reg = ohci_omap_readl(omap->tll_base, OMAP_TLL_SHARED_CONF);
+        reg &= ~OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN;
+        reg &= ~OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN;
+        reg |= OMAP_TLL_SHARED_CONF_USB_DIVRATION;
+        reg |= OMAP_TLL_SHARED_CONF_FCLK_IS_ON;
+        ohci_omap_writel(omap->tll_base, OMAP_TLL_SHARED_CONF, reg);
+
+        /* Program each TLL channel */
+        /*
+         * REVISIT: Only the 3-pin and 4-pin PHY modes have
+         * actually been tested.
+         */
+        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
+
+                /* Enable only those channels that are actually used */
+                if (omap->port_mode[i] == OMAP_OHCI_PORT_MODE_UNUSED)
+                        continue;
+
+                reg = ohci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
+                reg |= ohci_omap3_fslsmode(omap->port_mode[i])
+                                << OMAP_TLL_CHANNEL_CONF_FSLSMODE_SHIFT;
+                reg |= OMAP_TLL_CHANNEL_CONF_CHANMODE_FSLS;
+                reg |= OMAP_TLL_CHANNEL_CONF_CHANEN;
+                ohci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
+        }
+}
+
+/* omap3_start_ohci
+ *      - Start the TI USBHOST controller
+ */
+static int omap3_start_ohci(struct ohci_hcd_omap3 *omap, struct usb_hcd *hcd)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        u32 reg = 0;
+        int ret = 0;
+
+        dev_dbg(omap->dev, "starting TI OHCI USB Controller\n");
+
+        /* Get all the clock handles we need */
+        omap->usbhost_ick = clk_get(omap->dev, "usbhost_ick");
+        if (IS_ERR(omap->usbhost_ick)) {
+                dev_err(omap->dev, "could not get usbhost_ick\n");
+                ret =  PTR_ERR(omap->usbhost_ick);
+                goto err_host_ick;
+        }
+
+        omap->usbhost2_120m_fck = clk_get(omap->dev, "usbhost_120m_fck");
+        if (IS_ERR(omap->usbhost2_120m_fck)) {
+                dev_err(omap->dev, "could not get usbhost_120m_fck\n");
+                ret = PTR_ERR(omap->usbhost2_120m_fck);
+                goto err_host_120m_fck;
+        }
+
+        omap->usbhost1_48m_fck = clk_get(omap->dev, "usbhost_48m_fck");
+        if (IS_ERR(omap->usbhost1_48m_fck)) {
+                dev_err(omap->dev, "could not get usbhost_48m_fck\n");
+                ret = PTR_ERR(omap->usbhost1_48m_fck);
+                goto err_host_48m_fck;
+        }
+
+        omap->usbtll_fck = clk_get(omap->dev, "usbtll_fck");
+        if (IS_ERR(omap->usbtll_fck)) {
+                dev_err(omap->dev, "could not get usbtll_fck\n");
+                ret = PTR_ERR(omap->usbtll_fck);
+                goto err_tll_fck;
+        }
+
+        omap->usbtll_ick = clk_get(omap->dev, "usbtll_ick");
+        if (IS_ERR(omap->usbtll_ick)) {
+                dev_err(omap->dev, "could not get usbtll_ick\n");
+                ret = PTR_ERR(omap->usbtll_ick);
+                goto err_tll_ick;
+        }
+
+        /* Now enable all the clocks in the correct order */
+        ohci_omap3_clock_power(omap, 1);
+
+        /* perform TLL soft reset, and wait until reset is complete */
+        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
+                        OMAP_USBTLL_SYSCONFIG_SOFTRESET);
+
+        /* Wait for TLL reset to complete */
+        while (!(ohci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
+                        & OMAP_USBTLL_SYSSTATUS_RESETDONE)) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout)) {
+                        dev_dbg(omap->dev, "operation timed out\n");
+                        ret = -EINVAL;
+                        goto err_sys_status;
+                }
+        }
+
+        dev_dbg(omap->dev, "TLL reset done\n");
+
+        /* (1<<3) = no idle mode only for initial debugging */
+        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
+                        OMAP_USBTLL_SYSCONFIG_ENAWAKEUP |
+                        OMAP_USBTLL_SYSCONFIG_SIDLEMODE |
+                        OMAP_USBTLL_SYSCONFIG_CACTIVITY);
+
+
+        /* Put UHH in NoIdle/NoStandby mode */
+        reg = ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG);
+        reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
+                        | OMAP_UHH_SYSCONFIG_SIDLEMODE
+                        | OMAP_UHH_SYSCONFIG_CACTIVITY
+                        | OMAP_UHH_SYSCONFIG_MIDLEMODE);
+        reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
+        reg &= ~OMAP_UHH_SYSCONFIG_SOFTRESET;
+
+        ohci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg);
+
+        reg = ohci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG);
+
+        /* setup ULPI bypass and burst configurations */
+        reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN
+                        | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN
+                        | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN);
+        reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN;
+
+        /*
+         * REVISIT: Pi_CONNECT_STATUS controls MStandby
+         * assertion and Swakeup generation - let us not
+         * worry about this for now. OMAP HWMOD framework
+         * might take care of this later. If not, we can
+         * update these registers when adding aggressive
+         * clock management code.
+         *
+         * For now, turn off all the Pi_CONNECT_STATUS bits
+         *
+        if (omap->port_mode[0] == OMAP_OHCI_PORT_MODE_UNUSED)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
+        if (omap->port_mode[1] == OMAP_OHCI_PORT_MODE_UNUSED)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
+        if (omap->port_mode[2] == OMAP_OHCI_PORT_MODE_UNUSED)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
+         */
+        reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
+        reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
+        reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
+
+         if (omap->es2_compatibility) {
+                /*
+                 * All OHCI modes need to go through the TLL,
+                 * unlike in the EHCI case. So use UTMI mode
+                 * for all ports for OHCI, on ES2.x silicon
+                 */
+                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
+                reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
+        } else {
+                dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
+                if (omap->port_mode[0] == OMAP_OHCI_PORT_MODE_UNUSED)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+                else
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+
+                if (omap->port_mode[1] == OMAP_OHCI_PORT_MODE_UNUSED)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+                else
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+
+                if (omap->port_mode[2] == OMAP_OHCI_PORT_MODE_UNUSED)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+                else
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+
+        }
+        ohci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg);
+        dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
+
+        ohci_omap3_tll_config(omap);
+
+        return 0;
+
+err_sys_status:
+        ohci_omap3_clock_power(omap, 0);
+        clk_put(omap->usbtll_ick);
+
+err_tll_ick:
+        clk_put(omap->usbtll_fck);
+
+err_tll_fck:
+        clk_put(omap->usbhost1_48m_fck);
+
+err_host_48m_fck:
+        clk_put(omap->usbhost2_120m_fck);
+
+err_host_120m_fck:
+        clk_put(omap->usbhost_ick);
+
+err_host_ick:
+        return ret;
+}
+
+static void omap3_stop_ohci(struct ohci_hcd_omap3 *omap, struct usb_hcd *hcd)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(100);
+
+        dev_dbg(omap->dev, "stopping TI EHCI USB Controller\n");
+
+        /* Reset USBHOST for insmod/rmmod to work */
+        ohci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG,
+                        OMAP_UHH_SYSCONFIG_SOFTRESET);
+        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & OMAP_UHH_SYSSTATUS_UHHRESETDONE)) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & OMAP_UHH_SYSSTATUS_OHCIRESETDONE)) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & OMAP_UHH_SYSSTATUS_EHCIRESETDONE)) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, (1 << 1));
+
+        while (!(ohci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
+                                & (1 << 0))) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        ohci_omap3_clock_power(omap, 0);
+
+        if (omap->usbtll_fck != NULL) {
+                clk_put(omap->usbtll_fck);
+                omap->usbtll_fck = NULL;
+        }
+
+        if (omap->usbhost_ick != NULL) {
+                clk_put(omap->usbhost_ick);
+                omap->usbhost_ick = NULL;
+        }
+
+        if (omap->usbhost1_48m_fck != NULL) {
+                clk_put(omap->usbhost1_48m_fck);
+                omap->usbhost1_48m_fck = NULL;
+        }
+
+        if (omap->usbhost2_120m_fck != NULL) {
+                clk_put(omap->usbhost2_120m_fck);
+                omap->usbhost2_120m_fck = NULL;
+        }
+
+        if (omap->usbtll_ick != NULL) {
+                clk_put(omap->usbtll_ick);
+                omap->usbtll_ick = NULL;
+        }
+
+        dev_dbg(omap->dev, "Clock to USB host has been disabled\n");
+}
+
+/*-------------------------------------------------------------------------*/
+
+static const struct hc_driver ohci_omap3_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "OMAP3 OHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct ohci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq =                  ohci_irq,
+        .flags =                HCD_USB11 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset =                ohci_omap3_init,
+        .start =                ohci_omap3_start,
+        .stop =                 ohci_stop,
+        .shutdown =             ohci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue =          ohci_urb_enqueue,
+        .urb_dequeue =          ohci_urb_dequeue,
+        .endpoint_disable =     ohci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number =     ohci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data =      ohci_hub_status_data,
+        .hub_control =          ohci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
+#endif
+        .start_port_reset =     ohci_start_port_reset,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * configure so an HC device and id are always provided
+ * always called with process context; sleeping is OK
+ */
+
+/**
+ * ohci_hcd_omap3_probe - initialize OMAP-based HCDs
+ *
+ * Allocates basic resources for this USB host controller, and
+ * then invokes the start() method for the HCD associated with it
+ * through the hotplug entry's driver_data.
+ */
+static int __devinit ohci_hcd_omap3_probe(struct platform_device *pdev)
+{
+        struct ohci_hcd_omap_platform_data *pdata = pdev->dev.platform_data;
+        struct ohci_hcd_omap3 *omap;
+        struct resource *res;
+        struct usb_hcd *hcd;
+        int ret = -ENODEV;
+        int irq;
+
+        if (usb_disabled())
+                goto err_disabled;
+
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "missing platform_data\n");
+                goto err_pdata;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+
+        omap = kzalloc(sizeof(*omap), GFP_KERNEL);
+        if (!omap) {
+                ret = -ENOMEM;
+                goto err_disabled;
+        }
+
+        hcd = usb_create_hcd(&ohci_omap3_hc_driver, &pdev->dev,
+                        dev_name(&pdev->dev));
+        if (!hcd) {
+                ret = -ENOMEM;
+                goto err_create_hcd;
+        }
+
+        platform_set_drvdata(pdev, omap);
+        omap->dev               = &pdev->dev;
+        omap->port_mode[0]      = pdata->port_mode[0];
+        omap->port_mode[1]      = pdata->port_mode[1];
+        omap->port_mode[2]      = pdata->port_mode[2];
+        omap->es2_compatibility = pdata->es2_compatibility;
+        omap->ohci              = hcd_to_ohci(hcd);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "OHCI ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        omap->uhh_base = ioremap(res->start, resource_size(res));
+        if (!omap->uhh_base) {
+                dev_err(&pdev->dev, "UHH ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_uhh_ioremap;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        omap->tll_base = ioremap(res->start, resource_size(res));
+        if (!omap->tll_base) {
+                dev_err(&pdev->dev, "TLL ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_tll_ioremap;
+        }
+
+        ret = omap3_start_ohci(omap, hcd);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to start ehci\n");
+                goto err_start;
+        }
+
+        ohci_hcd_init(omap->ohci);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                goto err_add_hcd;
+        }
+
+        return 0;
+
+err_add_hcd:
+        omap3_stop_ohci(omap, hcd);
+
+err_start:
+        iounmap(omap->tll_base);
+
+err_tll_ioremap:
+        iounmap(omap->uhh_base);
+
+err_uhh_ioremap:
+        iounmap(hcd->regs);
+
+err_ioremap:
+        usb_put_hcd(hcd);
+
+err_create_hcd:
+        kfree(omap);
+err_pdata:
+err_disabled:
+        return ret;
+}
+
+/*
+ * may be called without controller electrically present
+ * may be called with controller, bus, and devices active
+ */
+
+/**
+ * ohci_hcd_omap3_remove - shutdown processing for OHCI HCDs
+ * @pdev: USB Host Controller being removed
+ *
+ * Reverses the effect of ohci_hcd_omap3_probe(), first invoking
+ * the HCD's stop() method.  It is always called from a thread
+ * context, normally "rmmod", "apmd", or something similar.
+ */
+static int __devexit ohci_hcd_omap3_remove(struct platform_device *pdev)
+{
+        struct ohci_hcd_omap3 *omap = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ohci_to_hcd(omap->ohci);
+
+        usb_remove_hcd(hcd);
+        omap3_stop_ohci(omap, hcd);
+        iounmap(hcd->regs);
+        iounmap(omap->tll_base);
+        iounmap(omap->uhh_base);
+        usb_put_hcd(hcd);
+        kfree(omap);
+
+        return 0;
+}
+
+static void ohci_hcd_omap3_shutdown(struct platform_device *pdev)
+{
+        struct ohci_hcd_omap3 *omap = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ohci_to_hcd(omap->ohci);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver ohci_hcd_omap3_driver = {
+        .probe          = ohci_hcd_omap3_probe,
+        .remove         = __devexit_p(ohci_hcd_omap3_remove),
+        .shutdown       = ohci_hcd_omap3_shutdown,
+        .driver         = {
+                .name   = "ohci-omap3",
+        },
+};
+
+MODULE_ALIAS("platform:ohci-omap3");
+MODULE_AUTHOR("Anand Gadiyar <gadiyar@ti.com>");
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index e62b30b3e429..f608dfd09a8a 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -34,12 +34,11 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
 #include <linux/io.h>
 
-#include "../core/hcd.h"
-
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/unaligned.h>
@@ -3154,10 +3153,10 @@ static inline unsigned int oxu_port_speed(struct oxu_hcd *oxu,
         case 0:
                 return 0;
         case 1:
-                return 1 << USB_PORT_FEAT_LOWSPEED;
+                return USB_PORT_STAT_LOW_SPEED;
         case 2:
         default:
-                return 1 << USB_PORT_FEAT_HIGHSPEED;
+                return USB_PORT_STAT_HIGH_SPEED;
         }
 }
 
@@ -3202,7 +3201,7 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
                  * Even if OWNER is set, so the port is owned by the
                  * companion controller, khubd needs to be able to clear
                  * the port-change status bits (especially
-                 * USB_PORT_FEAT_C_CONNECTION).
+                 * USB_PORT_STAT_C_CONNECTION).
                  */
 
                 switch (wValue) {
@@ -3264,11 +3263,11 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 /* wPortChange bits */
                 if (temp & PORT_CSC)
-                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                        status |= USB_PORT_STAT_C_CONNECTION << 16;
                 if (temp & PORT_PEC)
-                        status |= 1 << USB_PORT_FEAT_C_ENABLE;
+                        status |= USB_PORT_STAT_C_ENABLE << 16;
                 if ((temp & PORT_OCC) && !ignore_oc)
-                        status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
+                        status |= USB_PORT_STAT_C_OVERCURRENT << 16;
 
                 /* whoever resumes must GetPortStatus to complete it!! */
                 if (temp & PORT_RESUME) {
@@ -3286,7 +3285,7 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         /* resume completed? */
                         else if (time_after_eq(jiffies,
                                         oxu->reset_done[wIndex])) {
-                                status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                                status |= USB_PORT_STAT_C_SUSPEND << 16;
                                 oxu->reset_done[wIndex] = 0;
 
                                 /* stop resume signaling */
@@ -3309,7 +3308,7 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 if ((temp & PORT_RESET)
                                 && time_after_eq(jiffies,
                                         oxu->reset_done[wIndex])) {
-                        status |= 1 << USB_PORT_FEAT_C_RESET;
+                        status |= USB_PORT_STAT_C_RESET << 16;
                         oxu->reset_done[wIndex] = 0;
 
                         /* force reset to complete */
@@ -3348,20 +3347,20 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
                  */
 
                 if (temp & PORT_CONNECT) {
-                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        status |= USB_PORT_STAT_CONNECTION;
                         /* status may be from integrated TT */
                         status |= oxu_port_speed(oxu, temp);
                 }
                 if (temp & PORT_PE)
-                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                        status |= USB_PORT_STAT_ENABLE;
                 if (temp & (PORT_SUSPEND|PORT_RESUME))
-                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                        status |= USB_PORT_STAT_SUSPEND;
                 if (temp & PORT_OC)
-                        status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
+                        status |= USB_PORT_STAT_OVERCURRENT;
                 if (temp & PORT_RESET)
-                        status |= 1 << USB_PORT_FEAT_RESET;
+                        status |= USB_PORT_STAT_RESET;
                 if (temp & PORT_POWER)
-                        status |= 1 << USB_PORT_FEAT_POWER;
+                        status |= USB_PORT_STAT_POWER;
 
 #ifndef OXU_VERBOSE_DEBUG
         if (status & ~0xffff)   /* only if wPortChange is interesting */
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index d478ffad59b4..6db57ab6079d 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -33,6 +33,7 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/mm.h>
@@ -40,7 +41,6 @@
 #include <linux/slab.h>
 #include <asm/cacheflush.h>
 
-#include "../core/hcd.h"
 #include "r8a66597.h"
 
 MODULE_DESCRIPTION("R8A66597 USB Host Controller Driver");
@@ -1018,10 +1018,10 @@ static void start_root_hub_sampling(struct r8a66597 *r8a66597, int port,
         rh->old_syssts = r8a66597_read(r8a66597, get_syssts_reg(port)) & LNST;
         rh->scount = R8A66597_MAX_SAMPLING;
         if (connect)
-                rh->port |= 1 << USB_PORT_FEAT_CONNECTION;
+                rh->port |= USB_PORT_STAT_CONNECTION;
         else
-                rh->port &= ~(1 << USB_PORT_FEAT_CONNECTION);
-        rh->port |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                rh->port &= ~USB_PORT_STAT_CONNECTION;
+        rh->port |= USB_PORT_STAT_C_CONNECTION << 16;
 
         r8a66597_root_hub_start_polling(r8a66597);
 }
@@ -1059,15 +1059,14 @@ static void r8a66597_usb_connect(struct r8a66597 *r8a66597, int port)
         u16 speed = get_rh_usb_speed(r8a66597, port);
         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
 
-        rh->port &= ~((1 << USB_PORT_FEAT_HIGHSPEED) |
-                      (1 << USB_PORT_FEAT_LOWSPEED));
+        rh->port &= ~(USB_PORT_STAT_HIGH_SPEED | USB_PORT_STAT_LOW_SPEED);
         if (speed == HSMODE)
-                rh->port |= (1 << USB_PORT_FEAT_HIGHSPEED);
+                rh->port |= USB_PORT_STAT_HIGH_SPEED;
         else if (speed == LSMODE)
-                rh->port |= (1 << USB_PORT_FEAT_LOWSPEED);
+                rh->port |= USB_PORT_STAT_LOW_SPEED;
 
-        rh->port &= ~(1 << USB_PORT_FEAT_RESET);
-        rh->port |= 1 << USB_PORT_FEAT_ENABLE;
+        rh->port &= USB_PORT_STAT_RESET;
+        rh->port |= USB_PORT_STAT_ENABLE;
 }
 
 /* this function must be called with interrupt disabled */
@@ -1706,7 +1705,7 @@ static void r8a66597_root_hub_control(struct r8a66597 *r8a66597, int port)
         u16 tmp;
         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
 
-        if (rh->port & (1 << USB_PORT_FEAT_RESET)) {
+        if (rh->port & USB_PORT_STAT_RESET) {
                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
 
                 tmp = r8a66597_read(r8a66597, dvstctr_reg);
@@ -1718,7 +1717,7 @@ static void r8a66597_root_hub_control(struct r8a66597 *r8a66597, int port)
                         r8a66597_usb_connect(r8a66597, port);
         }
 
-        if (!(rh->port & (1 << USB_PORT_FEAT_CONNECTION))) {
+        if (!(rh->port & USB_PORT_STAT_CONNECTION)) {
                 r8a66597_write(r8a66597, ~ATTCH, get_intsts_reg(port));
                 r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
         }
@@ -2186,7 +2185,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                 switch (wValue) {
                 case USB_PORT_FEAT_ENABLE:
-                        rh->port &= ~(1 << USB_PORT_FEAT_POWER);
+                        rh->port &= ~USB_PORT_STAT_POWER;
                         break;
                 case USB_PORT_FEAT_SUSPEND:
                         break;
@@ -2227,12 +2226,12 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         break;
                 case USB_PORT_FEAT_POWER:
                         r8a66597_port_power(r8a66597, port, 1);
-                        rh->port |= (1 << USB_PORT_FEAT_POWER);
+                        rh->port |= USB_PORT_STAT_POWER;
                         break;
                 case USB_PORT_FEAT_RESET: {
                         struct r8a66597_device *dev = rh->dev;
 
-                        rh->port |= (1 << USB_PORT_FEAT_RESET);
+                        rh->port |= USB_PORT_STAT_RESET;
 
                         disable_r8a66597_pipe_all(r8a66597, dev);
                         free_usb_address(r8a66597, dev, 1);
@@ -2270,12 +2269,12 @@ static int r8a66597_bus_suspend(struct usb_hcd *hcd)
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
 
-                if (!(rh->port & (1 << USB_PORT_FEAT_ENABLE)))
+                if (!(rh->port & USB_PORT_STAT_ENABLE))
                         continue;
 
                 dbg("suspend port = %d", port);
                 r8a66597_bclr(r8a66597, UACT, dvstctr_reg);     /* suspend */
-                rh->port |= 1 << USB_PORT_FEAT_SUSPEND;
+                rh->port |= USB_PORT_STAT_SUSPEND;
 
                 if (rh->dev->udev->do_remote_wakeup) {
                         msleep(3);      /* waiting last SOF */
@@ -2301,12 +2300,12 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
 
-                if (!(rh->port & (1 << USB_PORT_FEAT_SUSPEND)))
+                if (!(rh->port & USB_PORT_STAT_SUSPEND))
                         continue;
 
                 dbg("resume port = %d", port);
-                rh->port &= ~(1 << USB_PORT_FEAT_SUSPEND);
-                rh->port |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                rh->port &= ~USB_PORT_STAT_SUSPEND;
+                rh->port |= USB_PORT_STAT_C_SUSPEND < 16;
                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
                 msleep(50);
                 r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 3b867a8af7b2..bcf9f0e809de 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -45,6 +45,7 @@
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/usb/sl811.h>
+#include <linux/usb/hcd.h>
 #include <linux/platform_device.h>
 
 #include <asm/io.h>
@@ -53,7 +54,6 @@
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 
-#include "../core/hcd.h"
 #include "sl811.h"
 
 
@@ -90,10 +90,10 @@ static void port_power(struct sl811 *sl811, int is_on)
 
         /* hub is inactive unless the port is powered */
         if (is_on) {
-                if (sl811->port1 & (1 << USB_PORT_FEAT_POWER))
+                if (sl811->port1 & USB_PORT_STAT_POWER)
                         return;
 
-                sl811->port1 = (1 << USB_PORT_FEAT_POWER);
+                sl811->port1 = USB_PORT_STAT_POWER;
                 sl811->irq_enable = SL11H_INTMASK_INSRMV;
         } else {
                 sl811->port1 = 0;
@@ -407,7 +407,7 @@ static struct sl811h_ep	*start(struct sl811 *sl811, u8 bank)
 
 static inline void start_transfer(struct sl811 *sl811)
 {
-        if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND))
+        if (sl811->port1 & USB_PORT_STAT_SUSPEND)
                 return;
         if (sl811->active_a == NULL) {
                 sl811->active_a = start(sl811, SL811_EP_A(SL811_HOST_BUF));
@@ -721,23 +721,23 @@ retry:
                  * force the reset and make khubd clean up later.
                  */
                 if (irqstat & SL11H_INTMASK_RD)
-                        sl811->port1 &= ~(1 << USB_PORT_FEAT_CONNECTION);
+                        sl811->port1 &= ~USB_PORT_STAT_CONNECTION;
                 else
-                        sl811->port1 |= 1 << USB_PORT_FEAT_CONNECTION;
+                        sl811->port1 |= USB_PORT_STAT_CONNECTION;
 
-                sl811->port1 |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                sl811->port1 |= USB_PORT_STAT_C_CONNECTION << 16;
 
         } else if (irqstat & SL11H_INTMASK_RD) {
-                if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)) {
+                if (sl811->port1 & USB_PORT_STAT_SUSPEND) {
                         DBG("wakeup\n");
-                        sl811->port1 |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                        sl811->port1 |= USB_PORT_STAT_C_SUSPEND << 16;
                         sl811->stat_wake++;
                 } else
                         irqstat &= ~SL11H_INTMASK_RD;
         }
 
         if (irqstat) {
-                if (sl811->port1 & (1 << USB_PORT_FEAT_ENABLE))
+                if (sl811->port1 & USB_PORT_STAT_ENABLE)
                         start_transfer(sl811);
                 ret = IRQ_HANDLED;
                 if (retries--)
@@ -819,7 +819,7 @@ static int sl811h_urb_enqueue(
         spin_lock_irqsave(&sl811->lock, flags);
 
         /* don't submit to a dead or disabled port */
-        if (!(sl811->port1 & (1 << USB_PORT_FEAT_ENABLE))
+        if (!(sl811->port1 & USB_PORT_STAT_ENABLE)
                         || !HC_IS_RUNNING(hcd->state)) {
                 retval = -ENODEV;
                 kfree(ep);
@@ -1119,9 +1119,9 @@ sl811h_timer(unsigned long _sl811)
         unsigned long   flags;
         u8              irqstat;
         u8              signaling = sl811->ctrl1 & SL11H_CTL1MASK_FORCE;
-        const u32       mask = (1 << USB_PORT_FEAT_CONNECTION)
-                                | (1 << USB_PORT_FEAT_ENABLE)
-                                | (1 << USB_PORT_FEAT_LOWSPEED);
+        const u32       mask = USB_PORT_STAT_CONNECTION
+                                | USB_PORT_STAT_ENABLE
+                                | USB_PORT_STAT_LOW_SPEED;
 
         spin_lock_irqsave(&sl811->lock, flags);
 
@@ -1135,8 +1135,8 @@ sl811h_timer(unsigned long _sl811)
         switch (signaling) {
         case SL11H_CTL1MASK_SE0:
                 DBG("end reset\n");
-                sl811->port1 = (1 << USB_PORT_FEAT_C_RESET)
-                                | (1 << USB_PORT_FEAT_POWER);
+                sl811->port1 = (USB_PORT_STAT_C_RESET << 16)
+                                 | USB_PORT_STAT_POWER;
                 sl811->ctrl1 = 0;
                 /* don't wrongly ack RD */
                 if (irqstat & SL11H_INTMASK_INSRMV)
@@ -1144,7 +1144,7 @@ sl811h_timer(unsigned long _sl811)
                 break;
         case SL11H_CTL1MASK_K:
                 DBG("end resume\n");
-                sl811->port1 &= ~(1 << USB_PORT_FEAT_SUSPEND);
+                sl811->port1 &= ~USB_PORT_STAT_SUSPEND;
                 break;
         default:
                 DBG("odd timer signaling: %02x\n", signaling);
@@ -1154,26 +1154,26 @@ sl811h_timer(unsigned long _sl811)
 
         if (irqstat & SL11H_INTMASK_RD) {
                 /* usbcore nukes all pending transactions on disconnect */
-                if (sl811->port1 & (1 << USB_PORT_FEAT_CONNECTION))
-                        sl811->port1 |= (1 << USB_PORT_FEAT_C_CONNECTION)
-                                        | (1 << USB_PORT_FEAT_C_ENABLE);
+                if (sl811->port1 & USB_PORT_STAT_CONNECTION)
+                        sl811->port1 |= (USB_PORT_STAT_C_CONNECTION << 16)
+                                        | (USB_PORT_STAT_C_ENABLE << 16);
                 sl811->port1 &= ~mask;
                 sl811->irq_enable = SL11H_INTMASK_INSRMV;
         } else {
                 sl811->port1 |= mask;
                 if (irqstat & SL11H_INTMASK_DP)
-                        sl811->port1 &= ~(1 << USB_PORT_FEAT_LOWSPEED);
+                        sl811->port1 &= ~USB_PORT_STAT_LOW_SPEED;
                 sl811->irq_enable = SL11H_INTMASK_INSRMV | SL11H_INTMASK_RD;
         }
 
-        if (sl811->port1 & (1 << USB_PORT_FEAT_CONNECTION)) {
+        if (sl811->port1 & USB_PORT_STAT_CONNECTION) {
                 u8      ctrl2 = SL811HS_CTL2_INIT;
 
                 sl811->irq_enable |= SL11H_INTMASK_DONE_A;
 #ifdef USE_B
                 sl811->irq_enable |= SL11H_INTMASK_DONE_B;
 #endif
-                if (sl811->port1 & (1 << USB_PORT_FEAT_LOWSPEED)) {
+                if (sl811->port1 & USB_PORT_STAT_LOW_SPEED) {
                         sl811->ctrl1 |= SL11H_CTL1MASK_LSPD;
                         ctrl2 |= SL811HS_CTL2MASK_DSWAP;
                 }
@@ -1233,7 +1233,7 @@ sl811h_hub_control(
 
                 switch (wValue) {
                 case USB_PORT_FEAT_ENABLE:
-                        sl811->port1 &= (1 << USB_PORT_FEAT_POWER);
+                        sl811->port1 &= USB_PORT_STAT_POWER;
                         sl811->ctrl1 = 0;
                         sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
                         sl811->irq_enable = SL11H_INTMASK_INSRMV;
@@ -1241,7 +1241,7 @@ sl811h_hub_control(
                                                 sl811->irq_enable);
                         break;
                 case USB_PORT_FEAT_SUSPEND:
-                        if (!(sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)))
+                        if (!(sl811->port1 & USB_PORT_STAT_SUSPEND))
                                 break;
 
                         /* 20 msec of resume/K signaling, other irqs blocked */
@@ -1290,9 +1290,9 @@ sl811h_hub_control(
                         goto error;
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
-                        if (sl811->port1 & (1 << USB_PORT_FEAT_RESET))
+                        if (sl811->port1 & USB_PORT_STAT_RESET)
                                 goto error;
-                        if (!(sl811->port1 & (1 << USB_PORT_FEAT_ENABLE)))
+                        if (!(sl811->port1 & USB_PORT_STAT_ENABLE))
                                 goto error;
 
                         DBG("suspend...\n");
@@ -1303,9 +1303,9 @@ sl811h_hub_control(
                         port_power(sl811, 1);
                         break;
                 case USB_PORT_FEAT_RESET:
-                        if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND))
+                        if (sl811->port1 & USB_PORT_STAT_SUSPEND)
                                 goto error;
-                        if (!(sl811->port1 & (1 << USB_PORT_FEAT_POWER)))
+                        if (!(sl811->port1 & USB_PORT_STAT_POWER))
                                 break;
 
                         /* 50 msec of reset/SE0 signaling, irqs blocked */
@@ -1314,7 +1314,7 @@ sl811h_hub_control(
                                                 sl811->irq_enable);
                         sl811->ctrl1 = SL11H_CTL1MASK_SE0;
                         sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
-                        sl811->port1 |= (1 << USB_PORT_FEAT_RESET);
+                        sl811->port1 |= USB_PORT_STAT_RESET;
                         mod_timer(&sl811->timer, jiffies
                                         + msecs_to_jiffies(50));
                         break;
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index 228f2b070f2b..5b31bae92dbc 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -49,6 +49,7 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
 #include <linux/mutex.h>
@@ -56,7 +57,6 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/byteorder.h>
-#include "../core/hcd.h"
 
         /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
          * If you're going to try stuff like this, you need to split
@@ -1446,9 +1446,9 @@ static void u132_hcd_endp_work_scheduler(struct work_struct *work)
                         return;
                 } else {
                         int retval;
-                        u8 address = u132->addr[endp->usb_addr].address;
                         struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
                                 endp->queue_next];
+                        address = u132->addr[endp->usb_addr].address;
                         endp->active = 1;
                         ring->curr_endp = endp;
                         ring->in_use = 1;
@@ -3120,8 +3120,8 @@ static int __devinit u132_probe(struct platform_device *pdev)
                 ftdi_elan_gone_away(pdev);
                 return -ENOMEM;
         } else {
-                int retval = 0;
                 struct u132 *u132 = hcd_to_u132(hcd);
+                retval = 0;
                 hcd->rsrc_start = 0;
                 mutex_lock(&u132_module_lock);
                 list_add_tail(&u132->u132_list, &u132_static_list);
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 09197067fe6b..6637e52736dd 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -38,6 +38,7 @@
 #include <linux/dmapool.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb.h>
+#include <linux/usb/hcd.h>
 #include <linux/bitops.h>
 #include <linux/dmi.h>
 
@@ -46,7 +47,6 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 
-#include "../core/hcd.h"
 #include "uhci-hcd.h"
 #include "pci-quirks.h"
 
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c
index c5305b599ca0..767af265e002 100644
--- a/drivers/usb/host/whci/debug.c
+++ b/drivers/usb/host/whci/debug.c
@@ -30,7 +30,7 @@ struct whc_dbg {
         struct dentry *pzl_f;
 };
 
-void qset_print(struct seq_file *s, struct whc_qset *qset)
+static void qset_print(struct seq_file *s, struct whc_qset *qset)
 {
         static const char *qh_type[] = {
                 "ctrl", "isoc", "bulk", "intr", "rsvd", "rsvd", "rsvd", "lpintr", };
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index 141d049beb3e..ab5a14fbfeeb 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -443,7 +443,7 @@ static int qset_add_urb_sg(struct whc *whc, struct whc_qset *qset, struct urb *u
 
         remaining = urb->transfer_buffer_length;
 
-        for_each_sg(urb->sg->sg, sg, urb->num_sgs, i) {
+        for_each_sg(urb->sg, sg, urb->num_sgs, i) {
                 dma_addr_t dma_addr;
                 size_t dma_remaining;
                 dma_addr_t sp, ep;
@@ -561,7 +561,7 @@ static int qset_add_urb_sg_linearize(struct whc *whc, struct whc_qset *qset,
 
         remaining = urb->transfer_buffer_length;
 
-        for_each_sg(urb->sg->sg, sg, urb->sg->nents, i) {
+        for_each_sg(urb->sg, sg, urb->num_sgs, i) {
                 size_t len;
                 size_t sg_remaining;
                 void *orig;
@@ -646,7 +646,7 @@ int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
         wurb->urb = urb;
         INIT_WORK(&wurb->dequeue_work, urb_dequeue_work);
 
-        if (urb->sg) {
+        if (urb->num_sgs) {
                 ret = qset_add_urb_sg(whc, qset, urb, mem_flags);
                 if (ret == -EINVAL) {
                         qset_free_stds(qset, urb);
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 105fa8b025bb..fcbf4abbf381 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -364,6 +364,30 @@ void xhci_debug_ring(struct xhci_hcd *xhci, struct xhci_ring *ring)
                 xhci_debug_segment(xhci, seg);
 }
 
+void xhci_dbg_ep_rings(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_virt_ep *ep)
+{
+        int i;
+        struct xhci_ring *ring;
+
+        if (ep->ep_state & EP_HAS_STREAMS) {
+                for (i = 1; i < ep->stream_info->num_streams; i++) {
+                        ring = ep->stream_info->stream_rings[i];
+                        xhci_dbg(xhci, "Dev %d endpoint %d stream ID %d:\n",
+                                slot_id, ep_index, i);
+                        xhci_debug_segment(xhci, ring->deq_seg);
+                }
+        } else {
+                ring = ep->ring;
+                if (!ring)
+                        return;
+                xhci_dbg(xhci, "Dev %d endpoint ring %d:\n",
+                                slot_id, ep_index);
+                xhci_debug_segment(xhci, ring->deq_seg);
+        }
+}
+
 void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
 {
         u32 addr = (u32) erst->erst_dma_addr;
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 208b805b80eb..a1a7a9795536 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -64,15 +64,15 @@ static void xhci_hub_descriptor(struct xhci_hcd *xhci,
 static unsigned int xhci_port_speed(unsigned int port_status)
 {
         if (DEV_LOWSPEED(port_status))
-                return 1 << USB_PORT_FEAT_LOWSPEED;
+                return USB_PORT_STAT_LOW_SPEED;
         if (DEV_HIGHSPEED(port_status))
-                return 1 << USB_PORT_FEAT_HIGHSPEED;
+                return USB_PORT_STAT_HIGH_SPEED;
         if (DEV_SUPERSPEED(port_status))
-                return 1 << USB_PORT_FEAT_SUPERSPEED;
+                return USB_PORT_STAT_SUPER_SPEED;
         /*
          * FIXME: Yes, we should check for full speed, but the core uses that as
          * a default in portspeed() in usb/core/hub.c (which is the only place
-         * USB_PORT_FEAT_*SPEED is used).
+         * USB_PORT_STAT_*_SPEED is used).
          */
         return 0;
 }
@@ -205,27 +205,27 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                 /* wPortChange bits */
                 if (temp & PORT_CSC)
-                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                        status |= USB_PORT_STAT_C_CONNECTION << 16;
                 if (temp & PORT_PEC)
-                        status |= 1 << USB_PORT_FEAT_C_ENABLE;
+                        status |= USB_PORT_STAT_C_ENABLE << 16;
                 if ((temp & PORT_OCC))
-                        status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
+                        status |= USB_PORT_STAT_C_OVERCURRENT << 16;
                 /*
                  * FIXME ignoring suspend, reset, and USB 2.1/3.0 specific
                  * changes
                  */
                 if (temp & PORT_CONNECT) {
-                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        status |= USB_PORT_STAT_CONNECTION;
                         status |= xhci_port_speed(temp);
                 }
                 if (temp & PORT_PE)
-                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                        status |= USB_PORT_STAT_ENABLE;
                 if (temp & PORT_OC)
-                        status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
+                        status |= USB_PORT_STAT_OVERCURRENT;
                 if (temp & PORT_RESET)
-                        status |= 1 << USB_PORT_FEAT_RESET;
+                        status |= USB_PORT_STAT_RESET;
                 if (temp & PORT_POWER)
-                        status |= 1 << USB_PORT_FEAT_POWER;
+                        status |= USB_PORT_STAT_POWER;
                 xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
                 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
                 break;
@@ -298,7 +298,6 @@ error:
  * Returns 0 if the status hasn't changed, or the number of bytes in buf.
  * Ports are 0-indexed from the HCD point of view,
  * and 1-indexed from the USB core pointer of view.
- * xHCI instances can have up to 127 ports, so FIXME if you see more than 15.
  *
  * Note that the status change bits will be cleared as soon as a port status
  * change event is generated, so we use the saved status from that event.
@@ -315,14 +314,9 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         ports = HCS_MAX_PORTS(xhci->hcs_params1);
 
         /* Initial status is no changes */
-        buf[0] = 0;
+        retval = (ports + 8) / 8;
+        memset(buf, 0, retval);
         status = 0;
-        if (ports > 7) {
-                buf[1] = 0;
-                retval = 2;
-        } else {
-                retval = 1;
-        }
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
@@ -331,10 +325,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
                         NUM_PORT_REGS*i;
                 temp = xhci_readl(xhci, addr);
                 if (temp & (PORT_CSC | PORT_PEC | PORT_OCC)) {
-                        if (i < 7)
-                                buf[0] |= 1 << (i + 1);
-                        else
-                                buf[1] |= 1 << (i - 7);
+                        buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
                         status = 1;
                 }
         }
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index d64f5724bfc4..fd9e03afd91c 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -41,13 +41,13 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flag
 
         seg = kzalloc(sizeof *seg, flags);
         if (!seg)
-                return 0;
+                return NULL;
         xhci_dbg(xhci, "Allocating priv segment structure at %p\n", seg);
 
         seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma);
         if (!seg->trbs) {
                 kfree(seg);
-                return 0;
+                return NULL;
         }
         xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n",
                         seg->trbs, (unsigned long long)dma);
@@ -159,7 +159,7 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
         ring = kzalloc(sizeof *(ring), flags);
         xhci_dbg(xhci, "Allocating ring at %p\n", ring);
         if (!ring)
-                return 0;
+                return NULL;
 
         INIT_LIST_HEAD(&ring->td_list);
         if (num_segs == 0)
@@ -196,7 +196,7 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
 
 fail:
         xhci_ring_free(xhci, ring);
-        return 0;
+        return NULL;
 }
 
 void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
@@ -247,7 +247,7 @@ static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
 
 #define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32)
 
-struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
+static struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
                                                     int type, gfp_t flags)
 {
         struct xhci_container_ctx *ctx = kzalloc(sizeof(*ctx), flags);
@@ -265,7 +265,7 @@ struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
         return ctx;
 }
 
-void xhci_free_container_ctx(struct xhci_hcd *xhci,
+static void xhci_free_container_ctx(struct xhci_hcd *xhci,
                              struct xhci_container_ctx *ctx)
 {
         if (!ctx)
@@ -304,6 +304,422 @@ struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci,
                 (ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params)));
 }
 
+
+/***************** Streams structures manipulation *************************/
+
+void xhci_free_stream_ctx(struct xhci_hcd *xhci,
+                unsigned int num_stream_ctxs,
+                struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
+{
+        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+
+        if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
+                pci_free_consistent(pdev,
+                                sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
+                                stream_ctx, dma);
+        else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
+                return dma_pool_free(xhci->small_streams_pool,
+                                stream_ctx, dma);
+        else
+                return dma_pool_free(xhci->medium_streams_pool,
+                                stream_ctx, dma);
+}
+
+/*
+ * The stream context array for each endpoint with bulk streams enabled can
+ * vary in size, based on:
+ *  - how many streams the endpoint supports,
+ *  - the maximum primary stream array size the host controller supports,
+ *  - and how many streams the device driver asks for.
+ *
+ * The stream context array must be a power of 2, and can be as small as
+ * 64 bytes or as large as 1MB.
+ */
+struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
+                unsigned int num_stream_ctxs, dma_addr_t *dma,
+                gfp_t mem_flags)
+{
+        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+
+        if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
+                return pci_alloc_consistent(pdev,
+                                sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
+                                dma);
+        else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
+                return dma_pool_alloc(xhci->small_streams_pool,
+                                mem_flags, dma);
+        else
+                return dma_pool_alloc(xhci->medium_streams_pool,
+                                mem_flags, dma);
+}
+
+struct xhci_ring *xhci_dma_to_transfer_ring(
+                struct xhci_virt_ep *ep,
+                u64 address)
+{
+        if (ep->ep_state & EP_HAS_STREAMS)
+                return radix_tree_lookup(&ep->stream_info->trb_address_map,
+                                address >> SEGMENT_SHIFT);
+        return ep->ring;
+}
+
+/* Only use this when you know stream_info is valid */
+#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
+static struct xhci_ring *dma_to_stream_ring(
+                struct xhci_stream_info *stream_info,
+                u64 address)
+{
+        return radix_tree_lookup(&stream_info->trb_address_map,
+                        address >> SEGMENT_SHIFT);
+}
+#endif  /* CONFIG_USB_XHCI_HCD_DEBUGGING */
+
+struct xhci_ring *xhci_stream_id_to_ring(
+                struct xhci_virt_device *dev,
+                unsigned int ep_index,
+                unsigned int stream_id)
+{
+        struct xhci_virt_ep *ep = &dev->eps[ep_index];
+
+        if (stream_id == 0)
+                return ep->ring;
+        if (!ep->stream_info)
+                return NULL;
+
+        if (stream_id > ep->stream_info->num_streams)
+                return NULL;
+        return ep->stream_info->stream_rings[stream_id];
+}
+
+struct xhci_ring *xhci_triad_to_transfer_ring(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id)
+{
+        struct xhci_virt_ep *ep;
+
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+        /* Common case: no streams */
+        if (!(ep->ep_state & EP_HAS_STREAMS))
+                return ep->ring;
+
+        if (stream_id == 0) {
+                xhci_warn(xhci,
+                                "WARN: Slot ID %u, ep index %u has streams, "
+                                "but URB has no stream ID.\n",
+                                slot_id, ep_index);
+                return NULL;
+        }
+
+        if (stream_id < ep->stream_info->num_streams)
+                return ep->stream_info->stream_rings[stream_id];
+
+        xhci_warn(xhci,
+                        "WARN: Slot ID %u, ep index %u has "
+                        "stream IDs 1 to %u allocated, "
+                        "but stream ID %u is requested.\n",
+                        slot_id, ep_index,
+                        ep->stream_info->num_streams - 1,
+                        stream_id);
+        return NULL;
+}
+
+/* Get the right ring for the given URB.
+ * If the endpoint supports streams, boundary check the URB's stream ID.
+ * If the endpoint doesn't support streams, return the singular endpoint ring.
+ */
+struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
+                struct urb *urb)
+{
+        return xhci_triad_to_transfer_ring(xhci, urb->dev->slot_id,
+                xhci_get_endpoint_index(&urb->ep->desc), urb->stream_id);
+}
+
+#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
+static int xhci_test_radix_tree(struct xhci_hcd *xhci,
+                unsigned int num_streams,
+                struct xhci_stream_info *stream_info)
+{
+        u32 cur_stream;
+        struct xhci_ring *cur_ring;
+        u64 addr;
+
+        for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
+                struct xhci_ring *mapped_ring;
+                int trb_size = sizeof(union xhci_trb);
+
+                cur_ring = stream_info->stream_rings[cur_stream];
+                for (addr = cur_ring->first_seg->dma;
+                                addr < cur_ring->first_seg->dma + SEGMENT_SIZE;
+                                addr += trb_size) {
+                        mapped_ring = dma_to_stream_ring(stream_info, addr);
+                        if (cur_ring != mapped_ring) {
+                                xhci_warn(xhci, "WARN: DMA address 0x%08llx "
+                                                "didn't map to stream ID %u; "
+                                                "mapped to ring %p\n",
+                                                (unsigned long long) addr,
+                                                cur_stream,
+                                                mapped_ring);
+                                return -EINVAL;
+                        }
+                }
+                /* One TRB after the end of the ring segment shouldn't return a
+                 * pointer to the current ring (although it may be a part of a
+                 * different ring).
+                 */
+                mapped_ring = dma_to_stream_ring(stream_info, addr);
+                if (mapped_ring != cur_ring) {
+                        /* One TRB before should also fail */
+                        addr = cur_ring->first_seg->dma - trb_size;
+                        mapped_ring = dma_to_stream_ring(stream_info, addr);
+                }
+                if (mapped_ring == cur_ring) {
+                        xhci_warn(xhci, "WARN: Bad DMA address 0x%08llx "
+                                        "mapped to valid stream ID %u; "
+                                        "mapped ring = %p\n",
+                                        (unsigned long long) addr,
+                                        cur_stream,
+                                        mapped_ring);
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+#endif  /* CONFIG_USB_XHCI_HCD_DEBUGGING */
+
+/*
+ * Change an endpoint's internal structure so it supports stream IDs.  The
+ * number of requested streams includes stream 0, which cannot be used by device
+ * drivers.
+ *
+ * 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,
+                unsigned int num_streams, gfp_t mem_flags)
+{
+        struct xhci_stream_info *stream_info;
+        u32 cur_stream;
+        struct xhci_ring *cur_ring;
+        unsigned long key;
+        u64 addr;
+        int ret;
+
+        xhci_dbg(xhci, "Allocating %u streams and %u "
+                        "stream context array entries.\n",
+                        num_streams, num_stream_ctxs);
+        if (xhci->cmd_ring_reserved_trbs == MAX_RSVD_CMD_TRBS) {
+                xhci_dbg(xhci, "Command ring has no reserved TRBs available\n");
+                return NULL;
+        }
+        xhci->cmd_ring_reserved_trbs++;
+
+        stream_info = kzalloc(sizeof(struct xhci_stream_info), mem_flags);
+        if (!stream_info)
+                goto cleanup_trbs;
+
+        stream_info->num_streams = num_streams;
+        stream_info->num_stream_ctxs = num_stream_ctxs;
+
+        /* Initialize the array of virtual pointers to stream rings. */
+        stream_info->stream_rings = kzalloc(
+                        sizeof(struct xhci_ring *)*num_streams,
+                        mem_flags);
+        if (!stream_info->stream_rings)
+                goto cleanup_info;
+
+        /* Initialize the array of DMA addresses for stream rings for the HW. */
+        stream_info->stream_ctx_array = xhci_alloc_stream_ctx(xhci,
+                        num_stream_ctxs, &stream_info->ctx_array_dma,
+                        mem_flags);
+        if (!stream_info->stream_ctx_array)
+                goto cleanup_ctx;
+        memset(stream_info->stream_ctx_array, 0,
+                        sizeof(struct xhci_stream_ctx)*num_stream_ctxs);
+
+        /* Allocate everything needed to free the stream rings later */
+        stream_info->free_streams_command =
+                xhci_alloc_command(xhci, true, true, mem_flags);
+        if (!stream_info->free_streams_command)
+                goto cleanup_ctx;
+
+        INIT_RADIX_TREE(&stream_info->trb_address_map, GFP_ATOMIC);
+
+        /* Allocate rings for all the streams that the driver will use,
+         * and add their segment DMA addresses to the radix tree.
+         * Stream 0 is reserved.
+         */
+        for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
+                stream_info->stream_rings[cur_stream] =
+                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                cur_ring = stream_info->stream_rings[cur_stream];
+                if (!cur_ring)
+                        goto cleanup_rings;
+                cur_ring->stream_id = cur_stream;
+                /* Set deq ptr, cycle bit, and stream context type */
+                addr = cur_ring->first_seg->dma |
+                        SCT_FOR_CTX(SCT_PRI_TR) |
+                        cur_ring->cycle_state;
+                stream_info->stream_ctx_array[cur_stream].stream_ring = addr;
+                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 >> SEGMENT_SHIFT);
+                ret = radix_tree_insert(&stream_info->trb_address_map,
+                                key, cur_ring);
+                if (ret) {
+                        xhci_ring_free(xhci, cur_ring);
+                        stream_info->stream_rings[cur_stream] = NULL;
+                        goto cleanup_rings;
+                }
+        }
+        /* Leave the other unused stream ring pointers in the stream context
+         * array initialized to zero.  This will cause the xHC to give us an
+         * error if the device asks for a stream ID we don't have setup (if it
+         * was any other way, the host controller would assume the ring is
+         * "empty" and wait forever for data to be queued to that stream ID).
+         */
+#if XHCI_DEBUG
+        /* Do a little test on the radix tree to make sure it returns the
+         * correct values.
+         */
+        if (xhci_test_radix_tree(xhci, num_streams, stream_info))
+                goto cleanup_rings;
+#endif
+
+        return stream_info;
+
+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 >> SEGMENT_SHIFT);
+                        xhci_ring_free(xhci, cur_ring);
+                        stream_info->stream_rings[cur_stream] = NULL;
+                }
+        }
+        xhci_free_command(xhci, stream_info->free_streams_command);
+cleanup_ctx:
+        kfree(stream_info->stream_rings);
+cleanup_info:
+        kfree(stream_info);
+cleanup_trbs:
+        xhci->cmd_ring_reserved_trbs--;
+        return NULL;
+}
+/*
+ * Sets the MaxPStreams field and the Linear Stream Array field.
+ * Sets the dequeue pointer to the stream context array.
+ */
+void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
+                struct xhci_ep_ctx *ep_ctx,
+                struct xhci_stream_info *stream_info)
+{
+        u32 max_primary_streams;
+        /* MaxPStreams is the number of stream context array entries, not the
+         * number we're actually using.  Must be in 2^(MaxPstreams + 1) format.
+         * fls(0) = 0, fls(0x1) = 1, fls(0x10) = 2, fls(0x100) = 3, etc.
+         */
+        max_primary_streams = fls(stream_info->num_stream_ctxs) - 2;
+        xhci_dbg(xhci, "Setting number of stream ctx array entries to %u\n",
+                        1 << (max_primary_streams + 1));
+        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
+        ep_ctx->ep_info |= EP_MAXPSTREAMS(max_primary_streams);
+        ep_ctx->ep_info |= EP_HAS_LSA;
+        ep_ctx->deq  = stream_info->ctx_array_dma;
+}
+
+/*
+ * Sets the MaxPStreams field and the Linear Stream Array field to 0.
+ * Reinstalls the "normal" endpoint ring (at its previous dequeue mark,
+ * not at the beginning of the ring).
+ */
+void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
+                struct xhci_ep_ctx *ep_ctx,
+                struct xhci_virt_ep *ep)
+{
+        dma_addr_t addr;
+        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
+        ep_ctx->ep_info &= ~EP_HAS_LSA;
+        addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue);
+        ep_ctx->deq  = addr | ep->ring->cycle_state;
+}
+
+/* Frees all stream contexts associated with the endpoint,
+ *
+ * Caller should fix the endpoint context streams fields.
+ */
+void xhci_free_stream_info(struct xhci_hcd *xhci,
+                struct xhci_stream_info *stream_info)
+{
+        int cur_stream;
+        struct xhci_ring *cur_ring;
+        dma_addr_t addr;
+
+        if (!stream_info)
+                return;
+
+        for (cur_stream = 1; cur_stream < stream_info->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 >> SEGMENT_SHIFT);
+                        xhci_ring_free(xhci, cur_ring);
+                        stream_info->stream_rings[cur_stream] = NULL;
+                }
+        }
+        xhci_free_command(xhci, stream_info->free_streams_command);
+        xhci->cmd_ring_reserved_trbs--;
+        if (stream_info->stream_ctx_array)
+                xhci_free_stream_ctx(xhci,
+                                stream_info->num_stream_ctxs,
+                                stream_info->stream_ctx_array,
+                                stream_info->ctx_array_dma);
+
+        if (stream_info)
+                kfree(stream_info->stream_rings);
+        kfree(stream_info);
+}
+
+
+/***************** Device context manipulation *************************/
+
 static void xhci_init_endpoint_timer(struct xhci_hcd *xhci,
                 struct xhci_virt_ep *ep)
 {
@@ -328,9 +744,13 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
         if (!dev)
                 return;
 
-        for (i = 0; i < 31; ++i)
+        for (i = 0; i < 31; ++i) {
                 if (dev->eps[i].ring)
                         xhci_ring_free(xhci, dev->eps[i].ring);
+                if (dev->eps[i].stream_info)
+                        xhci_free_stream_info(xhci,
+                                        dev->eps[i].stream_info);
+        }
 
         if (dev->ring_cache) {
                 for (i = 0; i < dev->num_rings_cached; i++)
@@ -344,7 +764,7 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
                 xhci_free_container_ctx(xhci, dev->out_ctx);
 
         kfree(xhci->devs[slot_id]);
-        xhci->devs[slot_id] = 0;
+        xhci->devs[slot_id] = NULL;
 }
 
 int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
@@ -590,9 +1010,9 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
 static inline u32 xhci_get_endpoint_mult(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
-        if (udev->speed != USB_SPEED_SUPER || !ep->ss_ep_comp)
+        if (udev->speed != USB_SPEED_SUPER)
                 return 0;
-        return ep->ss_ep_comp->desc.bmAttributes;
+        return ep->ss_ep_comp.bmAttributes;
 }
 
 static inline u32 xhci_get_endpoint_type(struct usb_device *udev,
@@ -641,13 +1061,8 @@ static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
                         usb_endpoint_xfer_bulk(&ep->desc))
                 return 0;
 
-        if (udev->speed == USB_SPEED_SUPER) {
-                if (ep->ss_ep_comp)
-                        return ep->ss_ep_comp->desc.wBytesPerInterval;
-                xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n");
-                /* Assume no bursts, no multiple opportunities to send. */
-                return ep->desc.wMaxPacketSize;
-        }
+        if (udev->speed == USB_SPEED_SUPER)
+                return ep->ss_ep_comp.wBytesPerInterval;
 
         max_packet = ep->desc.wMaxPacketSize & 0x3ff;
         max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
@@ -655,6 +1070,9 @@ static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
         return max_packet * (max_burst + 1);
 }
 
+/* Set up an endpoint with one ring segment.  Do not allocate stream rings.
+ * Drivers will have to call usb_alloc_streams() to do that.
+ */
 int xhci_endpoint_init(struct xhci_hcd *xhci,
                 struct xhci_virt_device *virt_dev,
                 struct usb_device *udev,
@@ -708,12 +1126,9 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                 max_packet = ep->desc.wMaxPacketSize;
                 ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
                 /* dig out max burst from ep companion desc */
-                if (!ep->ss_ep_comp) {
-                        xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n");
-                        max_packet = 0;
-                } else {
-                        max_packet = ep->ss_ep_comp->desc.bMaxBurst;
-                }
+                max_packet = ep->ss_ep_comp.bMaxBurst;
+                if (!max_packet)
+                        xhci_warn(xhci, "WARN no SS endpoint bMaxBurst\n");
                 ep_ctx->ep_info2 |= MAX_BURST(max_packet);
                 break;
         case USB_SPEED_HIGH:
@@ -1003,6 +1418,16 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->device_pool = NULL;
         xhci_dbg(xhci, "Freed device context pool\n");
 
+        if (xhci->small_streams_pool)
+                dma_pool_destroy(xhci->small_streams_pool);
+        xhci->small_streams_pool = NULL;
+        xhci_dbg(xhci, "Freed small stream array pool\n");
+
+        if (xhci->medium_streams_pool)
+                dma_pool_destroy(xhci->medium_streams_pool);
+        xhci->medium_streams_pool = NULL;
+        xhci_dbg(xhci, "Freed medium stream array pool\n");
+
         xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr);
         if (xhci->dcbaa)
                 pci_free_consistent(pdev, sizeof(*xhci->dcbaa),
@@ -1239,6 +1664,22 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         if (!xhci->segment_pool || !xhci->device_pool)
                 goto fail;
 
+        /* Linear stream context arrays don't have any boundary restrictions,
+         * and only need to be 16-byte aligned.
+         */
+        xhci->small_streams_pool =
+                dma_pool_create("xHCI 256 byte stream ctx arrays",
+                        dev, SMALL_STREAM_ARRAY_SIZE, 16, 0);
+        xhci->medium_streams_pool =
+                dma_pool_create("xHCI 1KB stream ctx arrays",
+                        dev, MEDIUM_STREAM_ARRAY_SIZE, 16, 0);
+        /* Any stream context array bigger than MEDIUM_STREAM_ARRAY_SIZE
+         * will be allocated with pci_alloc_consistent()
+         */
+
+        if (!xhci->small_streams_pool || !xhci->medium_streams_pool)
+                goto fail;
+
         /* Set up the command ring to have one segments for now. */
         xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags);
         if (!xhci->cmd_ring)
@@ -1330,7 +1771,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          */
         init_completion(&xhci->addr_dev);
         for (i = 0; i < MAX_HC_SLOTS; ++i)
-                xhci->devs[i] = 0;
+                xhci->devs[i] = NULL;
 
         if (scratchpad_alloc(xhci, flags))
                 goto fail;
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 417d37aff8d7..edffd81fc253 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -54,7 +54,7 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
         int                     retval;
 
-        hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 1;
+        hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
 
         xhci->cap_regs = hcd->regs;
         xhci->op_regs = hcd->regs +
@@ -132,6 +132,8 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .urb_dequeue =          xhci_urb_dequeue,
         .alloc_dev =            xhci_alloc_dev,
         .free_dev =             xhci_free_dev,
+        .alloc_streams =        xhci_alloc_streams,
+        .free_streams =         xhci_free_streams,
         .add_endpoint =         xhci_add_endpoint,
         .drop_endpoint =        xhci_drop_endpoint,
         .endpoint_reset =       xhci_endpoint_reset,
@@ -175,12 +177,12 @@ static struct pci_driver xhci_pci_driver = {
         .shutdown =     usb_hcd_pci_shutdown,
 };
 
-int xhci_register_pci()
+int xhci_register_pci(void)
 {
         return pci_register_driver(&xhci_pci_driver);
 }
 
-void xhci_unregister_pci()
+void xhci_unregister_pci(void)
 {
         pci_unregister_driver(&xhci_pci_driver);
 }
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 85d7e8f2085e..36c858e5b529 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -112,6 +112,12 @@ static inline int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 return (trb->link.control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK);
 }
 
+static inline int enqueue_is_link_trb(struct xhci_ring *ring)
+{
+        struct xhci_link_trb *link = &ring->enqueue->link;
+        return ((link->control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK));
+}
+
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
  * TRB is in a new segment.  This does not skip over link TRBs, and it does not
  * effect the ring dequeue or enqueue pointers.
@@ -193,20 +199,15 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
         while (last_trb(xhci, ring, ring->enq_seg, next)) {
                 if (!consumer) {
                         if (ring != xhci->event_ring) {
-                                /* If we're not dealing with 0.95 hardware,
-                                 * carry over the chain bit of the previous TRB
-                                 * (which may mean the chain bit is cleared).
-                                 */
-                                if (!xhci_link_trb_quirk(xhci)) {
-                                        next->link.control &= ~TRB_CHAIN;
-                                        next->link.control |= chain;
+                                if (chain) {
+                                        next->link.control |= TRB_CHAIN;
+
+                                        /* Give this link TRB to the hardware */
+                                        wmb();
+                                        next->link.control ^= TRB_CYCLE;
+                                } else {
+                                        break;
                                 }
-                                /* Give this link TRB to the hardware */
-                                wmb();
-                                if (next->link.control & TRB_CYCLE)
-                                        next->link.control &= (u32) ~TRB_CYCLE;
-                                else
-                                        next->link.control |= (u32) TRB_CYCLE;
                         }
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -242,10 +243,34 @@ static int room_on_ring(struct xhci_hcd *xhci, struct xhci_ring *ring,
         int i;
         union xhci_trb *enq = ring->enqueue;
         struct xhci_segment *enq_seg = ring->enq_seg;
+        struct xhci_segment *cur_seg;
+        unsigned int left_on_ring;
+
+        /* If we are currently pointing to a link TRB, advance the
+         * enqueue pointer before checking for space */
+        while (last_trb(xhci, ring, enq_seg, enq)) {
+                enq_seg = enq_seg->next;
+                enq = enq_seg->trbs;
+        }
 
         /* Check if ring is empty */
-        if (enq == ring->dequeue)
+        if (enq == ring->dequeue) {
+                /* Can't use link trbs */
+                left_on_ring = TRBS_PER_SEGMENT - 1;
+                for (cur_seg = enq_seg->next; cur_seg != enq_seg;
+                                cur_seg = cur_seg->next)
+                        left_on_ring += TRBS_PER_SEGMENT - 1;
+
+                /* Always need one TRB free in the ring. */
+                left_on_ring -= 1;
+                if (num_trbs > left_on_ring) {
+                        xhci_warn(xhci, "Not enough room on ring; "
+                                        "need %u TRBs, %u TRBs left\n",
+                                        num_trbs, left_on_ring);
+                        return 0;
+                }
                 return 1;
+        }
         /* Make sure there's an extra empty TRB available */
         for (i = 0; i <= num_trbs; ++i) {
                 if (enq == ring->dequeue)
@@ -295,7 +320,8 @@ void xhci_ring_cmd_db(struct xhci_hcd *xhci)
 
 static void ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
-                unsigned int ep_index)
+                unsigned int ep_index,
+                unsigned int stream_id)
 {
         struct xhci_virt_ep *ep;
         unsigned int ep_state;
@@ -306,11 +332,16 @@ static void ring_ep_doorbell(struct xhci_hcd *xhci,
         ep_state = ep->ep_state;
         /* Don't ring the doorbell for this endpoint if there are pending
          * cancellations because the we don't want to interrupt processing.
+         * We don't want to restart any stream rings if there's a set dequeue
+         * pointer command pending because the device can choose to start any
+         * stream once the endpoint is on the HW schedule.
+         * FIXME - check all the stream rings for pending cancellations.
          */
         if (!(ep_state & EP_HALT_PENDING) && !(ep_state & SET_DEQ_PENDING)
                         && !(ep_state & EP_HALTED)) {
                 field = xhci_readl(xhci, db_addr) & DB_MASK;
-                xhci_writel(xhci, field | EPI_TO_DB(ep_index), db_addr);
+                field |= EPI_TO_DB(ep_index) | STREAM_ID_TO_DB(stream_id);
+                xhci_writel(xhci, field, db_addr);
                 /* Flush PCI posted writes - FIXME Matthew Wilcox says this
                  * isn't time-critical and we shouldn't make the CPU wait for
                  * the flush.
@@ -319,6 +350,31 @@ static void ring_ep_doorbell(struct xhci_hcd *xhci,
         }
 }
 
+/* Ring the doorbell for any rings with pending URBs */
+static void ring_doorbell_for_active_rings(struct xhci_hcd *xhci,
+                unsigned int slot_id,
+                unsigned int ep_index)
+{
+        unsigned int stream_id;
+        struct xhci_virt_ep *ep;
+
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+
+        /* A ring has pending URBs if its TD list is not empty */
+        if (!(ep->ep_state & EP_HAS_STREAMS)) {
+                if (!(list_empty(&ep->ring->td_list)))
+                        ring_ep_doorbell(xhci, slot_id, ep_index, 0);
+                return;
+        }
+
+        for (stream_id = 1; stream_id < ep->stream_info->num_streams;
+                        stream_id++) {
+                struct xhci_stream_info *stream_info = ep->stream_info;
+                if (!list_empty(&stream_info->stream_rings[stream_id]->td_list))
+                        ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
+        }
+}
+
 /*
  * Find the segment that trb is in.  Start searching in start_seg.
  * If we must move past a segment that has a link TRB with a toggle cycle state
@@ -334,13 +390,14 @@ static struct xhci_segment *find_trb_seg(
         while (cur_seg->trbs > trb ||
                         &cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) {
                 generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic;
-                if (TRB_TYPE(generic_trb->field[3]) == TRB_LINK &&
+                if ((generic_trb->field[3] & TRB_TYPE_BITMASK) ==
+                                TRB_TYPE(TRB_LINK) &&
                                 (generic_trb->field[3] & LINK_TOGGLE))
                         *cycle_state = ~(*cycle_state) & 0x1;
                 cur_seg = cur_seg->next;
                 if (cur_seg == start_seg)
                         /* Looped over the entire list.  Oops! */
-                        return 0;
+                        return NULL;
         }
         return cur_seg;
 }
@@ -361,14 +418,23 @@ static struct xhci_segment *find_trb_seg(
  */
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
-                struct xhci_td *cur_td, struct xhci_dequeue_state *state)
+                unsigned int stream_id, struct xhci_td *cur_td,
+                struct xhci_dequeue_state *state)
 {
         struct xhci_virt_device *dev = xhci->devs[slot_id];
-        struct xhci_ring *ep_ring = dev->eps[ep_index].ring;
+        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,
+                        ep_index, stream_id);
+        if (!ep_ring) {
+                xhci_warn(xhci, "WARN can't find new dequeue state "
+                                "for invalid stream ID %u.\n",
+                                stream_id);
+                return;
+        }
         state->new_cycle_state = 0;
         xhci_dbg(xhci, "Finding segment containing stopped TRB.\n");
         state->new_deq_seg = find_trb_seg(cur_td->start_seg,
@@ -390,7 +456,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 BUG();
 
         trb = &state->new_deq_ptr->generic;
-        if (TRB_TYPE(trb->field[3]) == TRB_LINK &&
+        if ((trb->field[3] & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK) &&
                                 (trb->field[3] & LINK_TOGGLE))
                 state->new_cycle_state = ~(state->new_cycle_state) & 0x1;
         next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
@@ -448,11 +514,13 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
 }
 
 static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, struct xhci_segment *deq_seg,
+                unsigned int ep_index, unsigned int stream_id,
+                struct xhci_segment *deq_seg,
                 union xhci_trb *deq_ptr, u32 cycle_state);
 
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id,
                 struct xhci_dequeue_state *deq_state)
 {
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
@@ -464,7 +532,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
                         deq_state->new_deq_ptr,
                         (unsigned long long)xhci_trb_virt_to_dma(deq_state->new_deq_seg, deq_state->new_deq_ptr),
                         deq_state->new_cycle_state);
-        queue_set_tr_deq(xhci, slot_id, ep_index,
+        queue_set_tr_deq(xhci, slot_id, ep_index, stream_id,
                         deq_state->new_deq_seg,
                         deq_state->new_deq_ptr,
                         (u32) deq_state->new_cycle_state);
@@ -523,7 +591,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
         struct list_head *entry;
-        struct xhci_td *cur_td = 0;
+        struct xhci_td *cur_td = NULL;
         struct xhci_td *last_unlinked_td;
 
         struct xhci_dequeue_state deq_state;
@@ -532,11 +600,10 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
         ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
         ep = &xhci->devs[slot_id]->eps[ep_index];
-        ep_ring = ep->ring;
 
         if (list_empty(&ep->cancelled_td_list)) {
                 xhci_stop_watchdog_timer_in_irq(xhci, ep);
-                ring_ep_doorbell(xhci, slot_id, ep_index);
+                ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
 
@@ -550,15 +617,36 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                 xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n",
                                 cur_td->first_trb,
                                 (unsigned long long)xhci_trb_virt_to_dma(cur_td->start_seg, cur_td->first_trb));
+                ep_ring = xhci_urb_to_transfer_ring(xhci, cur_td->urb);
+                if (!ep_ring) {
+                        /* This shouldn't happen unless a driver is mucking
+                         * with the stream ID after submission.  This will
+                         * leave the TD on the hardware ring, and the hardware
+                         * will try to execute it, and may access a buffer
+                         * that has already been freed.  In the best case, the
+                         * hardware will execute it, and the event handler will
+                         * ignore the completion event for that TD, since it was
+                         * removed from the td_list for that endpoint.  In
+                         * short, don't muck with the stream ID after
+                         * submission.
+                         */
+                        xhci_warn(xhci, "WARN Cancelled URB %p "
+                                        "has invalid stream ID %u.\n",
+                                        cur_td->urb,
+                                        cur_td->urb->stream_id);
+                        goto remove_finished_td;
+                }
                 /*
                  * If we stopped on the TD we need to cancel, then we have to
                  * move the xHC endpoint ring dequeue pointer past this TD.
                  */
                 if (cur_td == ep->stopped_td)
-                        xhci_find_new_dequeue_state(xhci, slot_id, ep_index, cur_td,
-                                        &deq_state);
+                        xhci_find_new_dequeue_state(xhci, slot_id, ep_index,
+                                        cur_td->urb->stream_id,
+                                        cur_td, &deq_state);
                 else
                         td_to_noop(xhci, ep_ring, cur_td);
+remove_finished_td:
                 /*
                  * The event handler won't see a completion for this TD anymore,
                  * so remove it from the endpoint ring's TD list.  Keep it in
@@ -572,12 +660,16 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
                 xhci_queue_new_dequeue_state(xhci,
-                                slot_id, ep_index, &deq_state);
+                                slot_id, ep_index,
+                                ep->stopped_td->urb->stream_id,
+                                &deq_state);
                 xhci_ring_cmd_db(xhci);
         } else {
-                /* Otherwise just ring the doorbell to restart the ring */
-                ring_ep_doorbell(xhci, slot_id, ep_index);
+                /* Otherwise ring the doorbell(s) to restart queued transfers */
+                ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
         }
+        ep->stopped_td = NULL;
+        ep->stopped_trb = NULL;
 
         /*
          * Drop the lock and complete the URBs in the cancelled TD list.
@@ -734,6 +826,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
 {
         unsigned int slot_id;
         unsigned int ep_index;
+        unsigned int stream_id;
         struct xhci_ring *ep_ring;
         struct xhci_virt_device *dev;
         struct xhci_ep_ctx *ep_ctx;
@@ -741,8 +834,19 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
 
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
         ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        stream_id = TRB_TO_STREAM_ID(trb->generic.field[2]);
         dev = xhci->devs[slot_id];
-        ep_ring = dev->eps[ep_index].ring;
+
+        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",
+                                stream_id);
+                /* XXX: Harmless??? */
+                dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
+                return;
+        }
+
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
 
@@ -787,7 +891,8 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         }
 
         dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
-        ring_ep_doorbell(xhci, slot_id, ep_index);
+        /* Restart any rings with pending URBs */
+        ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
 }
 
 static void handle_reset_ep_completion(struct xhci_hcd *xhci,
@@ -796,11 +901,9 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
 {
         int slot_id;
         unsigned int ep_index;
-        struct xhci_ring *ep_ring;
 
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
         ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
-        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
         /* This command will only fail if the endpoint wasn't halted,
          * but we don't care.
          */
@@ -818,9 +921,9 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
                                 false);
                 xhci_ring_cmd_db(xhci);
         } else {
-                /* Clear our internal halted state and restart the ring */
+                /* Clear our internal halted state and restart the ring(s) */
                 xhci->devs[slot_id]->eps[ep_index].ep_state &= ~EP_HALTED;
-                ring_ep_doorbell(xhci, slot_id, ep_index);
+                ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
         }
 }
 
@@ -897,16 +1000,19 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                  * Configure endpoint commands can come from the USB core
                  * configuration or alt setting changes, or because the HW
                  * needed an extra configure endpoint command after a reset
-                 * endpoint command.  In the latter case, the xHCI driver is
-                 * not waiting on the configure endpoint command.
+                 * endpoint command or streams were being configured.
+                 * If the command was for a halted endpoint, the xHCI driver
+                 * is not waiting on the configure endpoint command.
                  */
                 ctrl_ctx = xhci_get_input_control_ctx(xhci,
                                 virt_dev->in_ctx);
                 /* Input ctx add_flags are the endpoint index plus one */
                 ep_index = xhci_last_valid_endpoint(ctrl_ctx->add_flags) - 1;
                 /* A usb_set_interface() call directly after clearing a halted
-                 * condition may race on this quirky hardware.
-                 * Not worth worrying about, since this is prototype hardware.
+                 * condition may race on this quirky hardware.  Not worth
+                 * worrying about, since this is prototype hardware.  Not sure
+                 * if this will work for streams, but streams support was
+                 * untested on this prototype.
                  */
                 if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
                                 ep_index != (unsigned int) -1 &&
@@ -919,10 +1025,10 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                         xhci_dbg(xhci, "Completed config ep cmd - "
                                         "last ep index = %d, state = %d\n",
                                         ep_index, ep_state);
-                        /* Clear our internal halted state and restart ring */
+                        /* Clear internal halted state and restart ring(s) */
                         xhci->devs[slot_id]->eps[ep_index].ep_state &=
                                 ~EP_HALTED;
-                        ring_ep_doorbell(xhci, slot_id, ep_index);
+                        ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                         break;
                 }
 bandwidth_change:
@@ -1018,7 +1124,7 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
 
         do {
                 if (start_dma == 0)
-                        return 0;
+                        return NULL;
                 /* We may get an event for a Link TRB in the middle of a TD */
                 end_seg_dma = xhci_trb_virt_to_dma(cur_seg,
                                 &cur_seg->trbs[TRBS_PER_SEGMENT - 1]);
@@ -1040,7 +1146,7 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                                                  suspect_dma <= end_trb_dma))
                                         return cur_seg;
                         }
-                        return 0;
+                        return NULL;
                 } else {
                         /* Might still be somewhere in this segment */
                         if (suspect_dma >= start_dma && suspect_dma <= end_seg_dma)
@@ -1050,19 +1156,27 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 start_dma = xhci_trb_virt_to_dma(cur_seg, &cur_seg->trbs[0]);
         } while (cur_seg != start_seg);
 
-        return 0;
+        return NULL;
 }
 
 static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id,
                 struct xhci_td *td, union xhci_trb *event_trb)
 {
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
         ep->ep_state |= EP_HALTED;
         ep->stopped_td = td;
         ep->stopped_trb = event_trb;
+        ep->stopped_stream = stream_id;
+
         xhci_queue_reset_ep(xhci, slot_id, ep_index);
         xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
+
+        ep->stopped_td = NULL;
+        ep->stopped_trb = NULL;
+        ep->stopped_stream = 0;
+
         xhci_ring_cmd_db(xhci);
 }
 
@@ -1119,11 +1233,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         unsigned int slot_id;
         int ep_index;
-        struct xhci_td *td = 0;
+        struct xhci_td *td = NULL;
         dma_addr_t event_dma;
         struct xhci_segment *event_seg;
         union xhci_trb *event_trb;
-        struct urb *urb = 0;
+        struct urb *urb = NULL;
         int status = -EINPROGRESS;
         struct xhci_ep_ctx *ep_ctx;
         u32 trb_comp_code;
@@ -1140,10 +1254,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         ep_index = TRB_TO_EP_ID(event->flags) - 1;
         xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
         ep = &xdev->eps[ep_index];
-        ep_ring = ep->ring;
+        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
         if (!ep_ring || (ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED) {
-                xhci_err(xhci, "ERROR Transfer event pointed to disabled endpoint\n");
+                xhci_err(xhci, "ERROR Transfer event for disabled endpoint "
+                                "or incorrect stream ring\n");
                 return -ENODEV;
         }
 
@@ -1274,7 +1389,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                 td->urb->actual_length = 0;
 
                         xhci_cleanup_halted_endpoint(xhci,
-                                        slot_id, ep_index, td, event_trb);
+                                        slot_id, ep_index, 0, td, event_trb);
                         goto td_cleanup;
                 }
                 /*
@@ -1390,8 +1505,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg;
                                         cur_trb != event_trb;
                                         next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                                if (TRB_TYPE(cur_trb->generic.field[3]) != TRB_TR_NOOP &&
-                                                TRB_TYPE(cur_trb->generic.field[3]) != TRB_LINK)
+                                if ((cur_trb->generic.field[3] &
+                                 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
+                                    (cur_trb->generic.field[3] &
+                                 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
                                         td->urb->actual_length +=
                                                 TRB_LEN(cur_trb->generic.field[2]);
                         }
@@ -1423,6 +1540,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                          */
                         ep->stopped_td = td;
                         ep->stopped_trb = event_trb;
+                        ep->stopped_stream = ep_ring->stream_id;
                 } else if (xhci_requires_manual_halt_cleanup(xhci,
                                         ep_ctx, trb_comp_code)) {
                         /* Other types of errors halt the endpoint, but the
@@ -1431,7 +1549,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                          * xHCI hardware manually.
                          */
                         xhci_cleanup_halted_endpoint(xhci,
-                                        slot_id, ep_index, td, event_trb);
+                                        slot_id, ep_index, ep_ring->stream_id, td, event_trb);
                 } else {
                         /* Update ring dequeue pointer */
                         while (ep_ring->dequeue != td->last_trb)
@@ -1621,20 +1739,66 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 xhci_err(xhci, "ERROR no room on ep ring\n");
                 return -ENOMEM;
         }
+
+        if (enqueue_is_link_trb(ep_ring)) {
+                struct xhci_ring *ring = ep_ring;
+                union xhci_trb *next;
+
+                xhci_dbg(xhci, "prepare_ring: pointing to link trb\n");
+                next = ring->enqueue;
+
+                while (last_trb(xhci, ring, ring->enq_seg, next)) {
+
+                        /* If we're not dealing with 0.95 hardware,
+                         * clear the chain bit.
+                         */
+                        if (!xhci_link_trb_quirk(xhci))
+                                next->link.control &= ~TRB_CHAIN;
+                        else
+                                next->link.control |= TRB_CHAIN;
+
+                        wmb();
+                        next->link.control ^= (u32) TRB_CYCLE;
+
+                        /* Toggle the cycle bit after the last ring segment. */
+                        if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
+                                ring->cycle_state = (ring->cycle_state ? 0 : 1);
+                                if (!in_interrupt()) {
+                                        xhci_dbg(xhci, "queue_trb: Toggle cycle "
+                                                "state for ring %p = %i\n",
+                                                ring, (unsigned int)ring->cycle_state);
+                                }
+                        }
+                        ring->enq_seg = ring->enq_seg->next;
+                        ring->enqueue = ring->enq_seg->trbs;
+                        next = ring->enqueue;
+                }
+        }
+
         return 0;
 }
 
 static int prepare_transfer(struct xhci_hcd *xhci,
                 struct xhci_virt_device *xdev,
                 unsigned int ep_index,
+                unsigned int stream_id,
                 unsigned int num_trbs,
                 struct urb *urb,
                 struct xhci_td **td,
                 gfp_t mem_flags)
 {
         int ret;
+        struct xhci_ring *ep_ring;
         struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        ret = prepare_ring(xhci, xdev->eps[ep_index].ring,
+
+        ep_ring = xhci_stream_id_to_ring(xdev, ep_index, stream_id);
+        if (!ep_ring) {
+                xhci_dbg(xhci, "Can't prepare ring for bad stream ID %u\n",
+                                stream_id);
+                return -EINVAL;
+        }
+
+        ret = prepare_ring(xhci, ep_ring,
                         ep_ctx->ep_info & EP_STATE_MASK,
                         num_trbs, mem_flags);
         if (ret)
@@ -1654,9 +1818,9 @@ static int prepare_transfer(struct xhci_hcd *xhci,
         (*td)->urb = urb;
         urb->hcpriv = (void *) (*td);
         /* Add this TD to the tail of the endpoint ring's TD list */
-        list_add_tail(&(*td)->td_list, &xdev->eps[ep_index].ring->td_list);
-        (*td)->start_seg = xdev->eps[ep_index].ring->enq_seg;
-        (*td)->first_trb = xdev->eps[ep_index].ring->enqueue;
+        list_add_tail(&(*td)->td_list, &ep_ring->td_list);
+        (*td)->start_seg = ep_ring->enq_seg;
+        (*td)->first_trb = ep_ring->enqueue;
 
         return 0;
 }
@@ -1672,7 +1836,7 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
 
         xhci_dbg(xhci, "count sg list trbs: \n");
         num_trbs = 0;
-        for_each_sg(urb->sg->sg, sg, num_sgs, i) {
+        for_each_sg(urb->sg, sg, num_sgs, i) {
                 unsigned int previous_total_trbs = num_trbs;
                 unsigned int len = sg_dma_len(sg);
 
@@ -1722,7 +1886,7 @@ static void check_trb_math(struct urb *urb, int num_trbs, int running_total)
 }
 
 static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, int start_cycle,
+                unsigned int ep_index, unsigned int stream_id, int start_cycle,
                 struct xhci_generic_trb *start_trb, struct xhci_td *td)
 {
         /*
@@ -1731,7 +1895,7 @@ static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id,
          */
         wmb();
         start_trb->field[3] |= start_cycle;
-        ring_ep_doorbell(xhci, slot_id, ep_index);
+        ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
 }
 
 /*
@@ -1805,12 +1969,16 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         struct xhci_generic_trb *start_trb;
         int start_cycle;
 
-        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
+        ep_ring = xhci_urb_to_transfer_ring(xhci, urb);
+        if (!ep_ring)
+                return -EINVAL;
+
         num_trbs = count_sg_trbs_needed(xhci, urb);
         num_sgs = urb->num_sgs;
 
         trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id],
-                        ep_index, num_trbs, urb, &td, mem_flags);
+                        ep_index, urb->stream_id,
+                        num_trbs, urb, &td, mem_flags);
         if (trb_buff_len < 0)
                 return trb_buff_len;
         /*
@@ -1831,7 +1999,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
          *    the amount of memory allocated for this scatter-gather list.
          * 3. TRBs buffers can't cross 64KB boundaries.
          */
-        sg = urb->sg->sg;
+        sg = urb->sg;
         addr = (u64) sg_dma_address(sg);
         this_sg_len = sg_dma_len(sg);
         trb_buff_len = TRB_MAX_BUFF_SIZE -
@@ -1919,7 +2087,8 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         } while (running_total < urb->transfer_buffer_length);
 
         check_trb_math(urb, num_trbs, running_total);
-        giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td);
+        giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
+                        start_cycle, start_trb, td);
         return 0;
 }
 
@@ -1938,10 +2107,12 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         int running_total, trb_buff_len, ret;
         u64 addr;
 
-        if (urb->sg)
+        if (urb->num_sgs)
                 return queue_bulk_sg_tx(xhci, mem_flags, urb, slot_id, ep_index);
 
-        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
+        ep_ring = xhci_urb_to_transfer_ring(xhci, urb);
+        if (!ep_ring)
+                return -EINVAL;
 
         num_trbs = 0;
         /* How much data is (potentially) left before the 64KB boundary? */
@@ -1968,7 +2139,8 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 (unsigned long long)urb->transfer_dma,
                                 num_trbs);
 
-        ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
+        ret = prepare_transfer(xhci, xhci->devs[slot_id],
+                        ep_index, urb->stream_id,
                         num_trbs, urb, &td, mem_flags);
         if (ret < 0)
                 return ret;
@@ -2038,7 +2210,8 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         } while (running_total < urb->transfer_buffer_length);
 
         check_trb_math(urb, num_trbs, running_total);
-        giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td);
+        giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
+                        start_cycle, start_trb, td);
         return 0;
 }
 
@@ -2055,7 +2228,9 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         u32 field, length_field;
         struct xhci_td *td;
 
-        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
+        ep_ring = xhci_urb_to_transfer_ring(xhci, urb);
+        if (!ep_ring)
+                return -EINVAL;
 
         /*
          * Need to copy setup packet into setup TRB, so we can't use the setup
@@ -2076,8 +2251,9 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
          */
         if (urb->transfer_buffer_length > 0)
                 num_trbs++;
-        ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index, num_trbs,
-                        urb, &td, mem_flags);
+        ret = prepare_transfer(xhci, xhci->devs[slot_id],
+                        ep_index, urb->stream_id,
+                        num_trbs, urb, &td, mem_flags);
         if (ret < 0)
                 return ret;
 
@@ -2132,7 +2308,8 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         /* Event on completion */
                         field | TRB_IOC | TRB_TYPE(TRB_STATUS) | ep_ring->cycle_state);
 
-        giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td);
+        giveback_first_trb(xhci, slot_id, ep_index, 0,
+                        start_cycle, start_trb, td);
         return 0;
 }
 
@@ -2244,12 +2421,14 @@ int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
  * This should not be used for endpoints that have streams enabled.
  */
 static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, struct xhci_segment *deq_seg,
+                unsigned int ep_index, unsigned int stream_id,
+                struct xhci_segment *deq_seg,
                 union xhci_trb *deq_ptr, u32 cycle_state)
 {
         dma_addr_t addr;
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
+        u32 trb_stream_id = STREAM_ID_FOR_TRB(stream_id);
         u32 type = TRB_TYPE(TRB_SET_DEQ);
 
         addr = xhci_trb_virt_to_dma(deq_seg, deq_ptr);
@@ -2260,7 +2439,7 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
                 return 0;
         }
         return queue_command(xhci, lower_32_bits(addr) | cycle_state,
-                        upper_32_bits(addr), 0,
+                        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 7e4277273908..40e0a0c221b8 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/irq.h>
+#include <linux/log2.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/slab.h>
@@ -352,11 +353,7 @@ void xhci_event_ring_work(unsigned long arg)
                 if (!xhci->devs[i])
                         continue;
                 for (j = 0; j < 31; ++j) {
-                        struct xhci_ring *ring = xhci->devs[i]->eps[j].ring;
-                        if (!ring)
-                                continue;
-                        xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);
-                        xhci_debug_segment(xhci, ring->deq_seg);
+                        xhci_dbg_ep_rings(xhci, i, j, &xhci->devs[i]->eps[j]);
                 }
         }
 
@@ -726,8 +723,21 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                 spin_lock_irqsave(&xhci->lock, flags);
                 if (xhci->xhc_state & XHCI_STATE_DYING)
                         goto dying;
-                ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
-                                slot_id, ep_index);
+                if (xhci->devs[slot_id]->eps[ep_index].ep_state &
+                                EP_GETTING_STREAMS) {
+                        xhci_warn(xhci, "WARN: Can't enqueue URB while bulk ep "
+                                        "is transitioning to using streams.\n");
+                        ret = -EINVAL;
+                } else if (xhci->devs[slot_id]->eps[ep_index].ep_state &
+                                EP_GETTING_NO_STREAMS) {
+                        xhci_warn(xhci, "WARN: Can't enqueue URB while bulk ep "
+                                        "is transitioning to "
+                                        "not having streams.\n");
+                        ret = -EINVAL;
+                } else {
+                        ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
+                                        slot_id, ep_index);
+                }
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -825,7 +835,12 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         xhci_debug_ring(xhci, xhci->event_ring);
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
         ep = &xhci->devs[urb->dev->slot_id]->eps[ep_index];
-        ep_ring = ep->ring;
+        ep_ring = xhci_urb_to_transfer_ring(xhci, urb);
+        if (!ep_ring) {
+                ret = -EINVAL;
+                goto done;
+        }
+
         xhci_dbg(xhci, "Endpoint ring:\n");
         xhci_debug_ring(xhci, ep_ring);
         td = (struct xhci_td *) urb->hcpriv;
@@ -1369,7 +1384,7 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
          * or it will attempt to resend it on the next doorbell ring.
          */
         xhci_find_new_dequeue_state(xhci, udev->slot_id,
-                        ep_index, ep->stopped_td,
+                        ep_index, ep->stopped_stream, ep->stopped_td,
                         &deq_state);
 
         /* HW with the reset endpoint quirk will use the saved dequeue state to
@@ -1378,10 +1393,12 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
         if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {
                 xhci_dbg(xhci, "Queueing new dequeue state\n");
                 xhci_queue_new_dequeue_state(xhci, udev->slot_id,
-                                ep_index, &deq_state);
+                                ep_index, ep->stopped_stream, &deq_state);
         } else {
                 /* Better hope no one uses the input context between now and the
                  * reset endpoint completion!
+                 * XXX: No idea how this hardware will react when stream rings
+                 * are enabled.
                  */
                 xhci_dbg(xhci, "Setting up input context for "
                                 "configure endpoint command\n");
@@ -1438,12 +1455,391 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
                 kfree(virt_ep->stopped_td);
                 xhci_ring_cmd_db(xhci);
         }
+        virt_ep->stopped_td = NULL;
+        virt_ep->stopped_trb = NULL;
+        virt_ep->stopped_stream = 0;
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         if (ret)
                 xhci_warn(xhci, "FIXME allocate a new ring segment\n");
 }
 
+static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
+                struct usb_device *udev, struct usb_host_endpoint *ep,
+                unsigned int slot_id)
+{
+        int ret;
+        unsigned int ep_index;
+        unsigned int ep_state;
+
+        if (!ep)
+                return -EINVAL;
+        ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, __func__);
+        if (ret <= 0)
+                return -EINVAL;
+        if (ep->ss_ep_comp.bmAttributes == 0) {
+                xhci_warn(xhci, "WARN: SuperSpeed Endpoint Companion"
+                                " descriptor for ep 0x%x does not support streams\n",
+                                ep->desc.bEndpointAddress);
+                return -EINVAL;
+        }
+
+        ep_index = xhci_get_endpoint_index(&ep->desc);
+        ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
+        if (ep_state & EP_HAS_STREAMS ||
+                        ep_state & EP_GETTING_STREAMS) {
+                xhci_warn(xhci, "WARN: SuperSpeed bulk endpoint 0x%x "
+                                "already has streams set up.\n",
+                                ep->desc.bEndpointAddress);
+                xhci_warn(xhci, "Send email to xHCI maintainer and ask for "
+                                "dynamic stream context array reallocation.\n");
+                return -EINVAL;
+        }
+        if (!list_empty(&xhci->devs[slot_id]->eps[ep_index].ring->td_list)) {
+                xhci_warn(xhci, "Cannot setup streams for SuperSpeed bulk "
+                                "endpoint 0x%x; URBs are pending.\n",
+                                ep->desc.bEndpointAddress);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static void xhci_calculate_streams_entries(struct xhci_hcd *xhci,
+                unsigned int *num_streams, unsigned int *num_stream_ctxs)
+{
+        unsigned int max_streams;
+
+        /* The stream context array size must be a power of two */
+        *num_stream_ctxs = roundup_pow_of_two(*num_streams);
+        /*
+         * Find out how many primary stream array entries the host controller
+         * supports.  Later we may use secondary stream arrays (similar to 2nd
+         * level page entries), but that's an optional feature for xHCI host
+         * controllers. xHCs must support at least 4 stream IDs.
+         */
+        max_streams = HCC_MAX_PSA(xhci->hcc_params);
+        if (*num_stream_ctxs > max_streams) {
+                xhci_dbg(xhci, "xHCI HW only supports %u stream ctx entries.\n",
+                                max_streams);
+                *num_stream_ctxs = max_streams;
+                *num_streams = max_streams;
+        }
+}
+
+/* Returns an error code if one of the endpoint already has streams.
+ * This does not change any data structures, it only checks and gathers
+ * information.
+ */
+static int xhci_calculate_streams_and_bitmask(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int *num_streams, u32 *changed_ep_bitmask)
+{
+        unsigned int max_streams;
+        unsigned int endpoint_flag;
+        int i;
+        int ret;
+
+        for (i = 0; i < num_eps; i++) {
+                ret = xhci_check_streams_endpoint(xhci, udev,
+                                eps[i], udev->slot_id);
+                if (ret < 0)
+                        return ret;
+
+                max_streams = USB_SS_MAX_STREAMS(
+                                eps[i]->ss_ep_comp.bmAttributes);
+                if (max_streams < (*num_streams - 1)) {
+                        xhci_dbg(xhci, "Ep 0x%x only supports %u stream IDs.\n",
+                                        eps[i]->desc.bEndpointAddress,
+                                        max_streams);
+                        *num_streams = max_streams+1;
+                }
+
+                endpoint_flag = xhci_get_endpoint_flag(&eps[i]->desc);
+                if (*changed_ep_bitmask & endpoint_flag)
+                        return -EINVAL;
+                *changed_ep_bitmask |= endpoint_flag;
+        }
+        return 0;
+}
+
+static u32 xhci_calculate_no_streams_bitmask(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps)
+{
+        u32 changed_ep_bitmask = 0;
+        unsigned int slot_id;
+        unsigned int ep_index;
+        unsigned int ep_state;
+        int i;
+
+        slot_id = udev->slot_id;
+        if (!xhci->devs[slot_id])
+                return 0;
+
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
+                /* Are streams already being freed for the endpoint? */
+                if (ep_state & EP_GETTING_NO_STREAMS) {
+                        xhci_warn(xhci, "WARN Can't disable streams for "
+                                        "endpoint 0x%x\n, "
+                                        "streams are being disabled already.",
+                                        eps[i]->desc.bEndpointAddress);
+                        return 0;
+                }
+                /* Are there actually any streams to free? */
+                if (!(ep_state & EP_HAS_STREAMS) &&
+                                !(ep_state & EP_GETTING_STREAMS)) {
+                        xhci_warn(xhci, "WARN Can't disable streams for "
+                                        "endpoint 0x%x\n, "
+                                        "streams are already disabled!",
+                                        eps[i]->desc.bEndpointAddress);
+                        xhci_warn(xhci, "WARN xhci_free_streams() called "
+                                        "with non-streams endpoint\n");
+                        return 0;
+                }
+                changed_ep_bitmask |= xhci_get_endpoint_flag(&eps[i]->desc);
+        }
+        return changed_ep_bitmask;
+}
+
+/*
+ * The USB device drivers use this function (though the HCD interface in USB
+ * core) to prepare a set of bulk endpoints to use streams.  Streams are used to
+ * coordinate mass storage command queueing across multiple endpoints (basically
+ * a stream ID == a task ID).
+ *
+ * Setting up streams involves allocating the same size stream context array
+ * for each endpoint and issuing a configure endpoint command for all endpoints.
+ *
+ * Don't allow the call to succeed if one endpoint only supports one stream
+ * (which means it doesn't support streams at all).
+ *
+ * Drivers may get less stream IDs than they asked for, if the host controller
+ * hardware or endpoints claim they can't support the number of requested
+ * stream IDs.
+ */
+int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int num_streams, gfp_t mem_flags)
+{
+        int i, ret;
+        struct xhci_hcd *xhci;
+        struct xhci_virt_device *vdev;
+        struct xhci_command *config_cmd;
+        unsigned int ep_index;
+        unsigned int num_stream_ctxs;
+        unsigned long flags;
+        u32 changed_ep_bitmask = 0;
+
+        if (!eps)
+                return -EINVAL;
+
+        /* Add one to the number of streams requested to account for
+         * stream 0 that is reserved for xHCI usage.
+         */
+        num_streams += 1;
+        xhci = hcd_to_xhci(hcd);
+        xhci_dbg(xhci, "Driver wants %u stream IDs (including stream 0).\n",
+                        num_streams);
+
+        config_cmd = xhci_alloc_command(xhci, true, true, mem_flags);
+        if (!config_cmd) {
+                xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
+                return -ENOMEM;
+        }
+
+        /* Check to make sure all endpoints are not already configured for
+         * streams.  While we're at it, find the maximum number of streams that
+         * all the endpoints will support and check for duplicate endpoints.
+         */
+        spin_lock_irqsave(&xhci->lock, flags);
+        ret = xhci_calculate_streams_and_bitmask(xhci, udev, eps,
+                        num_eps, &num_streams, &changed_ep_bitmask);
+        if (ret < 0) {
+                xhci_free_command(xhci, config_cmd);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return ret;
+        }
+        if (num_streams <= 1) {
+                xhci_warn(xhci, "WARN: endpoints can't handle "
+                                "more than one stream.\n");
+                xhci_free_command(xhci, config_cmd);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return -EINVAL;
+        }
+        vdev = xhci->devs[udev->slot_id];
+        /* Mark each endpoint as being in transistion, so
+         * xhci_urb_enqueue() will reject all URBs.
+         */
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                vdev->eps[ep_index].ep_state |= EP_GETTING_STREAMS;
+        }
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Setup internal data structures and allocate HW data structures for
+         * streams (but don't install the HW structures in the input context
+         * until we're sure all memory allocation succeeded).
+         */
+        xhci_calculate_streams_entries(xhci, &num_streams, &num_stream_ctxs);
+        xhci_dbg(xhci, "Need %u stream ctx entries for %u stream IDs.\n",
+                        num_stream_ctxs, num_streams);
+
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                vdev->eps[ep_index].stream_info = xhci_alloc_stream_info(xhci,
+                                num_stream_ctxs,
+                                num_streams, mem_flags);
+                if (!vdev->eps[ep_index].stream_info)
+                        goto cleanup;
+                /* Set maxPstreams in endpoint context and update deq ptr to
+                 * point to stream context array. FIXME
+                 */
+        }
+
+        /* Set up the input context for a configure endpoint command. */
+        for (i = 0; i < num_eps; i++) {
+                struct xhci_ep_ctx *ep_ctx;
+
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                ep_ctx = xhci_get_ep_ctx(xhci, config_cmd->in_ctx, ep_index);
+
+                xhci_endpoint_copy(xhci, config_cmd->in_ctx,
+                                vdev->out_ctx, ep_index);
+                xhci_setup_streams_ep_input_ctx(xhci, ep_ctx,
+                                vdev->eps[ep_index].stream_info);
+        }
+        /* Tell the HW to drop its old copy of the endpoint context info
+         * and add the updated copy from the input context.
+         */
+        xhci_setup_input_ctx_for_config_ep(xhci, config_cmd->in_ctx,
+                        vdev->out_ctx, changed_ep_bitmask, changed_ep_bitmask);
+
+        /* Issue and wait for the configure endpoint command */
+        ret = xhci_configure_endpoint(xhci, udev, config_cmd,
+                        false, false);
+
+        /* xHC rejected the configure endpoint command for some reason, so we
+         * leave the old ring intact and free our internal streams data
+         * structure.
+         */
+        if (ret < 0)
+                goto cleanup;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                vdev->eps[ep_index].ep_state &= ~EP_GETTING_STREAMS;
+                xhci_dbg(xhci, "Slot %u ep ctx %u now has streams.\n",
+                         udev->slot_id, ep_index);
+                vdev->eps[ep_index].ep_state |= EP_HAS_STREAMS;
+        }
+        xhci_free_command(xhci, config_cmd);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Subtract 1 for stream 0, which drivers can't use */
+        return num_streams - 1;
+
+cleanup:
+        /* If it didn't work, free the streams! */
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                xhci_free_stream_info(xhci, vdev->eps[ep_index].stream_info);
+                vdev->eps[ep_index].stream_info = NULL;
+                /* FIXME Unset maxPstreams in endpoint context and
+                 * update deq ptr to point to normal string ring.
+                 */
+                vdev->eps[ep_index].ep_state &= ~EP_GETTING_STREAMS;
+                vdev->eps[ep_index].ep_state &= ~EP_HAS_STREAMS;
+                xhci_endpoint_zero(xhci, vdev, eps[i]);
+        }
+        xhci_free_command(xhci, config_cmd);
+        return -ENOMEM;
+}
+
+/* Transition the endpoint from using streams to being a "normal" endpoint
+ * without streams.
+ *
+ * Modify the endpoint context state, submit a configure endpoint command,
+ * and free all endpoint rings for streams if that completes successfully.
+ */
+int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                gfp_t mem_flags)
+{
+        int i, ret;
+        struct xhci_hcd *xhci;
+        struct xhci_virt_device *vdev;
+        struct xhci_command *command;
+        unsigned int ep_index;
+        unsigned long flags;
+        u32 changed_ep_bitmask;
+
+        xhci = hcd_to_xhci(hcd);
+        vdev = xhci->devs[udev->slot_id];
+
+        /* Set up a configure endpoint command to remove the streams rings */
+        spin_lock_irqsave(&xhci->lock, flags);
+        changed_ep_bitmask = xhci_calculate_no_streams_bitmask(xhci,
+                        udev, eps, num_eps);
+        if (changed_ep_bitmask == 0) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return -EINVAL;
+        }
+
+        /* Use the xhci_command structure from the first endpoint.  We may have
+         * allocated too many, but the driver may call xhci_free_streams() for
+         * each endpoint it grouped into one call to xhci_alloc_streams().
+         */
+        ep_index = xhci_get_endpoint_index(&eps[0]->desc);
+        command = vdev->eps[ep_index].stream_info->free_streams_command;
+        for (i = 0; i < num_eps; i++) {
+                struct xhci_ep_ctx *ep_ctx;
+
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                ep_ctx = xhci_get_ep_ctx(xhci, command->in_ctx, ep_index);
+                xhci->devs[udev->slot_id]->eps[ep_index].ep_state |=
+                        EP_GETTING_NO_STREAMS;
+
+                xhci_endpoint_copy(xhci, command->in_ctx,
+                                vdev->out_ctx, ep_index);
+                xhci_setup_no_streams_ep_input_ctx(xhci, ep_ctx,
+                                &vdev->eps[ep_index]);
+        }
+        xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx,
+                        vdev->out_ctx, changed_ep_bitmask, changed_ep_bitmask);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Issue and wait for the configure endpoint command,
+         * which must succeed.
+         */
+        ret = xhci_configure_endpoint(xhci, udev, command,
+                        false, true);
+
+        /* xHC rejected the configure endpoint command for some reason, so we
+         * leave the streams rings intact.
+         */
+        if (ret < 0)
+                return ret;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        for (i = 0; i < num_eps; i++) {
+                ep_index = xhci_get_endpoint_index(&eps[i]->desc);
+                xhci_free_stream_info(xhci, vdev->eps[ep_index].stream_info);
+                vdev->eps[ep_index].stream_info = NULL;
+                /* FIXME Unset maxPstreams in endpoint context and
+                 * update deq ptr to point to normal string ring.
+                 */
+                vdev->eps[ep_index].ep_state &= ~EP_GETTING_NO_STREAMS;
+                vdev->eps[ep_index].ep_state &= ~EP_HAS_STREAMS;
+        }
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        return 0;
+}
+
 /*
  * This submits a Reset Device Command, which will set the device state to 0,
  * set the device address to 0, and disable all the endpoints except the default
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index ea389e9a4931..dada2fb59261 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -26,8 +26,8 @@
 #include <linux/usb.h>
 #include <linux/timer.h>
 #include <linux/kernel.h>
+#include <linux/usb/hcd.h>
 
-#include "../core/hcd.h"
 /* Code sharing between pci-quirks and xhci hcd */
 #include        "xhci-ext-caps.h"
 
@@ -117,7 +117,7 @@ struct xhci_cap_regs {
 /* true: no secondary Stream ID Support */
 #define HCC_NSS(p)              ((p) & (1 << 7))
 /* Max size for Primary Stream Arrays - 2^(n+1), where n is bits 12:15 */
-#define HCC_MAX_PSA             (1 << ((((p) >> 12) & 0xf) + 1))
+#define HCC_MAX_PSA(p)          (1 << ((((p) >> 12) & 0xf) + 1))
 /* Extended Capabilities pointer from PCI base - section 5.3.6 */
 #define HCC_EXT_CAPS(p)         XHCI_HCC_EXT_CAPS(p)
 
@@ -444,6 +444,7 @@ struct xhci_doorbell_array {
 
 /* Endpoint Target - bits 0:7 */
 #define EPI_TO_DB(p)            (((p) + 1) & 0xff)
+#define STREAM_ID_TO_DB(p)      (((p) & 0xffff) << 16)
 
 
 /**
@@ -585,6 +586,10 @@ struct xhci_ep_ctx {
 /* Interval - period between requests to an endpoint - 125u increments. */
 #define EP_INTERVAL(p)          ((p & 0xff) << 16)
 #define EP_INTERVAL_TO_UFRAMES(p)               (1 << (((p) >> 16) & 0xff))
+#define EP_MAXPSTREAMS_MASK     (0x1f << 10)
+#define EP_MAXPSTREAMS(p)       (((p) << 10) & EP_MAXPSTREAMS_MASK)
+/* Endpoint is set up with a Linear Stream Array (vs. Secondary Stream Array) */
+#define EP_HAS_LSA              (1 << 15)
 
 /* ep_info2 bitmasks */
 /*
@@ -648,8 +653,50 @@ struct xhci_command {
 /* add context bitmasks */
 #define ADD_EP(x)       (0x1 << x)
 
+struct xhci_stream_ctx {
+        /* 64-bit stream ring address, cycle state, and stream type */
+        u64     stream_ring;
+        /* offset 0x14 - 0x1f reserved for HC internal use */
+        u32     reserved[2];
+};
+
+/* Stream Context Types (section 6.4.1) - bits 3:1 of stream ctx deq ptr */
+#define SCT_FOR_CTX(p)          (((p) << 1) & 0x7)
+/* Secondary stream array type, dequeue pointer is to a transfer ring */
+#define SCT_SEC_TR              0
+/* Primary stream array type, dequeue pointer is to a transfer ring */
+#define SCT_PRI_TR              1
+/* Dequeue pointer is for a secondary stream array (SSA) with 8 entries */
+#define SCT_SSA_8               2
+#define SCT_SSA_16              3
+#define SCT_SSA_32              4
+#define SCT_SSA_64              5
+#define SCT_SSA_128             6
+#define SCT_SSA_256             7
+
+/* Assume no secondary streams for now */
+struct xhci_stream_info {
+        struct xhci_ring                **stream_rings;
+        /* Number of streams, including stream 0 (which drivers can't use) */
+        unsigned int                    num_streams;
+        /* The stream context array may be bigger than
+         * the number of streams the driver asked for
+         */
+        struct xhci_stream_ctx          *stream_ctx_array;
+        unsigned int                    num_stream_ctxs;
+        dma_addr_t                      ctx_array_dma;
+        /* For mapping physical TRB addresses to segments in stream rings */
+        struct radix_tree_root          trb_address_map;
+        struct xhci_command             *free_streams_command;
+};
+
+#define SMALL_STREAM_ARRAY_SIZE         256
+#define MEDIUM_STREAM_ARRAY_SIZE        1024
+
 struct xhci_virt_ep {
         struct xhci_ring                *ring;
+        /* Related to endpoints that are configured to use stream IDs only */
+        struct xhci_stream_info         *stream_info;
         /* Temporary storage in case the configure endpoint command fails and we
          * have to restore the device state to the previous state
          */
@@ -658,11 +705,17 @@ struct xhci_virt_ep {
 #define SET_DEQ_PENDING         (1 << 0)
 #define EP_HALTED               (1 << 1)        /* For stall handling */
 #define EP_HALT_PENDING         (1 << 2)        /* For URB cancellation */
+/* Transitioning the endpoint to using streams, don't enqueue URBs */
+#define EP_GETTING_STREAMS      (1 << 3)
+#define EP_HAS_STREAMS          (1 << 4)
+/* Transitioning the endpoint to not using streams, don't enqueue URBs */
+#define EP_GETTING_NO_STREAMS   (1 << 5)
         /* ----  Related to URB cancellation ---- */
         struct list_head        cancelled_td_list;
         /* The TRB that was last reported in a stopped endpoint ring */
         union xhci_trb          *stopped_trb;
         struct xhci_td          *stopped_td;
+        unsigned int            stopped_stream;
         /* Watchdog timer for stop endpoint command to cancel URBs */
         struct timer_list       stop_cmd_timer;
         int                     stop_cmds_pending;
@@ -710,14 +763,6 @@ struct xhci_device_context_array {
  */
 
 
-struct xhci_stream_ctx {
-        /* 64-bit stream ring address, cycle state, and stream type */
-        u64     stream_ring;
-        /* offset 0x14 - 0x1f reserved for HC internal use */
-        u32     reserved[2];
-};
-
-
 struct xhci_transfer_event {
         /* 64-bit buffer address, or immediate data */
         u64     buffer;
@@ -828,6 +873,10 @@ struct xhci_event_cmd {
 #define TRB_TO_EP_INDEX(p)              ((((p) & (0x1f << 16)) >> 16) - 1)
 #define EP_ID_FOR_TRB(p)                ((((p) + 1) & 0x1f) << 16)
 
+/* Set TR Dequeue Pointer command TRB fields */
+#define TRB_TO_STREAM_ID(p)             ((((p) & (0xffff << 16)) >> 16))
+#define STREAM_ID_FOR_TRB(p)            ((((p)) & 0xffff) << 16)
+
 
 /* Port Status Change Event TRB fields */
 /* Port ID - bits 31:24 */
@@ -952,6 +1001,10 @@ union xhci_trb {
 /* Allow two commands + a link TRB, along with any reserved command TRBs */
 #define MAX_RSVD_CMD_TRBS       (TRBS_PER_SEGMENT - 3)
 #define SEGMENT_SIZE            (TRBS_PER_SEGMENT*16)
+/* SEGMENT_SHIFT should be log2(SEGMENT_SIZE).
+ * Change this if you change TRBS_PER_SEGMENT!
+ */
+#define SEGMENT_SHIFT           10
 /* TRB buffer pointers can't cross 64KB boundaries */
 #define TRB_MAX_BUFF_SHIFT              16
 #define TRB_MAX_BUFF_SIZE       (1 << TRB_MAX_BUFF_SHIFT)
@@ -993,6 +1046,7 @@ struct xhci_ring {
          * if we own the TRB (if we are the consumer).  See section 4.9.1.
          */
         u32                     cycle_state;
+        unsigned int            stream_id;
 };
 
 struct xhci_erst_entry {
@@ -1088,6 +1142,8 @@ struct xhci_hcd {
         /* DMA pools */
         struct dma_pool *device_pool;
         struct dma_pool *segment_pool;
+        struct dma_pool *small_streams_pool;
+        struct dma_pool *medium_streams_pool;
 
 #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
         /* Poll the rings - for debugging */
@@ -1216,6 +1272,9 @@ void xhci_dbg_ring_ptrs(struct xhci_hcd *xhci, struct xhci_ring *ring);
 void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int last_ep);
 char *xhci_get_slot_state(struct xhci_hcd *xhci,
                 struct xhci_container_ctx *ctx);
+void xhci_dbg_ep_rings(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_virt_ep *ep);
 
 /* xHCI memory management */
 void xhci_mem_cleanup(struct xhci_hcd *xhci);
@@ -1242,6 +1301,29 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring);
 void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
                 struct xhci_virt_device *virt_dev,
                 unsigned int ep_index);
+struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
+                unsigned int num_stream_ctxs,
+                unsigned int num_streams, gfp_t flags);
+void xhci_free_stream_info(struct xhci_hcd *xhci,
+                struct xhci_stream_info *stream_info);
+void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
+                struct xhci_ep_ctx *ep_ctx,
+                struct xhci_stream_info *stream_info);
+void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
+                struct xhci_ep_ctx *ep_ctx,
+                struct xhci_virt_ep *ep);
+struct xhci_ring *xhci_dma_to_transfer_ring(
+                struct xhci_virt_ep *ep,
+                u64 address);
+struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
+                struct urb *urb);
+struct xhci_ring *xhci_triad_to_transfer_ring(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id);
+struct xhci_ring *xhci_stream_id_to_ring(
+                struct xhci_virt_device *dev,
+                unsigned int ep_index,
+                unsigned int stream_id);
 struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
                 bool allocate_in_ctx, bool allocate_completion,
                 gfp_t mem_flags);
@@ -1266,6 +1348,12 @@ int xhci_get_frame(struct usb_hcd *hcd);
 irqreturn_t xhci_irq(struct usb_hcd *hcd);
 int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev);
 void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev);
+int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int num_streams, gfp_t mem_flags);
+int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                gfp_t mem_flags);
 int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                         struct usb_tt *tt, gfp_t mem_flags);
@@ -1308,9 +1396,11 @@ int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
 int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id);
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
-                struct xhci_td *cur_td, struct xhci_dequeue_state *state);
+                unsigned int stream_id, struct xhci_td *cur_td,
+                struct xhci_dequeue_state *state);
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id,
                 struct xhci_dequeue_state *deq_state);
 void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
                 struct usb_device *udev, unsigned int ep_index);