75 files changed, 3690 insertions, 934 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index ab085f12d570..060e0e2b1ae6 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -19,7 +19,7 @@ config USB_C67X00_HCD
 
 config USB_XHCI_HCD
         tristate "xHCI HCD (USB 3.0) support (EXPERIMENTAL)"
-        depends on USB && PCI && EXPERIMENTAL
+        depends on USB && USB_ARCH_HAS_XHCI && EXPERIMENTAL
         ---help---
           The eXtensible Host Controller Interface (xHCI) is standard for USB 3.0
           "SuperSpeed" host controller hardware.
@@ -515,6 +515,19 @@ config USB_R8A66597_HCD
           To compile this driver as a module, choose M here: the
           module will be called r8a66597-hcd.
 
+config USB_RENESAS_USBHS_HCD
+        tristate "Renesas USBHS HCD support"
+        depends on USB
+        depends on USB_RENESAS_USBHS
+        help
+          The Renesas USBHS is a USB 2.0 host and peripheral controller.
+
+          Enable this option if your board has this chip, and you want
+          to use it as a host controller.  If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called renesas-usbhs.
+
 config USB_WHCI_HCD
         tristate "Wireless USB Host Controller Interface (WHCI) driver (EXPERIMENTAL)"
         depends on EXPERIMENTAL
@@ -544,11 +557,11 @@ config USB_HWA_HCD
           will be called "hwa-hc".
 
 config USB_IMX21_HCD
-       tristate "iMX21 HCD support"
-       depends on USB && ARM && MACH_MX21
+       tristate "i.MX21 HCD support"
+       depends on USB && ARM && ARCH_MXC
        help
          This driver enables support for the on-chip USB host in the
-         iMX21 processor.
+         i.MX21 processor.
 
          To compile this driver as a module, choose M here: the
          module will be called "imx21-hcd".
@@ -578,3 +591,10 @@ config USB_OCTEON_OHCI
 config USB_OCTEON2_COMMON
         bool
         default y if USB_OCTEON_EHCI || USB_OCTEON_OHCI
+
+config USB_PXA168_EHCI
+        bool "Marvell PXA168 on-chip EHCI HCD support"
+        depends on USB_EHCI_HCD && ARCH_MMP
+        help
+          Enable support for Marvell PXA168 SoC's on-chip EHCI
+          host controller
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 624a362f2fee..7ca290fcb070 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -11,8 +11,9 @@ fhci-y += fhci-mem.o fhci-tds.o fhci-sched.o
 
 fhci-$(CONFIG_FHCI_DEBUG) += fhci-dbg.o
 
-xhci-hcd-y := xhci.o xhci-mem.o xhci-pci.o
+xhci-hcd-y := xhci.o xhci-mem.o
 xhci-hcd-y += xhci-ring.o xhci-hub.o xhci-dbg.o
+xhci-hcd-$(CONFIG_PCI)  += xhci-pci.o
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
 
@@ -35,3 +36,4 @@ obj-$(CONFIG_USB_HWA_HCD)	+= hwa-hc.o
 obj-$(CONFIG_USB_IMX21_HCD)     += imx21-hcd.o
 obj-$(CONFIG_USB_FSL_MPH_DR_OF) += fsl-mph-dr-of.o
 obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
+obj-$(CONFIG_MIPS_ALCHEMY)      += alchemy-common.o
diff --git a/drivers/usb/host/alchemy-common.c b/drivers/usb/host/alchemy-common.c
new file mode 100644
index 000000000000..b4192c964d0d
--- /dev/null
+++ b/drivers/usb/host/alchemy-common.c
@@ -0,0 +1,337 @@
+/*
+ * USB block power/access management abstraction.
+ *
+ * Au1000+: The OHCI block control register is at the far end of the OHCI memory
+ *          area. Au1550 has OHCI on different base address. No need to handle
+ *          UDC here.
+ * Au1200:  one register to control access and clocks to O/EHCI, UDC and OTG
+ *          as well as the PHY for EHCI and UDC.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/syscore_ops.h>
+#include <asm/mach-au1x00/au1000.h>
+
+/* control register offsets */
+#define AU1000_OHCICFG  0x7fffc
+#define AU1550_OHCICFG  0x07ffc
+#define AU1200_USBCFG   0x04
+
+/* Au1000 USB block config bits */
+#define USBHEN_RD       (1 << 4)                /* OHCI reset-done indicator */
+#define USBHEN_CE       (1 << 3)                /* OHCI block clock enable */
+#define USBHEN_E        (1 << 2)                /* OHCI block enable */
+#define USBHEN_C        (1 << 1)                /* OHCI block coherency bit */
+#define USBHEN_BE       (1 << 0)                /* OHCI Big-Endian */
+
+/* Au1200 USB config bits */
+#define USBCFG_PFEN     (1 << 31)               /* prefetch enable (undoc) */
+#define USBCFG_RDCOMB   (1 << 30)               /* read combining (undoc) */
+#define USBCFG_UNKNOWN  (5 << 20)               /* unknown, leave this way */
+#define USBCFG_SSD      (1 << 23)               /* serial short detect en */
+#define USBCFG_PPE      (1 << 19)               /* HS PHY PLL */
+#define USBCFG_UCE      (1 << 18)               /* UDC clock enable */
+#define USBCFG_ECE      (1 << 17)               /* EHCI clock enable */
+#define USBCFG_OCE      (1 << 16)               /* OHCI clock enable */
+#define USBCFG_FLA(x)   (((x) & 0x3f) << 8)
+#define USBCFG_UCAM     (1 << 7)                /* coherent access (undoc) */
+#define USBCFG_GME      (1 << 6)                /* OTG mem access */
+#define USBCFG_DBE      (1 << 5)                /* UDC busmaster enable */
+#define USBCFG_DME      (1 << 4)                /* UDC mem enable */
+#define USBCFG_EBE      (1 << 3)                /* EHCI busmaster enable */
+#define USBCFG_EME      (1 << 2)                /* EHCI mem enable */
+#define USBCFG_OBE      (1 << 1)                /* OHCI busmaster enable */
+#define USBCFG_OME      (1 << 0)                /* OHCI mem enable */
+#define USBCFG_INIT_AU1200      (USBCFG_PFEN | USBCFG_RDCOMB | USBCFG_UNKNOWN |\
+                                 USBCFG_SSD | USBCFG_FLA(0x20) | USBCFG_UCAM | \
+                                 USBCFG_GME | USBCFG_DBE | USBCFG_DME |        \
+                                 USBCFG_EBE | USBCFG_EME | USBCFG_OBE |        \
+                                 USBCFG_OME)
+
+
+static DEFINE_SPINLOCK(alchemy_usb_lock);
+
+
+static inline void __au1200_ohci_control(void __iomem *base, int enable)
+{
+        unsigned long r = __raw_readl(base + AU1200_USBCFG);
+        if (enable) {
+                __raw_writel(r | USBCFG_OCE, base + AU1200_USBCFG);
+                wmb();
+                udelay(2000);
+        } else {
+                __raw_writel(r & ~USBCFG_OCE, base + AU1200_USBCFG);
+                wmb();
+                udelay(1000);
+        }
+}
+
+static inline void __au1200_ehci_control(void __iomem *base, int enable)
+{
+        unsigned long r = __raw_readl(base + AU1200_USBCFG);
+        if (enable) {
+                __raw_writel(r | USBCFG_ECE | USBCFG_PPE, base + AU1200_USBCFG);
+                wmb();
+                udelay(1000);
+        } else {
+                if (!(r & USBCFG_UCE))          /* UDC also off? */
+                        r &= ~USBCFG_PPE;       /* yes: disable HS PHY PLL */
+                __raw_writel(r & ~USBCFG_ECE, base + AU1200_USBCFG);
+                wmb();
+                udelay(1000);
+        }
+}
+
+static inline void __au1200_udc_control(void __iomem *base, int enable)
+{
+        unsigned long r = __raw_readl(base + AU1200_USBCFG);
+        if (enable) {
+                __raw_writel(r | USBCFG_UCE | USBCFG_PPE, base + AU1200_USBCFG);
+                wmb();
+        } else {
+                if (!(r & USBCFG_ECE))          /* EHCI also off? */
+                        r &= ~USBCFG_PPE;       /* yes: disable HS PHY PLL */
+                __raw_writel(r & ~USBCFG_UCE, base + AU1200_USBCFG);
+                wmb();
+        }
+}
+
+static inline int au1200_coherency_bug(void)
+{
+#if defined(CONFIG_DMA_COHERENT)
+        /* Au1200 AB USB does not support coherent memory */
+        if (!(read_c0_prid() & 0xff)) {
+                printk(KERN_INFO "Au1200 USB: this is chip revision AB !!\n");
+                printk(KERN_INFO "Au1200 USB: update your board or re-configure"
+                                 " the kernel\n");
+                return -ENODEV;
+        }
+#endif
+        return 0;
+}
+
+static inline int au1200_usb_control(int block, int enable)
+{
+        void __iomem *base =
+                        (void __iomem *)KSEG1ADDR(AU1200_USB_CTL_PHYS_ADDR);
+        int ret = 0;
+
+        switch (block) {
+        case ALCHEMY_USB_OHCI0:
+                ret = au1200_coherency_bug();
+                if (ret && enable)
+                        goto out;
+                __au1200_ohci_control(base, enable);
+                break;
+        case ALCHEMY_USB_UDC0:
+                __au1200_udc_control(base, enable);
+                break;
+        case ALCHEMY_USB_EHCI0:
+                ret = au1200_coherency_bug();
+                if (ret && enable)
+                        goto out;
+                __au1200_ehci_control(base, enable);
+                break;
+        default:
+                ret = -ENODEV;
+        }
+out:
+        return ret;
+}
+
+
+/* initialize USB block(s) to a known working state */
+static inline void au1200_usb_init(void)
+{
+        void __iomem *base =
+                        (void __iomem *)KSEG1ADDR(AU1200_USB_CTL_PHYS_ADDR);
+        __raw_writel(USBCFG_INIT_AU1200, base + AU1200_USBCFG);
+        wmb();
+        udelay(1000);
+}
+
+static inline void au1000_usb_init(unsigned long rb, int reg)
+{
+        void __iomem *base = (void __iomem *)KSEG1ADDR(rb + reg);
+        unsigned long r = __raw_readl(base);
+
+#if defined(__BIG_ENDIAN)
+        r |= USBHEN_BE;
+#endif
+        r |= USBHEN_C;
+
+        __raw_writel(r, base);
+        wmb();
+        udelay(1000);
+}
+
+
+static inline void __au1xx0_ohci_control(int enable, unsigned long rb, int creg)
+{
+        void __iomem *base = (void __iomem *)KSEG1ADDR(rb);
+        unsigned long r = __raw_readl(base + creg);
+
+        if (enable) {
+                __raw_writel(r | USBHEN_CE, base + creg);
+                wmb();
+                udelay(1000);
+                __raw_writel(r | USBHEN_CE | USBHEN_E, base + creg);
+                wmb();
+                udelay(1000);
+
+                /* wait for reset complete (read reg twice: au1500 erratum) */
+                while (__raw_readl(base + creg),
+                        !(__raw_readl(base + creg) & USBHEN_RD))
+                        udelay(1000);
+        } else {
+                __raw_writel(r & ~(USBHEN_CE | USBHEN_E), base + creg);
+                wmb();
+        }
+}
+
+static inline int au1000_usb_control(int block, int enable, unsigned long rb,
+                                     int creg)
+{
+        int ret = 0;
+
+        switch (block) {
+        case ALCHEMY_USB_OHCI0:
+                __au1xx0_ohci_control(enable, rb, creg);
+                break;
+        default:
+                ret = -ENODEV;
+        }
+        return ret;
+}
+
+/*
+ * alchemy_usb_control - control Alchemy on-chip USB blocks
+ * @block:      USB block to target
+ * @enable:     set 1 to enable a block, 0 to disable
+ */
+int alchemy_usb_control(int block, int enable)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&alchemy_usb_lock, flags);
+        switch (alchemy_get_cputype()) {
+        case ALCHEMY_CPU_AU1000:
+        case ALCHEMY_CPU_AU1500:
+        case ALCHEMY_CPU_AU1100:
+                ret = au1000_usb_control(block, enable,
+                                AU1000_USB_OHCI_PHYS_ADDR, AU1000_OHCICFG);
+                break;
+        case ALCHEMY_CPU_AU1550:
+                ret = au1000_usb_control(block, enable,
+                                AU1550_USB_OHCI_PHYS_ADDR, AU1550_OHCICFG);
+                break;
+        case ALCHEMY_CPU_AU1200:
+                ret = au1200_usb_control(block, enable);
+                break;
+        default:
+                ret = -ENODEV;
+        }
+        spin_unlock_irqrestore(&alchemy_usb_lock, flags);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(alchemy_usb_control);
+
+
+static unsigned long alchemy_usb_pmdata[2];
+
+static void au1000_usb_pm(unsigned long br, int creg, int susp)
+{
+        void __iomem *base = (void __iomem *)KSEG1ADDR(br);
+
+        if (susp) {
+                alchemy_usb_pmdata[0] = __raw_readl(base + creg);
+                /* There appears to be some undocumented reset register.... */
+                __raw_writel(0, base + 0x04);
+                wmb();
+                __raw_writel(0, base + creg);
+                wmb();
+        } else {
+                __raw_writel(alchemy_usb_pmdata[0], base + creg);
+                wmb();
+        }
+}
+
+static void au1200_usb_pm(int susp)
+{
+        void __iomem *base =
+                        (void __iomem *)KSEG1ADDR(AU1200_USB_OTG_PHYS_ADDR);
+        if (susp) {
+                /* save OTG_CAP/MUX registers which indicate port routing */
+                /* FIXME: write an OTG driver to do that */
+                alchemy_usb_pmdata[0] = __raw_readl(base + 0x00);
+                alchemy_usb_pmdata[1] = __raw_readl(base + 0x04);
+        } else {
+                /* restore access to all MMIO areas */
+                au1200_usb_init();
+
+                /* restore OTG_CAP/MUX registers */
+                __raw_writel(alchemy_usb_pmdata[0], base + 0x00);
+                __raw_writel(alchemy_usb_pmdata[1], base + 0x04);
+                wmb();
+        }
+}
+
+static void alchemy_usb_pm(int susp)
+{
+        switch (alchemy_get_cputype()) {
+        case ALCHEMY_CPU_AU1000:
+        case ALCHEMY_CPU_AU1500:
+        case ALCHEMY_CPU_AU1100:
+                au1000_usb_pm(AU1000_USB_OHCI_PHYS_ADDR, AU1000_OHCICFG, susp);
+                break;
+        case ALCHEMY_CPU_AU1550:
+                au1000_usb_pm(AU1550_USB_OHCI_PHYS_ADDR, AU1550_OHCICFG, susp);
+                break;
+        case ALCHEMY_CPU_AU1200:
+                au1200_usb_pm(susp);
+                break;
+        }
+}
+
+static int alchemy_usb_suspend(void)
+{
+        alchemy_usb_pm(1);
+        return 0;
+}
+
+static void alchemy_usb_resume(void)
+{
+        alchemy_usb_pm(0);
+}
+
+static struct syscore_ops alchemy_usb_pm_ops = {
+        .suspend        = alchemy_usb_suspend,
+        .resume         = alchemy_usb_resume,
+};
+
+static int __init alchemy_usb_init(void)
+{
+        switch (alchemy_get_cputype()) {
+        case ALCHEMY_CPU_AU1000:
+        case ALCHEMY_CPU_AU1500:
+        case ALCHEMY_CPU_AU1100:
+                au1000_usb_init(AU1000_USB_OHCI_PHYS_ADDR, AU1000_OHCICFG);
+                break;
+        case ALCHEMY_CPU_AU1550:
+                au1000_usb_init(AU1550_USB_OHCI_PHYS_ADDR, AU1550_OHCICFG);
+                break;
+        case ALCHEMY_CPU_AU1200:
+                au1200_usb_init();
+                break;
+        }
+
+        register_syscore_ops(&alchemy_usb_pm_ops);
+
+        return 0;
+}
+arch_initcall(alchemy_usb_init);
diff --git a/drivers/usb/host/ehci-ath79.c b/drivers/usb/host/ehci-ath79.c
index 4d2e88d04dab..afb6743cf094 100644
--- a/drivers/usb/host/ehci-ath79.c
+++ b/drivers/usb/host/ehci-ath79.c
@@ -163,7 +163,7 @@ static int ehci_ath79_probe(struct platform_device *pdev)
                 goto err_release_region;
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
                 goto err_iounmap;
 
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 42ae57409908..18bafa99fe57 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -14,61 +14,9 @@
 #include <linux/platform_device.h>
 #include <asm/mach-au1x00/au1000.h>
 
-#define USB_HOST_CONFIG   (USB_MSR_BASE + USB_MSR_MCFG)
-#define USB_MCFG_PFEN     (1<<31)
-#define USB_MCFG_RDCOMB   (1<<30)
-#define USB_MCFG_SSDEN    (1<<23)
-#define USB_MCFG_PHYPLLEN (1<<19)
-#define USB_MCFG_UCECLKEN (1<<18)
-#define USB_MCFG_EHCCLKEN (1<<17)
-#ifdef CONFIG_DMA_COHERENT
-#define USB_MCFG_UCAM     (1<<7)
-#else
-#define USB_MCFG_UCAM     (0)
-#endif
-#define USB_MCFG_EBMEN    (1<<3)
-#define USB_MCFG_EMEMEN   (1<<2)
-
-#define USBH_ENABLE_CE  (USB_MCFG_PHYPLLEN | USB_MCFG_EHCCLKEN)
-#define USBH_ENABLE_INIT (USB_MCFG_PFEN  | USB_MCFG_RDCOMB |    \
-                          USBH_ENABLE_CE | USB_MCFG_SSDEN  |    \
-                          USB_MCFG_UCAM  | USB_MCFG_EBMEN  |    \
-                          USB_MCFG_EMEMEN)
-
-#define USBH_DISABLE      (USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
 
 extern int usb_disabled(void);
 
-static void au1xxx_start_ehc(void)
-{
-        /* enable clock to EHCI block and HS PHY PLL*/
-        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_CE, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-
-        /* enable EHCI mmio */
-        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-}
-
-static void au1xxx_stop_ehc(void)
-{
-        unsigned long c;
-
-        /* Disable mem */
-        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_DISABLE, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-
-        /* Disable EHC clock. If the HS PHY is unused disable it too. */
-        c = au_readl(USB_HOST_CONFIG) & ~USB_MCFG_EHCCLKEN;
-        if (!(c & USB_MCFG_UCECLKEN))           /* UDC disabled? */
-                c &= ~USB_MCFG_PHYPLLEN;        /* yes: disable HS PHY PLL */
-        au_writel(c, USB_HOST_CONFIG);
-        au_sync();
-}
-
 static int au1xxx_ehci_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
@@ -136,16 +84,6 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         if (usb_disabled())
                 return -ENODEV;
 
-#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
-        /* Au1200 AB USB does not support coherent memory */
-        if (!(read_c0_prid() & 0xff)) {
-                printk(KERN_INFO "%s: this is chip revision AB!\n", pdev->name);
-                printk(KERN_INFO "%s: update your board or re-configure"
-                                 " the kernel\n", pdev->name);
-                return -ENODEV;
-        }
-#endif
-
         if (pdev->resource[1].flags != IORESOURCE_IRQ) {
                 pr_debug("resource[1] is not IORESOURCE_IRQ");
                 return -ENOMEM;
@@ -171,7 +109,11 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        au1xxx_start_ehc();
+        if (alchemy_usb_control(ALCHEMY_USB_EHCI0, 1)) {
+                printk(KERN_INFO "%s: controller init failed!\n", pdev->name);
+                ret = -ENODEV;
+                goto err3;
+        }
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
@@ -181,13 +123,14 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
         ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                          IRQF_DISABLED | IRQF_SHARED);
+                          IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
                 return ret;
         }
 
-        au1xxx_stop_ehc();
+        alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
+err3:
         iounmap(hcd->regs);
 err2:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
@@ -201,10 +144,10 @@ static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
+        alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
-        au1xxx_stop_ehc();
         platform_set_drvdata(pdev, NULL);
 
         return 0;
@@ -236,7 +179,7 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
         // could save FLADJ in case of Vaux power loss
         // ... we'd only use it to handle clock skew
 
-        au1xxx_stop_ehc();
+        alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
 
         return rc;
 }
@@ -246,7 +189,7 @@ static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
-        au1xxx_start_ehc();
+        alchemy_usb_control(ALCHEMY_USB_EHCI0, 1);
 
         // maybe restore FLADJ
 
@@ -293,7 +236,7 @@ static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
         /* here we "know" root ports should always stay powered */
         ehci_port_power(ehci, 1);
 
-        hcd->state = HC_STATE_SUSPENDED;
+        ehci->rh_state = EHCI_RH_SUSPENDED;
 
         return 0;
 }
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 40a844c1dbb4..d6d74d2e09f4 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -697,6 +697,19 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
 }
 #undef DBG_SCHED_LIMIT
 
+static const char *rh_state_string(struct ehci_hcd *ehci)
+{
+        switch (ehci->rh_state) {
+        case EHCI_RH_HALTED:
+                return "halted";
+        case EHCI_RH_SUSPENDED:
+                return "suspended";
+        case EHCI_RH_RUNNING:
+                return "running";
+        }
+        return "?";
+}
+
 static ssize_t fill_registers_buffer(struct debug_buffer *buf)
 {
         struct usb_hcd          *hcd;
@@ -730,11 +743,11 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         temp = scnprintf (next, size,
                 "bus %s, device %s\n"
                 "%s\n"
-                "EHCI %x.%02x, hcd state %d\n",
+                "EHCI %x.%02x, rh state %s\n",
                 hcd->self.controller->bus->name,
                 dev_name(hcd->self.controller),
                 hcd->product_desc,
-                i >> 8, i & 0x0ff, hcd->state);
+                i >> 8, i & 0x0ff, rh_state_string(ehci));
         size -= temp;
         next += temp;
 
@@ -808,7 +821,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         next += temp;
 
         temp = scnprintf (next, size, "uframe %04x\n",
-                        ehci_readl(ehci, &ehci->regs->frame_index));
+                        ehci_read_frame_index(ehci));
         size -= temp;
         next += temp;
 
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 34a3140d1e5f..e90344a17631 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -134,7 +134,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
 
         /* Don't need to set host mode here. It will be done by tdi_reset() */
 
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval != 0)
                 goto err4;
 
@@ -392,7 +392,7 @@ static int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
 
         dev_dbg(dev, "suspending...\n");
 
-        hcd->state = HC_STATE_SUSPENDED;
+        ehci->rh_state = EHCI_RH_SUSPENDED;
         dev->power.power_state = PMSG_SUSPEND;
 
         /* ignore non-host interrupts */
@@ -481,7 +481,7 @@ static int ehci_fsl_mpc512x_drv_resume(struct device *dev)
         ehci_writel(ehci, pdata->pm_portsc, &ehci->regs->port_status[0]);
 
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        hcd->state = HC_STATE_RUNNING;
+        ehci->rh_state = EHCI_RH_RUNNING;
         dev->power.power_state = PMSG_ON;
 
         tmp = ehci_readl(ehci, &ehci->regs->command);
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index f72ae0b6ee7f..3ff9f82f7263 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -95,7 +95,7 @@ static const char	hcd_name [] = "ehci_hcd";
 #define EHCI_IO_JIFFIES         (HZ/10)         /* io watchdog > irq_thresh */
 #define EHCI_ASYNC_JIFFIES      (HZ/20)         /* async idle timeout */
 #define EHCI_SHRINK_JIFFIES     (DIV_ROUND_UP(HZ, 200) + 1)
-                                                /* 200-ms async qh unlink delay */
+                                                /* 5-ms async qh unlink delay */
 
 /* Initial IRQ latency:  faster than hw default */
 static int log2_irq_thresh = 0;         // 0 to 6
@@ -238,7 +238,7 @@ static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
         error = handshake(ehci, ptr, mask, done, usec);
         if (error) {
                 ehci_halt(ehci);
-                ehci_to_hcd(ehci)->state = HC_STATE_HALT;
+                ehci->rh_state = EHCI_RH_HALTED;
                 ehci_err(ehci, "force halt; handshake %p %08x %08x -> %d\n",
                         ptr, mask, done, error);
         }
@@ -278,7 +278,7 @@ static int ehci_reset (struct ehci_hcd *ehci)
         command |= CMD_RESET;
         dbg_cmd (ehci, "reset", command);
         ehci_writel(ehci, command, &ehci->regs->command);
-        ehci_to_hcd(ehci)->state = HC_STATE_HALT;
+        ehci->rh_state = EHCI_RH_HALTED;
         ehci->next_statechange = jiffies;
         retval = handshake (ehci, &ehci->regs->command,
                             CMD_RESET, 0, 250 * 1000);
@@ -307,7 +307,7 @@ static void ehci_quiesce (struct ehci_hcd *ehci)
         u32     temp;
 
 #ifdef DEBUG
-        if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
+        if (ehci->rh_state != EHCI_RH_RUNNING)
                 BUG ();
 #endif
 
@@ -356,7 +356,7 @@ static void ehci_iaa_watchdog(unsigned long param)
          */
         if (ehci->reclaim
                         && !timer_pending(&ehci->iaa_watchdog)
-                        && HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
+                        && ehci->rh_state == EHCI_RH_RUNNING) {
                 u32 cmd, status;
 
                 /* If we get here, IAA is *REALLY* late.  It's barely
@@ -496,7 +496,7 @@ static void ehci_work (struct ehci_hcd *ehci)
          * misplace IRQs, and should let us run completely without IRQs.
          * such lossage has been observed on both VT6202 and VT8235.
          */
-        if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
+        if (ehci->rh_state == EHCI_RH_RUNNING &&
                         (ehci->async->qh_next.ptr != NULL ||
                          ehci->periodic_sched != 0))
                 timer_action (ehci, TIMER_IO_WATCHDOG);
@@ -516,7 +516,7 @@ static void ehci_stop (struct usb_hcd *hcd)
         del_timer_sync(&ehci->iaa_watchdog);
 
         spin_lock_irq(&ehci->lock);
-        if (HC_IS_RUNNING (hcd->state))
+        if (ehci->rh_state == EHCI_RH_RUNNING)
                 ehci_quiesce (ehci);
 
         ehci_silence_controller(ehci);
@@ -741,7 +741,7 @@ static int ehci_run (struct usb_hcd *hcd)
          * be started before the port switching actions could complete.
          */
         down_write(&ehci_cf_port_reset_rwsem);
-        hcd->state = HC_STATE_RUNNING;
+        ehci->rh_state = EHCI_RH_RUNNING;
         ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
         ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
         msleep(5);
@@ -768,6 +768,35 @@ static int ehci_run (struct usb_hcd *hcd)
         return 0;
 }
 
+static int __maybe_unused ehci_setup (struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        ehci->regs = (void __iomem *)ehci->caps +
+            HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        ehci->sbrn = HCD_USB2;
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci_reset(ehci);
+
+        return 0;
+}
+
 /*-------------------------------------------------------------------------*/
 
 static irqreturn_t ehci_irq (struct usb_hcd *hcd)
@@ -788,7 +817,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
 
         /* Shared IRQ? */
         masked_status = status & INTR_MASK;
-        if (!masked_status || unlikely(hcd->state == HC_STATE_HALT)) {
+        if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
                 spin_unlock(&ehci->lock);
                 return IRQ_NONE;
         }
@@ -952,7 +981,7 @@ static int ehci_urb_enqueue (
 static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
         /* failfast */
-        if (!HC_IS_RUNNING(ehci_to_hcd(ehci)->state) && ehci->reclaim)
+        if (ehci->rh_state != EHCI_RH_RUNNING && ehci->reclaim)
                 end_unlink_async(ehci);
 
         /* If the QH isn't linked then there's nothing we can do
@@ -1079,7 +1108,7 @@ rescan:
                 goto idle_timeout;
         }
 
-        if (!HC_IS_RUNNING (hcd->state))
+        if (ehci->rh_state != EHCI_RH_RUNNING)
                 qh->qh_state = QH_STATE_IDLE;
         switch (qh->qh_state) {
         case QH_STATE_LINKED:
@@ -1166,8 +1195,7 @@ ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
 static int ehci_get_frame (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
-                ehci->periodic_size;
+        return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1196,7 +1224,7 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_hcd_sh_driver
 #endif
 
-#ifdef CONFIG_SOC_AU1200
+#ifdef CONFIG_MIPS_ALCHEMY
 #include "ehci-au1xxx.c"
 #define PLATFORM_DRIVER         ehci_hcd_au1xxx_driver
 #endif
@@ -1291,6 +1319,16 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_grlib_driver
 #endif
 
+#ifdef CONFIG_USB_PXA168_EHCI
+#include "ehci-pxa168.c"
+#define PLATFORM_DRIVER         ehci_pxa168_driver
+#endif
+
+#ifdef CONFIG_NLM_XLR
+#include "ehci-xls.c"
+#define PLATFORM_DRIVER         ehci_xls_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 4c32cb19b405..77bbb2357e47 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -236,10 +236,8 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
         }
 
         /* stop schedules, clean any completed work */
-        if (HC_IS_RUNNING(hcd->state)) {
+        if (ehci->rh_state == EHCI_RH_RUNNING)
                 ehci_quiesce (ehci);
-                hcd->state = HC_STATE_QUIESCING;
-        }
         ehci->command = ehci_readl(ehci, &ehci->regs->command);
         ehci_work(ehci);
 
@@ -313,7 +311,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 
         /* turn off now-idle HC */
         ehci_halt (ehci);
-        hcd->state = HC_STATE_SUSPENDED;
+        ehci->rh_state = EHCI_RH_SUSPENDED;
 
         if (ehci->reclaim)
                 end_unlink_async(ehci);
@@ -382,6 +380,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 
         /* restore CMD_RUN, framelist size, and irq threshold */
         ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        ehci->rh_state = EHCI_RH_RUNNING;
 
         /* Some controller/firmware combinations need a delay during which
          * they set up the port statuses.  See Bugzilla #8190. */
@@ -451,7 +450,6 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         }
 
         ehci->next_statechange = jiffies + msecs_to_jiffies(5);
-        hcd->state = HC_STATE_RUNNING;
 
         /* Now we can safely re-enable irqs */
         ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
@@ -563,7 +561,7 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
         u32             ppcd = 0;
 
         /* if !USB_SUSPEND, root hub timers won't get shut down ... */
-        if (!HC_IS_RUNNING(hcd->state))
+        if (ehci->rh_state != EHCI_RH_RUNNING)
                 return 0;
 
         /* init status to no-changes */
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 555a73c864b5..55978fcfa4b2 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -236,7 +236,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         priv->hcd = hcd;
         platform_set_drvdata(pdev, priv);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
                 goto err_add;
 
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index c3ba3ed5f3a6..ba1f51361134 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -155,7 +155,7 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret) {
                 dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
                 goto err3;
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 45240321ca09..e39b0297bad1 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -228,7 +228,7 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret) {
                 dev_err(dev, "failed to add hcd with err %d\n", ret);
                 goto err_add_hcd;
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 395bdb0248d5..a68a2a5c4b83 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -277,7 +277,7 @@ static int __devinit ehci_orion_drv_probe(struct platform_device *pdev)
                 printk(KERN_WARNING "Orion ehci -USB phy version isn't supported.\n");
         }
 
-        err = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
                 goto err4;
 
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 1102ce65a3a9..f4b627d343ac 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -224,6 +224,11 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                         pci_dev_put(p_smbus);
                 }
                 break;
+        case PCI_VENDOR_ID_NETMOS:
+                /* MosChip frame-index-register bug */
+                ehci_info(ehci, "applying MosChip frame-index workaround\n");
+                ehci->frame_index_bug = 1;
+                break;
         }
 
         /* optional debug port, normally in the first BAR */
@@ -439,7 +444,7 @@ static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated)
         /* here we "know" root ports should always stay powered */
         ehci_port_power(ehci, 1);
 
-        hcd->state = HC_STATE_SUSPENDED;
+        ehci->rh_state = EHCI_RH_SUSPENDED;
         return 0;
 }
 #endif
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 64626a777d61..2dc32da75cfc 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -167,7 +167,7 @@ static int __devinit ps3_ehci_probe(struct ps3_system_bus_device *dev)
 
         ps3_system_bus_set_drvdata(dev, hcd);
 
-        result = usb_add_hcd(hcd, virq, IRQF_DISABLED);
+        result = usb_add_hcd(hcd, virq, 0);
 
         if (result) {
                 dev_dbg(&dev->core, "%s:%d: usb_add_hcd failed (%d)\n",
diff --git a/drivers/usb/host/ehci-pxa168.c b/drivers/usb/host/ehci-pxa168.c
new file mode 100644
index 000000000000..ac0c16e8f539
--- /dev/null
+++ b/drivers/usb/host/ehci-pxa168.c
@@ -0,0 +1,363 @@
+/*
+ * drivers/usb/host/ehci-pxa168.c
+ *
+ * Tanmay Upadhyay <tanmay.upadhyay@einfochips.com>
+ *
+ * Based on drivers/usb/host/ehci-orion.c
+ *
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <mach/pxa168.h>
+
+#define USB_PHY_CTRL_REG 0x4
+#define USB_PHY_PLL_REG  0x8
+#define USB_PHY_TX_REG   0xc
+
+#define FBDIV_SHIFT      4
+
+#define ICP_SHIFT        12
+#define ICP_15            2
+#define ICP_20            3
+#define ICP_25            4
+
+#define KVCO_SHIFT       15
+
+#define PLLCALI12_SHIFT  25
+#define CALI12_VDD        0
+#define CALI12_09         1
+#define CALI12_10         2
+#define CALI12_11         3
+
+#define PLLVDD12_SHIFT   27
+#define VDD12_VDD         0
+#define VDD12_10          1
+#define VDD12_11          2
+#define VDD12_12          3
+
+#define PLLVDD18_SHIFT   29
+#define VDD18_19          0
+#define VDD18_20          1
+#define VDD18_21          2
+#define VDD18_22          3
+
+
+#define PLL_READY        (1 << 23)
+#define VCOCAL_START     (1 << 21)
+#define REG_RCAL_START   (1 << 12)
+
+struct pxa168_usb_drv_data {
+        struct ehci_hcd ehci;
+        struct clk      *pxa168_usb_clk;
+        struct resource *usb_phy_res;
+        void __iomem    *usb_phy_reg_base;
+};
+
+static int ehci_pxa168_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        ehci_reset(ehci);
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /*
+         * data structure init
+         */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        hcd->has_tt = 1;
+
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+static const struct hc_driver ehci_pxa168_hc_driver = {
+        .description = hcd_name,
+        .product_desc = "Marvell PXA168 EHCI",
+        .hcd_priv_size = sizeof(struct pxa168_usb_drv_data),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq = ehci_irq,
+        .flags = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset = ehci_pxa168_setup,
+        .start = ehci_run,
+        .stop = ehci_stop,
+        .shutdown = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue = ehci_urb_enqueue,
+        .urb_dequeue = ehci_urb_dequeue,
+        .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data = ehci_hub_status_data,
+        .hub_control = ehci_hub_control,
+        .bus_suspend = ehci_bus_suspend,
+        .bus_resume = ehci_bus_resume,
+        .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+static int pxa168_usb_phy_init(struct platform_device *pdev)
+{
+        struct resource *res;
+        void __iomem *usb_phy_reg_base;
+        struct pxa168_usb_pdata *pdata;
+        struct pxa168_usb_drv_data *drv_data;
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        unsigned long reg_val;
+        int pll_retry_cont = 10000, err = 0;
+
+        drv_data = (struct pxa168_usb_drv_data *)hcd->hcd_priv;
+        pdata = (struct pxa168_usb_pdata *)pdev->dev.platform_data;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Found HC with no PHY register addr. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                return -ENODEV;
+        }
+
+        if (!request_mem_region(res->start, resource_size(res),
+                                ehci_pxa168_hc_driver.description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                return -EBUSY;
+        }
+
+        usb_phy_reg_base = ioremap(res->start, resource_size(res));
+        if (usb_phy_reg_base == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                err = -EFAULT;
+                goto err1;
+        }
+        drv_data->usb_phy_reg_base = usb_phy_reg_base;
+        drv_data->usb_phy_res = res;
+
+        /* If someone wants to init USB phy in board specific way */
+        if (pdata && pdata->phy_init)
+                return pdata->phy_init(usb_phy_reg_base);
+
+        /* Power up the PHY and PLL */
+        writel(readl(usb_phy_reg_base + USB_PHY_CTRL_REG) | 0x3,
+                usb_phy_reg_base + USB_PHY_CTRL_REG);
+
+        /* Configure PHY PLL */
+        reg_val = readl(usb_phy_reg_base + USB_PHY_PLL_REG) & ~(0x7e03ffff);
+        reg_val |= (VDD18_22 << PLLVDD18_SHIFT | VDD12_12 << PLLVDD12_SHIFT |
+                CALI12_11 << PLLCALI12_SHIFT | 3 << KVCO_SHIFT |
+                ICP_15 << ICP_SHIFT | 0xee << FBDIV_SHIFT | 0xb);
+        writel(reg_val, usb_phy_reg_base + USB_PHY_PLL_REG);
+
+        /* Make sure PHY PLL is ready */
+        while (!(readl(usb_phy_reg_base + USB_PHY_PLL_REG) & PLL_READY)) {
+                if (!(pll_retry_cont--)) {
+                        dev_dbg(&pdev->dev, "USB PHY PLL not ready\n");
+                        err = -EIO;
+                        goto err2;
+                }
+        }
+
+        /* Toggle VCOCAL_START bit of U2PLL for PLL calibration */
+        udelay(200);
+        writel(readl(usb_phy_reg_base + USB_PHY_PLL_REG) | VCOCAL_START,
+                usb_phy_reg_base + USB_PHY_PLL_REG);
+        udelay(40);
+        writel(readl(usb_phy_reg_base + USB_PHY_PLL_REG) & ~VCOCAL_START,
+                usb_phy_reg_base + USB_PHY_PLL_REG);
+
+        /* Toggle REG_RCAL_START bit of U2PTX for impedance calibration */
+        udelay(400);
+        writel(readl(usb_phy_reg_base + USB_PHY_TX_REG) | REG_RCAL_START,
+                usb_phy_reg_base + USB_PHY_TX_REG);
+        udelay(40);
+        writel(readl(usb_phy_reg_base + USB_PHY_TX_REG) & ~REG_RCAL_START,
+                usb_phy_reg_base + USB_PHY_TX_REG);
+
+        /* Make sure PHY PLL is ready again */
+        pll_retry_cont = 0;
+        while (!(readl(usb_phy_reg_base + USB_PHY_PLL_REG) & PLL_READY)) {
+                if (!(pll_retry_cont--)) {
+                        dev_dbg(&pdev->dev, "USB PHY PLL not ready\n");
+                        err = -EIO;
+                        goto err2;
+                }
+        }
+
+        return 0;
+err2:
+        iounmap(usb_phy_reg_base);
+err1:
+        release_mem_region(res->start, resource_size(res));
+        return err;
+}
+
+static int __devinit ehci_pxa168_drv_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct pxa168_usb_drv_data *drv_data;
+        void __iomem *regs;
+        int irq, err = 0;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_debug("Initializing pxa168-SoC USB Host Controller\n");
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_err(&pdev->dev,
+                        "Found HC with no IRQ. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                err = -ENODEV;
+                goto err1;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Found HC with no register addr. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                err = -ENODEV;
+                goto err1;
+        }
+
+        if (!request_mem_region(res->start, resource_size(res),
+                                ehci_pxa168_hc_driver.description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                err = -EBUSY;
+                goto err1;
+        }
+
+        regs = ioremap(res->start, resource_size(res));
+        if (regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                err = -EFAULT;
+                goto err2;
+        }
+
+        hcd = usb_create_hcd(&ehci_pxa168_hc_driver,
+                        &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                err = -ENOMEM;
+                goto err3;
+        }
+
+        drv_data = (struct pxa168_usb_drv_data *)hcd->hcd_priv;
+
+        /* Enable USB clock */
+        drv_data->pxa168_usb_clk = clk_get(&pdev->dev, "PXA168-USBCLK");
+        if (IS_ERR(drv_data->pxa168_usb_clk)) {
+                dev_err(&pdev->dev, "Couldn't get USB clock\n");
+                err = PTR_ERR(drv_data->pxa168_usb_clk);
+                goto err4;
+        }
+        clk_enable(drv_data->pxa168_usb_clk);
+
+        err = pxa168_usb_phy_init(pdev);
+        if (err) {
+                dev_err(&pdev->dev, "USB PHY initialization failed\n");
+                goto err5;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = regs;
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        hcd->has_tt = 1;
+        ehci->sbrn = 0x20;
+
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+        if (err)
+                goto err5;
+
+        return 0;
+
+err5:
+        clk_disable(drv_data->pxa168_usb_clk);
+        clk_put(drv_data->pxa168_usb_clk);
+err4:
+        usb_put_hcd(hcd);
+err3:
+        iounmap(regs);
+err2:
+        release_mem_region(res->start, resource_size(res));
+err1:
+        dev_err(&pdev->dev, "init %s fail, %d\n",
+                dev_name(&pdev->dev), err);
+
+        return err;
+}
+
+static int __exit ehci_pxa168_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct pxa168_usb_drv_data *drv_data =
+                (struct pxa168_usb_drv_data *)hcd->hcd_priv;
+
+        usb_remove_hcd(hcd);
+
+        /* Power down PHY & PLL */
+        writel(readl(drv_data->usb_phy_reg_base + USB_PHY_CTRL_REG) & (~0x3),
+                drv_data->usb_phy_reg_base + USB_PHY_CTRL_REG);
+
+        clk_disable(drv_data->pxa168_usb_clk);
+        clk_put(drv_data->pxa168_usb_clk);
+
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        iounmap(drv_data->usb_phy_reg_base);
+        release_mem_region(drv_data->usb_phy_res->start,
+                        resource_size(drv_data->usb_phy_res));
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+MODULE_ALIAS("platform:pxa168-ehci");
+
+static struct platform_driver ehci_pxa168_driver = {
+        .probe          = ehci_pxa168_drv_probe,
+        .remove         = __exit_p(ehci_pxa168_drv_remove),
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver.name    = "pxa168-ehci",
+};
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 0917e3a32465..4e4066c35a09 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -111,8 +111,6 @@ qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd)
                 }
         }
 
-        /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
-        wmb ();
         hw->hw_token &= cpu_to_hc32(ehci, QTD_TOGGLE | QTD_STS_PING);
 }
 
@@ -153,7 +151,7 @@ static void ehci_clear_tt_buffer_complete(struct usb_hcd *hcd,
         spin_lock_irqsave(&ehci->lock, flags);
         qh->clearing_tt = 0;
         if (qh->qh_state == QH_STATE_IDLE && !list_empty(&qh->qtd_list)
-                        && HC_IS_RUNNING(hcd->state))
+                        && ehci->rh_state == EHCI_RH_RUNNING)
                 qh_link_async(ehci, qh);
         spin_unlock_irqrestore(&ehci->lock, flags);
 }
@@ -425,7 +423,7 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
                 /* stop scanning when we reach qtds the hc is using */
                 } else if (likely (!stopped
-                                && HC_IS_RUNNING (ehci_to_hcd(ehci)->state))) {
+                                && ehci->rh_state == EHCI_RH_RUNNING)) {
                         break;
 
                 /* scan the whole queue for unlinks whenever it stops */
@@ -433,7 +431,7 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         stopped = 1;
 
                         /* cancel everything if we halt, suspend, etc */
-                        if (!HC_IS_RUNNING(ehci_to_hcd(ehci)->state))
+                        if (ehci->rh_state != EHCI_RH_RUNNING)
                                 last_status = -ESHUTDOWN;
 
                         /* this qtd is active; skip it unless a previous qtd
@@ -724,7 +722,8 @@ qh_urb_transaction (
 
         /*
          * control requests may need a terminating data "status" ack;
-         * bulk ones may need a terminating short packet (zero length).
+         * other OUT ones may need a terminating short packet
+         * (zero length).
          */
         if (likely (urb->transfer_buffer_length != 0)) {
                 int     one_more = 0;
@@ -733,7 +732,7 @@ qh_urb_transaction (
                         one_more = 1;
                         token ^= 0x0100;        /* "in" <--> "out"  */
                         token |= QTD_TOGGLE;    /* force DATA1 */
-                } else if (usb_pipebulk (urb->pipe)
+                } else if (usb_pipeout(urb->pipe)
                                 && (urb->transfer_flags & URB_ZERO_PACKET)
                                 && !(urb->transfer_buffer_length % maxpacket)) {
                         one_more = 1;
@@ -977,9 +976,8 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         /* in case a clear of CMD_ASE didn't take yet */
                         (void)handshake(ehci, &ehci->regs->status,
                                         STS_ASS, 0, 150);
-                        cmd |= CMD_ASE | CMD_RUN;
+                        cmd |= CMD_ASE;
                         ehci_writel(ehci, cmd, &ehci->regs->command);
-                        ehci_to_hcd(ehci)->state = HC_STATE_RUNNING;
                         /* posted write need not be known to HC yet ... */
                 }
         }
@@ -1058,7 +1056,7 @@ static struct ehci_qh *qh_append_tds (
                          */
                         token = qtd->hw_token;
                         qtd->hw_token = HALT_BIT(ehci);
-                        wmb ();
+
                         dummy = qh->dummy;
 
                         dma = dummy->qtd_dma;
@@ -1168,14 +1166,13 @@ static void end_unlink_async (struct ehci_hcd *ehci)
 
         qh_completions (ehci, qh);
 
-        if (!list_empty (&qh->qtd_list)
-                        && HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
+        if (!list_empty(&qh->qtd_list) && ehci->rh_state == EHCI_RH_RUNNING) {
                 qh_link_async (ehci, qh);
-        else {
+        } else {
                 /* it's not free to turn the async schedule on/off; leave it
                  * active but idle for a while once it empties.
                  */
-                if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state)
+                if (ehci->rh_state == EHCI_RH_RUNNING
                                 && ehci->async->qh_next.qh == NULL)
                         timer_action (ehci, TIMER_ASYNC_OFF);
         }
@@ -1211,7 +1208,7 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         /* stop async schedule right now? */
         if (unlikely (qh == ehci->async)) {
                 /* can't get here without STS_ASS set */
-                if (ehci_to_hcd(ehci)->state != HC_STATE_HALT
+                if (ehci->rh_state != EHCI_RH_HALTED
                                 && !ehci->reclaim) {
                         /* ... and CMD_IAAD clear */
                         ehci_writel(ehci, cmd & ~CMD_ASE,
@@ -1237,7 +1234,7 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         wmb ();
 
         /* If the controller isn't running, we don't have to wait for it */
-        if (unlikely(!HC_IS_RUNNING(ehci_to_hcd(ehci)->state))) {
+        if (unlikely(ehci->rh_state != EHCI_RH_RUNNING)) {
                 /* if (unlikely (qh->reclaim != 0))
                  *      this will recurse, probably not much
                  */
@@ -1260,7 +1257,7 @@ static void scan_async (struct ehci_hcd *ehci)
         enum ehci_timer_action  action = TIMER_IO_WATCHDOG;
 
         timer_action_done (ehci, TIMER_ASYNC_SHRINK);
-        stopped = !HC_IS_RUNNING(ehci_to_hcd(ehci)->state);
+        stopped = (ehci->rh_state != EHCI_RH_RUNNING);
 
         ehci->qh_scan_next = ehci->async->qh_next.qh;
         while (ehci->qh_scan_next) {
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index 9e77f1c8bdbd..024b65c4990d 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -136,7 +136,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
-        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto fail;
@@ -270,7 +270,7 @@ static int s5p_ehci_resume(struct device *dev)
         /* here we "know" root ports should always stay powered */
         ehci_port_power(ehci, 1);
 
-        hcd->state = HC_STATE_SUSPENDED;
+        ehci->rh_state = EHCI_RH_SUSPENDED;
 
         return 0;
 }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 2abf8543f083..56a32033adb3 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -36,6 +36,27 @@
 
 static int ehci_get_frame (struct usb_hcd *hcd);
 
+#ifdef CONFIG_PCI
+
+static unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
+{
+        unsigned uf;
+
+        /*
+         * The MosChip MCS9990 controller updates its microframe counter
+         * a little before the frame counter, and occasionally we will read
+         * the invalid intermediate value.  Avoid problems by checking the
+         * microframe number (the low-order 3 bits); if they are 0 then
+         * re-read the register to get the correct value.
+         */
+        uf = ehci_readl(ehci, &ehci->regs->frame_index);
+        if (unlikely(ehci->frame_index_bug && ((uf & 7) == 0)))
+                uf = ehci_readl(ehci, &ehci->regs->frame_index);
+        return uf;
+}
+
+#endif
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -479,10 +500,9 @@ static int enable_periodic (struct ehci_hcd *ehci)
         cmd = ehci_readl(ehci, &ehci->regs->command) | CMD_PSE;
         ehci_writel(ehci, cmd, &ehci->regs->command);
         /* posted write ... PSS happens later */
-        ehci_to_hcd(ehci)->state = HC_STATE_RUNNING;
 
         /* make sure ehci_work scans these */
-        ehci->next_uframe = ehci_readl(ehci, &ehci->regs->frame_index)
+        ehci->next_uframe = ehci_read_frame_index(ehci)
                 % (ehci->periodic_size << 3);
         if (unlikely(ehci->broken_periodic))
                 ehci->last_periodic_enable = ktime_get_real();
@@ -677,7 +697,7 @@ static void intr_deschedule (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
         /* reschedule QH iff another request is queued */
         if (!list_empty(&qh->qtd_list) &&
-                        HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
+                        ehci->rh_state == EHCI_RH_RUNNING) {
                 rc = qh_schedule(ehci, qh);
 
                 /* An error here likely indicates handshake failure
@@ -1409,7 +1429,7 @@ iso_stream_schedule (
                 goto fail;
         }
 
-        now = ehci_readl(ehci, &ehci->regs->frame_index) & (mod - 1);
+        now = ehci_read_frame_index(ehci) & (mod - 1);
 
         /* Typical case: reuse current schedule, stream is still active.
          * Hopefully there are no gaps from the host falling behind
@@ -1459,10 +1479,15 @@ iso_stream_schedule (
 
                 /* NOTE:  assumes URB_ISO_ASAP, to limit complexity/bugs */
 
-                /* find a uframe slot with enough bandwidth */
-                next = start + period;
-                for (; start < next; start++) {
-
+                /* find a uframe slot with enough bandwidth.
+                 * Early uframes are more precious because full-speed
+                 * iso IN transfers can't use late uframes,
+                 * and therefore they should be allocated last.
+                 */
+                next = start;
+                start += period;
+                do {
+                        start--;
                         /* check schedule: enough space? */
                         if (stream->highspeed) {
                                 if (itd_slot_ok(ehci, mod, start,
@@ -1475,7 +1500,7 @@ iso_stream_schedule (
                                                 start, sched, period))
                                         break;
                         }
-                }
+                } while (start > next);
 
                 /* no room in the schedule */
                 if (start == next) {
@@ -2275,8 +2300,8 @@ scan_periodic (struct ehci_hcd *ehci)
          * Touches as few pages as possible:  cache-friendly.
          */
         now_uframe = ehci->next_uframe;
-        if (HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
-                clock = ehci_readl(ehci, &ehci->regs->frame_index);
+        if (ehci->rh_state == EHCI_RH_RUNNING) {
+                clock = ehci_read_frame_index(ehci);
                 clock_frame = (clock >> 3) & (ehci->periodic_size - 1);
         } else  {
                 clock = now_uframe + mod - 1;
@@ -2310,7 +2335,7 @@ restart:
                         union ehci_shadow       temp;
                         int                     live;
 
-                        live = HC_IS_RUNNING (ehci_to_hcd(ehci)->state);
+                        live = (ehci->rh_state == EHCI_RH_RUNNING);
                         switch (hc32_to_cpu(ehci, type)) {
                         case Q_TYPE_QH:
                                 /* handle any completions */
@@ -2435,7 +2460,7 @@ restart:
                  * We can't advance our scan without collecting the ISO
                  * transfers that are still pending in this frame.
                  */
-                if (incomplete && HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
+                if (incomplete && ehci->rh_state == EHCI_RH_RUNNING) {
                         ehci->next_uframe = now_uframe;
                         break;
                 }
@@ -2451,12 +2476,11 @@ restart:
                 if (now_uframe == clock) {
                         unsigned        now;
 
-                        if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state)
+                        if (ehci->rh_state != EHCI_RH_RUNNING
                                         || ehci->periodic_sched == 0)
                                 break;
                         ehci->next_uframe = now_uframe;
-                        now = ehci_readl(ehci, &ehci->regs->frame_index) &
-                                        (mod - 1);
+                        now = ehci_read_frame_index(ehci) & (mod - 1);
                         if (now_uframe == now)
                                 break;
 
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index 86a95bb80a61..9d9cf47d80da 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -168,7 +168,7 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         clk_enable(priv->fclk);
         clk_enable(priv->iclk);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to add hcd");
                 goto fail_add_hcd;
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index dbf1e4ef3c17..b115b0b76e33 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -154,7 +154,7 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
         ehci->clk = usbh_clk;
 
         spear_start_ehci(ehci);
-        retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval)
                 goto fail_add_hcd;
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 02b2bfd49a10..db9d1b4bfbdc 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -674,7 +674,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
 #endif
 
-        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto fail;
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
index 47d749631bc7..54d1ab8aec49 100644
--- a/drivers/usb/host/ehci-vt8500.c
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -133,7 +133,7 @@ static int vt8500_ehci_drv_probe(struct platform_device *pdev)
         ehci_port_power(ehci, 1);
 
         ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                          IRQF_DISABLED | IRQF_SHARED);
+                          IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
                 return ret;
diff --git a/drivers/usb/host/ehci-xls.c b/drivers/usb/host/ehci-xls.c
new file mode 100644
index 000000000000..b4fb511d24bc
--- /dev/null
+++ b/drivers/usb/host/ehci-xls.c
@@ -0,0 +1,161 @@
+/*
+ * EHCI HCD for Netlogic XLS processors.
+ *
+ * (C) Copyright 2011 Netlogic Microsystems Inc.
+ *
+ *  Based on various ehci-*.c drivers
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ */
+
+#include <linux/platform_device.h>
+
+static int ehci_xls_setup(struct usb_hcd *hcd)
+{
+        int     retval;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci_reset(ehci);
+
+        return retval;
+}
+
+int ehci_xls_probe_internal(const struct hc_driver *driver,
+        struct platform_device *pdev)
+{
+        struct usb_hcd  *hcd;
+        struct resource *res;
+        int retval, irq;
+
+        /* Get our IRQ from an earlier registered Platform Resource */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "Found HC with no IRQ. Check %s setup!\n",
+                                dev_name(&pdev->dev));
+                return -ENODEV;
+        }
+
+        /* Get our Memory Handle */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Error: MMIO Handle %s setup!\n",
+                                dev_name(&pdev->dev));
+                return -ENODEV;
+        }
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err1;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                retval = -EBUSY;
+                goto err2;
+        }
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                retval = -EFAULT;
+                goto err3;
+        }
+
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (retval != 0)
+                goto err4;
+        return retval;
+
+err4:
+        iounmap(hcd->regs);
+err3:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err2:
+        usb_put_hcd(hcd);
+err1:
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev),
+                        retval);
+        return retval;
+}
+
+static struct hc_driver ehci_xls_hc_driver = {
+        .description    = hcd_name,
+        .product_desc   = "XLS EHCI Host Controller",
+        .hcd_priv_size  = sizeof(struct ehci_hcd),
+        .irq            = ehci_irq,
+        .flags          = HCD_USB2 | HCD_MEMORY,
+        .reset          = ehci_xls_setup,
+        .start          = ehci_run,
+        .stop           = ehci_stop,
+        .shutdown       = ehci_shutdown,
+
+        .urb_enqueue    = ehci_urb_enqueue,
+        .urb_dequeue    = ehci_urb_dequeue,
+        .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
+
+        .get_frame_number = ehci_get_frame,
+
+        .hub_status_data = ehci_hub_status_data,
+        .hub_control    = ehci_hub_control,
+        .bus_suspend    = ehci_bus_suspend,
+        .bus_resume     = ehci_bus_resume,
+        .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_xls_probe(struct platform_device *pdev)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        return ehci_xls_probe_internal(&ehci_xls_hc_driver, pdev);
+}
+
+static int ehci_xls_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        return 0;
+}
+
+MODULE_ALIAS("ehci-xls");
+
+static struct platform_driver ehci_xls_driver = {
+        .probe          = ehci_xls_probe,
+        .remove         = ehci_xls_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name = "ehci-xls",
+        },
+};
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index cc7d337ec355..0a5fda73b3f2 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -62,6 +62,12 @@ struct ehci_stats {
 
 #define EHCI_MAX_ROOT_PORTS     15              /* see HCS_N_PORTS */
 
+enum ehci_rh_state {
+        EHCI_RH_HALTED,
+        EHCI_RH_SUSPENDED,
+        EHCI_RH_RUNNING
+};
+
 struct ehci_hcd {                       /* one per controller */
         /* glue to PCI and HCD framework */
         struct ehci_caps __iomem *caps;
@@ -70,6 +76,7 @@ struct ehci_hcd {			/* one per controller */
 
         __u32                   hcs_params;     /* cached register copy */
         spinlock_t              lock;
+        enum ehci_rh_state      rh_state;
 
         /* async schedule support */
         struct ehci_qh          *async;
@@ -139,6 +146,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
         unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
         unsigned                has_synopsys_hc_bug:1; /* Synopsys HC */
+        unsigned                frame_index_bug:1; /* MosChip (AKA NetMos) */
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
@@ -740,6 +748,22 @@ static inline u32 hc32_to_cpup (const struct ehci_hcd *ehci, const __hc32 *x)
 
 /*-------------------------------------------------------------------------*/
 
+#ifdef CONFIG_PCI
+
+/* For working around the MosChip frame-index-register bug */
+static unsigned ehci_read_frame_index(struct ehci_hcd *ehci);
+
+#else
+
+static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
+{
+        return ehci_readl(ehci, &ehci->regs->frame_index);
+}
+
+#endif
+
+/*-------------------------------------------------------------------------*/
+
 #ifndef DEBUG
 #define STUB_DEBUG_FILES
 #endif  /* DEBUG */
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 572ea53b0226..4ed6d19f2a54 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -621,12 +621,15 @@ static int __devinit of_fhci_probe(struct platform_device *ofdev)
                 goto err_pram;
         }
 
-        pram_addr = cpm_muram_alloc_fixed(iprop[2], FHCI_PRAM_SIZE);
+        pram_addr = cpm_muram_alloc(FHCI_PRAM_SIZE, 64);
         if (IS_ERR_VALUE(pram_addr)) {
                 dev_err(dev, "failed to allocate usb pram\n");
                 ret = -ENOMEM;
                 goto err_pram;
         }
+
+        qe_issue_cmd(QE_ASSIGN_PAGE_TO_DEVICE, QE_CR_SUBBLOCK_USB,
+                     QE_CR_PROTOCOL_UNSPECIFIED, pram_addr);
         fhci->pram = cpm_muram_addr(pram_addr);
 
         /* GPIOs and pins */
@@ -686,7 +689,7 @@ static int __devinit of_fhci_probe(struct platform_device *ofdev)
         }
 
         ret = request_irq(fhci->timer->irq, fhci_frame_limit_timer_irq,
-                          IRQF_DISABLED, "qe timer (usb)", hcd);
+                          0, "qe timer (usb)", hcd);
         if (ret) {
                 dev_err(dev, "failed to request timer irq");
                 goto err_timer_irq;
@@ -745,7 +748,7 @@ static int __devinit of_fhci_probe(struct platform_device *ofdev)
         out_be16(&fhci->regs->usb_event, 0xffff);
         out_be16(&fhci->regs->usb_mask, 0);
 
-        ret = usb_add_hcd(hcd, usb_irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, usb_irq, 0);
         if (ret < 0)
                 goto err_add_hcd;
 
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index a42ef380e917..2df851b4bc7c 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -1,7 +1,7 @@
 /*
  * Freescale QUICC Engine USB Host Controller Driver
  *
- * Copyright (c) Freescale Semicondutor, Inc. 2006.
+ * Copyright (c) Freescale Semicondutor, Inc. 2006, 2011.
  *               Shlomi Gridish <gridish@freescale.com>
  *               Jerry Huang <Chang-Ming.Huang@freescale.com>
  * Copyright (c) Logic Product Development, Inc. 2007
@@ -810,9 +810,11 @@ void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb)
                 ed->dev_addr = usb_pipedevice(urb->pipe);
                 ed->max_pkt_size = usb_maxpacket(urb->dev, urb->pipe,
                         usb_pipeout(urb->pipe));
+                /* setup stage */
                 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, FHCI_TA_SETUP,
                         USB_TD_TOGGLE_DATA0, urb->setup_packet, 8, 0, 0, true);
 
+                /* data stage */
                 if (data_len > 0) {
                         td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
                                 usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
@@ -820,9 +822,18 @@ void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb)
                                 USB_TD_TOGGLE_DATA1, data, data_len, 0, 0,
                                 true);
                 }
-                td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
-                        usb_pipeout(urb->pipe) ? FHCI_TA_IN : FHCI_TA_OUT,
-                        USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
+
+                /* status stage */
+                if (data_len > 0)
+                        td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
+                                (usb_pipeout(urb->pipe) ? FHCI_TA_IN :
+                                                          FHCI_TA_OUT),
+                                USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
+                else
+                         td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
+                                FHCI_TA_IN,
+                                USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
+
                 urb_state = US_CTRL_SETUP;
                 break;
         case FHCI_TF_ISO:
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index 79a66d622f9c..9037035ad1e4 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -16,6 +16,7 @@
 #include <linux/io.h>
 #include <linux/of_platform.h>
 #include <linux/clk.h>
+#include <linux/module.h>
 
 struct fsl_usb2_dev_data {
         char *dr_mode;          /* controller mode */
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index af05718bdc73..2ee18cfa1efe 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -1891,7 +1891,7 @@ static int imx21_probe(struct platform_device *pdev)
         dev_info(imx21->dev, "Hardware HC revision: 0x%02X\n",
                 (readl(imx21->regs + USBOTG_HWMODE) >> 16) & 0xFF);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, 0);
         if (ret != 0) {
                 dev_err(imx21->dev, "usb_add_hcd() returned %d\n", ret);
                 goto failed_add_hcd;
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index baae4ccd16ac..d91e5f211a76 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -1639,7 +1639,7 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
                 goto err6;
         }
 
-        ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, irqflags);
         if (ret)
                 goto err6;
 
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 9c37dad3e816..e5fd8aa57af1 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -2358,7 +2358,7 @@ static int isp1362_hc_reset(struct usb_hcd *hcd)
         unsigned long flags;
         int clkrdy = 0;
 
-        pr_info("%s:\n", __func__);
+        pr_debug("%s:\n", __func__);
 
         if (isp1362_hcd->board && isp1362_hcd->board->reset) {
                 isp1362_hcd->board->reset(hcd->self.controller, 1);
@@ -2395,7 +2395,7 @@ static void isp1362_hc_stop(struct usb_hcd *hcd)
         unsigned long flags;
         u32 tmp;
 
-        pr_info("%s:\n", __func__);
+        pr_debug("%s:\n", __func__);
 
         del_timer_sync(&hcd->rh_timer);
 
@@ -2523,7 +2523,7 @@ static int isp1362_hc_start(struct usb_hcd *hcd)
         u16 chipid;
         unsigned long flags;
 
-        pr_info("%s:\n", __func__);
+        pr_debug("%s:\n", __func__);
 
         spin_lock_irqsave(&isp1362_hcd->lock, flags);
         chipid = isp1362_read_reg16(isp1362_hcd, HCCHIPID);
@@ -2773,7 +2773,7 @@ static int __devinit isp1362_probe(struct platform_device *pdev)
         if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
                 irq_flags |= IRQF_TRIGGER_LOW;
 
-        retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_DISABLED | IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_SHARED);
         if (retval != 0)
                 goto err6;
         pr_info("%s, irq %d\n", hcd->product_desc, irq);
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 840beda66dd9..27dfab80ed8f 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -21,8 +21,10 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/mm.h>
+#include <linux/timer.h>
 #include <asm/unaligned.h>
 #include <asm/cacheflush.h>
+#include <linux/gpio.h>
 
 #include "isp1760-hcd.h"
 
@@ -39,7 +41,6 @@ struct isp1760_hcd {
         int                     int_done_map;
         struct memory_chunk memory_pool[BLOCKS];
         struct list_head        controlqhs, bulkqhs, interruptqhs;
-        int active_ptds;
 
         /* periodic schedule support */
 #define DEFAULT_I_TDPS          1024
@@ -48,6 +49,8 @@ struct isp1760_hcd {
         unsigned long           reset_done;
         unsigned long           next_statechange;
         unsigned int            devflags;
+
+        int                     rst_gpio;
 };
 
 static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
@@ -114,6 +117,7 @@ struct isp1760_qh {
         u32 toggle;
         u32 ping;
         int slot;
+        int tt_buffer_dirty;    /* See USB2.0 spec section 11.17.5 */
 };
 
 struct urb_listitem {
@@ -432,6 +436,18 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
         int result;
         u32 scratch, hwmode;
 
+        /* low-level chip reset */
+        if (gpio_is_valid(priv->rst_gpio)) {
+                unsigned int rst_lvl;
+
+                rst_lvl = (priv->devflags &
+                           ISP1760_FLAG_RESET_ACTIVE_HIGH) ? 1 : 0;
+
+                gpio_set_value(priv->rst_gpio, rst_lvl);
+                mdelay(50);
+                gpio_set_value(priv->rst_gpio, !rst_lvl);
+        }
+
         /* Setup HW Mode Control: This assumes a level active-low interrupt */
         hwmode = HW_DATA_BUS_32BIT;
 
@@ -489,10 +505,6 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
                            16 : 32, (priv->devflags & ISP1760_FLAG_ANALOG_OC) ?
                            "analog" : "digital");
 
-        /* This is weird: at the first plug-in of a device there seems to be
-           one packet queued that never gets returned? */
-        priv->active_ptds = -1;
-
         /* ATL reset */
         reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode | ALL_ATX_RESET);
         mdelay(10);
@@ -514,83 +526,6 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
         return priv_init(hcd);
 }
 
-static void isp1760_init_maps(struct usb_hcd *hcd)
-{
-        /*set last maps, for iso its only 1, else 32 tds bitmap*/
-        reg_write32(hcd->regs, HC_ATL_PTD_LASTPTD_REG, 0x80000000);
-        reg_write32(hcd->regs, HC_INT_PTD_LASTPTD_REG, 0x80000000);
-        reg_write32(hcd->regs, HC_ISO_PTD_LASTPTD_REG, 0x00000001);
-
-        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, 0xffffffff);
-        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, 0xffffffff);
-        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, 0xffffffff);
-
-        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG,
-                                                ATL_BUF_FILL | INT_BUF_FILL);
-}
-
-static void isp1760_enable_interrupts(struct usb_hcd *hcd)
-{
-        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_AND_REG, 0);
-        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, 0xffffffff);
-        reg_write32(hcd->regs, HC_INT_IRQ_MASK_AND_REG, 0);
-        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, 0xffffffff);
-        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_AND_REG, 0);
-        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_OR_REG, 0xffffffff);
-        /* step 23 passed */
-}
-
-static int isp1760_run(struct usb_hcd *hcd)
-{
-        int retval;
-        u32 temp;
-        u32 command;
-        u32 chipid;
-
-        hcd->uses_new_polling = 1;
-
-        hcd->state = HC_STATE_RUNNING;
-        isp1760_enable_interrupts(hcd);
-        temp = reg_read32(hcd->regs, HC_HW_MODE_CTRL);
-        reg_write32(hcd->regs, HC_HW_MODE_CTRL, temp | HW_GLOBAL_INTR_EN);
-
-        command = reg_read32(hcd->regs, HC_USBCMD);
-        command &= ~(CMD_LRESET|CMD_RESET);
-        command |= CMD_RUN;
-        reg_write32(hcd->regs, HC_USBCMD, command);
-
-        retval = handshake(hcd, HC_USBCMD, CMD_RUN, CMD_RUN, 250 * 1000);
-        if (retval)
-                return retval;
-
-        /*
-         * XXX
-         * Spec says to write FLAG_CF as last config action, priv code grabs
-         * the semaphore while doing so.
-         */
-        down_write(&ehci_cf_port_reset_rwsem);
-        reg_write32(hcd->regs, HC_CONFIGFLAG, FLAG_CF);
-
-        retval = handshake(hcd, HC_CONFIGFLAG, FLAG_CF, FLAG_CF, 250 * 1000);
-        up_write(&ehci_cf_port_reset_rwsem);
-        if (retval)
-                return retval;
-
-        chipid = reg_read32(hcd->regs, HC_CHIP_ID_REG);
-        dev_info(hcd->self.controller, "USB ISP %04x HW rev. %d started\n",
-                                        chipid & 0xffff, chipid >> 16);
-
-        /* PTD Register Init Part 2, Step 28 */
-        /* enable INTs */
-        isp1760_init_maps(hcd);
-
-        /* GRR this is run-once init(), being done every time the HC starts.
-         * So long as they're part of class devices, we can't do it init()
-         * since the class device isn't created that early.
-         */
-        return 0;
-}
-
 static u32 base_to_chip(u32 base)
 {
         return ((base - 0x400) >> 3);
@@ -813,28 +748,29 @@ static void start_bus_transfer(struct usb_hcd *hcd, u32 ptd_offset, int slot,
         WARN_ON(slots[slot].qh);
         WARN_ON(qtd->status != QTD_PAYLOAD_ALLOC);
 
-        slots[slot].qtd = qtd;
-        slots[slot].qh = qh;
-        qh->slot = slot;
-        qtd->status = QTD_XFER_STARTED; /* Set this before writing ptd, since
-                interrupt routine may preempt and expects this value. */
-        ptd_write(hcd->regs, ptd_offset, slot, ptd);
-        priv->active_ptds++;
-
         /* Make sure done map has not triggered from some unlinked transfer */
         if (ptd_offset == ATL_PTD_OFFSET) {
                 priv->atl_done_map |= reg_read32(hcd->regs,
                                                 HC_ATL_PTD_DONEMAP_REG);
-                priv->atl_done_map &= ~(1 << qh->slot);
+                priv->atl_done_map &= ~(1 << slot);
+        } else {
+                priv->int_done_map |= reg_read32(hcd->regs,
+                                                HC_INT_PTD_DONEMAP_REG);
+                priv->int_done_map &= ~(1 << slot);
+        }
+
+        qh->slot = slot;
+        qtd->status = QTD_XFER_STARTED;
+        slots[slot].timestamp = jiffies;
+        slots[slot].qtd = qtd;
+        slots[slot].qh = qh;
+        ptd_write(hcd->regs, ptd_offset, slot, ptd);
 
+        if (ptd_offset == ATL_PTD_OFFSET) {
                 skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
                 skip_map &= ~(1 << qh->slot);
                 reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, skip_map);
         } else {
-                priv->int_done_map |= reg_read32(hcd->regs,
-                                                HC_INT_PTD_DONEMAP_REG);
-                priv->int_done_map &= ~(1 << qh->slot);
-
                 skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
                 skip_map &= ~(1 << qh->slot);
                 reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, skip_map);
@@ -858,10 +794,7 @@ static void collect_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh,
                 if (qtd->status < QTD_XFER_COMPLETE)
                         break;
 
-                if (list_is_last(&qtd->qtd_list, &qh->qtd_list))
-                        last_qtd = 1;
-                else
-                        last_qtd = qtd->urb != qtd_next->urb;
+                last_qtd = last_qtd_of_urb(qtd, qh);
 
                 if ((!last_qtd) && (qtd->status == QTD_RETIRE))
                         qtd_next->status = QTD_RETIRE;
@@ -902,7 +835,7 @@ static void collect_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh,
                         urb_listitem = kmem_cache_zalloc(urb_listitem_cachep,
                                                                 GFP_ATOMIC);
                         if (unlikely(!urb_listitem))
-                                break;
+                                break; /* Try again on next call */
                         urb_listitem->urb = qtd->urb;
                         list_add_tail(&urb_listitem->urb_list, urb_list);
                 }
@@ -928,6 +861,10 @@ static void enqueue_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh)
                 return;
         }
 
+        /* Make sure this endpoint's TT buffer is clean before queueing ptds */
+        if (qh->tt_buffer_dirty)
+                return;
+
         if (usb_pipeint(list_entry(qh->qtd_list.next, struct isp1760_qtd,
                                                         qtd_list)->urb->pipe)) {
                 ptd_offset = INT_PTD_OFFSET;
@@ -1168,11 +1105,9 @@ static int check_atl_transfer(struct usb_hcd *hcd, struct ptd *ptd,
         return PTD_STATE_QTD_DONE;
 }
 
-static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
+static void handle_done_ptds(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 imask;
-        irqreturn_t irqret = IRQ_NONE;
         struct ptd ptd;
         struct isp1760_qh *qh;
         int slot;
@@ -1181,27 +1116,14 @@ static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
         u32 ptd_offset;
         struct isp1760_qtd *qtd;
         int modified;
-        static int last_active_ptds;
-        int int_skip_map, atl_skip_map;
-
-        spin_lock(&priv->lock);
-
-        if (!(hcd->state & HC_STATE_RUNNING))
-                goto leave;
-
-        imask = reg_read32(hcd->regs, HC_INTERRUPT_REG);
-        if (unlikely(!imask))
-                goto leave;
-        reg_write32(hcd->regs, HC_INTERRUPT_REG, imask); /* Clear */
+        int skip_map;
 
-        int_skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
-        atl_skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
-        priv->int_done_map |= reg_read32(hcd->regs, HC_INT_PTD_DONEMAP_REG);
-        priv->atl_done_map |= reg_read32(hcd->regs, HC_ATL_PTD_DONEMAP_REG);
-        priv->int_done_map &= ~int_skip_map;
-        priv->atl_done_map &= ~atl_skip_map;
+        skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
+        priv->int_done_map &= ~skip_map;
+        skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+        priv->atl_done_map &= ~skip_map;
 
-        modified = priv->int_done_map | priv->atl_done_map;
+        modified = priv->int_done_map || priv->atl_done_map;
 
         while (priv->int_done_map || priv->atl_done_map) {
                 if (priv->int_done_map) {
@@ -1240,7 +1162,6 @@ static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
                 slots[slot].qtd = NULL;
                 qh = slots[slot].qh;
                 slots[slot].qh = NULL;
-                priv->active_ptds--;
                 qh->slot = -1;
 
                 WARN_ON(qtd->status != QTD_XFER_STARTED);
@@ -1281,6 +1202,15 @@ static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
 
                 case PTD_STATE_URB_RETIRE:
                         qtd->status = QTD_RETIRE;
+                        if ((qtd->urb->dev->speed != USB_SPEED_HIGH) &&
+                                        (qtd->urb->status != -EPIPE) &&
+                                        (qtd->urb->status != -EREMOTEIO)) {
+                                qh->tt_buffer_dirty = 1;
+                                if (usb_hub_clear_tt_buffer(qtd->urb))
+                                        /* Clear failed; let's hope things work
+                                           anyway */
+                                        qh->tt_buffer_dirty = 0;
+                        }
                         qtd = NULL;
                         qh->toggle = 0;
                         qh->ping = 0;
@@ -1311,22 +1241,28 @@ static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
 
         if (modified)
                 schedule_ptds(hcd);
+}
 
-        /* ISP1760 Errata 2 explains that interrupts may be missed (or not
-           happen?) if two USB devices are running simultaneously. Perhaps
-           this happens when a PTD is finished during interrupt handling;
-           enable SOF interrupts if PTDs are still scheduled when exiting this
-           interrupt handler, just to be safe. */
+static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 imask;
+        irqreturn_t irqret = IRQ_NONE;
 
-        if (priv->active_ptds != last_active_ptds) {
-                if (priv->active_ptds > 0)
-                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
-                                                INTERRUPT_ENABLE_SOT_MASK);
-                else
-                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
-                                                INTERRUPT_ENABLE_MASK);
-                last_active_ptds = priv->active_ptds;
-        }
+        spin_lock(&priv->lock);
+
+        if (!(hcd->state & HC_STATE_RUNNING))
+                goto leave;
+
+        imask = reg_read32(hcd->regs, HC_INTERRUPT_REG);
+        if (unlikely(!imask))
+                goto leave;
+        reg_write32(hcd->regs, HC_INTERRUPT_REG, imask); /* Clear */
+
+        priv->int_done_map |= reg_read32(hcd->regs, HC_INT_PTD_DONEMAP_REG);
+        priv->atl_done_map |= reg_read32(hcd->regs, HC_ATL_PTD_DONEMAP_REG);
+
+        handle_done_ptds(hcd);
 
         irqret = IRQ_HANDLED;
 leave:
@@ -1335,6 +1271,138 @@ leave:
         return irqret;
 }
 
+/*
+ * Workaround for problem described in chip errata 2:
+ *
+ * Sometimes interrupts are not generated when ATL (not INT?) completion occurs.
+ * One solution suggested in the errata is to use SOF interrupts _instead_of_
+ * ATL done interrupts (the "instead of" might be important since it seems
+ * enabling ATL interrupts also causes the chip to sometimes - rarely - "forget"
+ * to set the PTD's done bit in addition to not generating an interrupt!).
+ *
+ * So if we use SOF + ATL interrupts, we sometimes get stale PTDs since their
+ * done bit is not being set. This is bad - it blocks the endpoint until reboot.
+ *
+ * If we use SOF interrupts only, we get latency between ptd completion and the
+ * actual handling. This is very noticeable in testusb runs which takes several
+ * minutes longer without ATL interrupts.
+ *
+ * A better solution is to run the code below every SLOT_CHECK_PERIOD ms. If it
+ * finds active ATL slots which are older than SLOT_TIMEOUT ms, it checks the
+ * slot's ACTIVE and VALID bits. If these are not set, the ptd is considered
+ * completed and its done map bit is set.
+ *
+ * The values of SLOT_TIMEOUT and SLOT_CHECK_PERIOD have been arbitrarily chosen
+ * not to cause too much lag when this HW bug occurs, while still hopefully
+ * ensuring that the check does not falsely trigger.
+ */
+#define SLOT_TIMEOUT 300
+#define SLOT_CHECK_PERIOD 200
+static struct timer_list errata2_timer;
+
+void errata2_function(unsigned long data)
+{
+        struct usb_hcd *hcd = (struct usb_hcd *) data;
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int slot;
+        struct ptd ptd;
+        unsigned long spinflags;
+
+        spin_lock_irqsave(&priv->lock, spinflags);
+
+        for (slot = 0; slot < 32; slot++)
+                if (priv->atl_slots[slot].qh && time_after(jiffies,
+                                        priv->atl_slots[slot].timestamp +
+                                        SLOT_TIMEOUT * HZ / 1000)) {
+                        ptd_read(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
+                        if (!FROM_DW0_VALID(ptd.dw0) &&
+                                        !FROM_DW3_ACTIVE(ptd.dw3))
+                                priv->atl_done_map |= 1 << slot;
+                }
+
+        if (priv->atl_done_map)
+                handle_done_ptds(hcd);
+
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+
+        errata2_timer.expires = jiffies + SLOT_CHECK_PERIOD * HZ / 1000;
+        add_timer(&errata2_timer);
+}
+
+static int isp1760_run(struct usb_hcd *hcd)
+{
+        int retval;
+        u32 temp;
+        u32 command;
+        u32 chipid;
+
+        hcd->uses_new_polling = 1;
+
+        hcd->state = HC_STATE_RUNNING;
+
+        /* Set PTD interrupt AND & OR maps */
+        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_INT_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_OR_REG, 0xffffffff);
+        /* step 23 passed */
+
+        temp = reg_read32(hcd->regs, HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, temp | HW_GLOBAL_INTR_EN);
+
+        command = reg_read32(hcd->regs, HC_USBCMD);
+        command &= ~(CMD_LRESET|CMD_RESET);
+        command |= CMD_RUN;
+        reg_write32(hcd->regs, HC_USBCMD, command);
+
+        retval = handshake(hcd, HC_USBCMD, CMD_RUN, CMD_RUN, 250 * 1000);
+        if (retval)
+                return retval;
+
+        /*
+         * XXX
+         * Spec says to write FLAG_CF as last config action, priv code grabs
+         * the semaphore while doing so.
+         */
+        down_write(&ehci_cf_port_reset_rwsem);
+        reg_write32(hcd->regs, HC_CONFIGFLAG, FLAG_CF);
+
+        retval = handshake(hcd, HC_CONFIGFLAG, FLAG_CF, FLAG_CF, 250 * 1000);
+        up_write(&ehci_cf_port_reset_rwsem);
+        if (retval)
+                return retval;
+
+        init_timer(&errata2_timer);
+        errata2_timer.function = errata2_function;
+        errata2_timer.data = (unsigned long) hcd;
+        errata2_timer.expires = jiffies + SLOT_CHECK_PERIOD * HZ / 1000;
+        add_timer(&errata2_timer);
+
+        chipid = reg_read32(hcd->regs, HC_CHIP_ID_REG);
+        dev_info(hcd->self.controller, "USB ISP %04x HW rev. %d started\n",
+                                        chipid & 0xffff, chipid >> 16);
+
+        /* PTD Register Init Part 2, Step 28 */
+
+        /* Setup registers controlling PTD checking */
+        reg_write32(hcd->regs, HC_ATL_PTD_LASTPTD_REG, 0x80000000);
+        reg_write32(hcd->regs, HC_INT_PTD_LASTPTD_REG, 0x80000000);
+        reg_write32(hcd->regs, HC_ISO_PTD_LASTPTD_REG, 0x00000001);
+        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG,
+                                                ATL_BUF_FILL | INT_BUF_FILL);
+
+        /* GRR this is run-once init(), being done every time the HC starts.
+         * So long as they're part of class devices, we can't do it init()
+         * since the class device isn't created that early.
+         */
+        return 0;
+}
+
 static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len)
 {
         qtd->data_buffer = databuffer;
@@ -1503,7 +1571,6 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
         packetize_urb(hcd, urb, &new_qtds, mem_flags);
         if (list_empty(&new_qtds))
                 return -ENOMEM;
-        urb->hcpriv = NULL; /* Used to signal unlink to interrupt handler */
 
         retval = 0;
         spin_lock_irqsave(&priv->lock, spinflags);
@@ -1531,6 +1598,7 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 qh = qh_alloc(GFP_ATOMIC);
                 if (!qh) {
                         retval = -ENOMEM;
+                        usb_hcd_unlink_urb_from_ep(hcd, urb);
                         goto out;
                 }
                 list_add_tail(&qh->qh_list, ep_queue);
@@ -1570,7 +1638,41 @@ static void kill_transfer(struct usb_hcd *hcd, struct urb *urb,
         }
 
         qh->slot = -1;
-        priv->active_ptds--;
+}
+
+/*
+ * Retire the qtds beginning at 'qtd' and belonging all to the same urb, killing
+ * any active transfer belonging to the urb in the process.
+ */
+static void dequeue_urb_from_qtd(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                                                struct isp1760_qtd *qtd)
+{
+        struct urb *urb;
+        int urb_was_running;
+
+        urb = qtd->urb;
+        urb_was_running = 0;
+        list_for_each_entry_from(qtd, &qh->qtd_list, qtd_list) {
+                if (qtd->urb != urb)
+                        break;
+
+                if (qtd->status >= QTD_XFER_STARTED)
+                        urb_was_running = 1;
+                if (last_qtd_of_urb(qtd, qh) &&
+                                        (qtd->status >= QTD_XFER_COMPLETE))
+                        urb_was_running = 0;
+
+                if (qtd->status == QTD_XFER_STARTED)
+                        kill_transfer(hcd, urb, qh);
+                qtd->status = QTD_RETIRE;
+        }
+
+        if ((urb->dev->speed != USB_SPEED_HIGH) && urb_was_running) {
+                qh->tt_buffer_dirty = 1;
+                if (usb_hub_clear_tt_buffer(urb))
+                        /* Clear failed; let's hope things work anyway */
+                        qh->tt_buffer_dirty = 0;
+        }
 }
 
 static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
@@ -1595,9 +1697,8 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
 
         list_for_each_entry(qtd, &qh->qtd_list, qtd_list)
                 if (qtd->urb == urb) {
-                        if (qtd->status == QTD_XFER_STARTED)
-                                kill_transfer(hcd, urb, qh);
-                        qtd->status = QTD_RETIRE;
+                        dequeue_urb_from_qtd(hcd, qh, qtd);
+                        break;
                 }
 
         urb->status = status;
@@ -1622,12 +1723,11 @@ static void isp1760_endpoint_disable(struct usb_hcd *hcd,
         if (!qh)
                 goto out;
 
-        list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
-                if (qtd->status == QTD_XFER_STARTED)
-                        kill_transfer(hcd, qtd->urb, qh);
-                qtd->status = QTD_RETIRE;
-                qtd->urb->status = -ECONNRESET;
-        }
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list)
+                if (qtd->status != QTD_RETIRE) {
+                        dequeue_urb_from_qtd(hcd, qh, qtd);
+                        qtd->urb->status = -ECONNRESET;
+                }
 
         ep->hcpriv = NULL;
         /* Cannot free qh here since it will be parsed by schedule_ptds() */
@@ -2021,6 +2121,8 @@ static void isp1760_stop(struct usb_hcd *hcd)
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         u32 temp;
 
+        del_timer(&errata2_timer);
+
         isp1760_hub_control(hcd, ClearPortFeature, USB_PORT_FEAT_POWER, 1,
                         NULL, 0);
         mdelay(20);
@@ -2048,6 +2150,23 @@ static void isp1760_shutdown(struct usb_hcd *hcd)
         reg_write32(hcd->regs, HC_USBCMD, command);
 }
 
+static void isp1760_clear_tt_buffer_complete(struct usb_hcd *hcd,
+                                                struct usb_host_endpoint *ep)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        struct isp1760_qh *qh = ep->hcpriv;
+        unsigned long spinflags;
+
+        if (!qh)
+                return;
+
+        spin_lock_irqsave(&priv->lock, spinflags);
+        qh->tt_buffer_dirty = 0;
+        schedule_ptds(hcd);
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+}
+
+
 static const struct hc_driver isp1760_hc_driver = {
         .description            = "isp1760-hcd",
         .product_desc           = "NXP ISP1760 USB Host Controller",
@@ -2064,6 +2183,7 @@ static const struct hc_driver isp1760_hc_driver = {
         .get_frame_number       = isp1760_get_frame,
         .hub_status_data        = isp1760_hub_status_data,
         .hub_control            = isp1760_hub_control,
+        .clear_tt_buffer_complete       = isp1760_clear_tt_buffer_complete,
 };
 
 int __init init_kmem_once(void)
@@ -2102,6 +2222,7 @@ void deinit_kmem_cache(void)
 
 struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
                                  int irq, unsigned long irqflags,
+                                 int rst_gpio,
                                  struct device *dev, const char *busname,
                                  unsigned int devflags)
 {
@@ -2121,6 +2242,7 @@ struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
 
         priv = hcd_to_priv(hcd);
         priv->devflags = devflags;
+        priv->rst_gpio = rst_gpio;
         init_memory(priv);
         hcd->regs = ioremap(res_start, res_len);
         if (!hcd->regs) {
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 014a7dfadf91..33dc79ccaa6b 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -4,6 +4,7 @@
 /* exports for if */
 struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
                                  int irq, unsigned long irqflags,
+                                 int rst_gpio,
                                  struct device *dev, const char *busname,
                                  unsigned int devflags);
 int init_kmem_once(void);
@@ -73,7 +74,6 @@ void deinit_kmem_cache(void);
 #define HC_EOT_INT              (1 << 3)
 #define HC_SOT_INT              (1 << 1)
 #define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT)
-#define INTERRUPT_ENABLE_SOT_MASK       (HC_SOT_INT)
 
 #define HC_ISO_IRQ_MASK_OR_REG  0x318
 #define HC_INT_IRQ_MASK_OR_REG  0x31C
@@ -107,6 +107,7 @@ struct ptd {
 struct slotinfo {
         struct isp1760_qh *qh;
         struct isp1760_qtd *qtd;
+        unsigned long timestamp;
 };
 
 
@@ -126,6 +127,7 @@ typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
 #define ISP1760_FLAG_ISP1761            0x00000040 /* Chip is ISP1761 */
 #define ISP1760_FLAG_INTR_POL_HIGH      0x00000080 /* Interrupt polarity active high */
 #define ISP1760_FLAG_INTR_EDGE_TRIG     0x00000100 /* Interrupt edge triggered */
+#define ISP1760_FLAG_RESET_ACTIVE_HIGH  0x80000000 /* RESET GPIO active high */
 
 /* chip memory management */
 struct memory_chunk {
@@ -188,6 +190,7 @@ struct memory_chunk {
 #define DW3_BABBLE_BIT                  (1 << 29)
 #define DW3_HALT_BIT                    (1 << 30)
 #define DW3_ACTIVE_BIT                  (1 << 31)
+#define FROM_DW3_ACTIVE(x)              (((x) >> 31) & 0x01)
 
 #define INT_UNDERRUN                    (1 << 2)
 #define INT_BABBLE                      (1 << 1)
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 7ee30056f373..a7dc1e1d45f2 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -11,25 +11,35 @@
 
 #include <linux/usb.h>
 #include <linux/io.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/usb/isp1760.h>
 #include <linux/usb/hcd.h>
 
 #include "isp1760-hcd.h"
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_OF
+#include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/of_gpio.h>
 #endif
 
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
 #endif
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_OF
+struct isp1760 {
+        struct usb_hcd *hcd;
+        int rst_gpio;
+};
+
 static int of_isp1760_probe(struct platform_device *dev)
 {
-        struct usb_hcd *hcd;
+        struct isp1760 *drvdata;
         struct device_node *dp = dev->dev.of_node;
         struct resource *res;
         struct resource memory;
@@ -39,6 +49,11 @@ static int of_isp1760_probe(struct platform_device *dev)
         int ret;
         const unsigned int *prop;
         unsigned int devflags = 0;
+        enum of_gpio_flags gpio_flags;
+
+        drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+        if (!drvdata)
+                return -ENOMEM;
 
         ret = of_address_to_resource(dp, 0, &memory);
         if (ret)
@@ -78,32 +93,57 @@ static int of_isp1760_probe(struct platform_device *dev)
         if (of_get_property(dp, "dreq-polarity", NULL) != NULL)
                 devflags |= ISP1760_FLAG_DREQ_POL_HIGH;
 
-        hcd = isp1760_register(memory.start, res_len, virq,
-                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
-                devflags);
-        if (IS_ERR(hcd)) {
-                ret = PTR_ERR(hcd);
-                goto release_reg;
+        drvdata->rst_gpio = of_get_gpio_flags(dp, 0, &gpio_flags);
+        if (gpio_is_valid(drvdata->rst_gpio)) {
+                ret = gpio_request(drvdata->rst_gpio, dev_name(&dev->dev));
+                if (!ret) {
+                        if (!(gpio_flags & OF_GPIO_ACTIVE_LOW)) {
+                                devflags |= ISP1760_FLAG_RESET_ACTIVE_HIGH;
+                                gpio_direction_output(drvdata->rst_gpio, 0);
+                        } else {
+                                gpio_direction_output(drvdata->rst_gpio, 1);
+                        }
+                } else {
+                        drvdata->rst_gpio = ret;
+                }
         }
 
-        dev_set_drvdata(&dev->dev, hcd);
+        drvdata->hcd = isp1760_register(memory.start, res_len, virq,
+                                        IRQF_SHARED, drvdata->rst_gpio,
+                                        &dev->dev, dev_name(&dev->dev),
+                                        devflags);
+        if (IS_ERR(drvdata->hcd)) {
+                ret = PTR_ERR(drvdata->hcd);
+                goto free_gpio;
+        }
+
+        dev_set_drvdata(&dev->dev, drvdata);
         return ret;
 
+free_gpio:
+        if (gpio_is_valid(drvdata->rst_gpio))
+                gpio_free(drvdata->rst_gpio);
 release_reg:
         release_mem_region(memory.start, res_len);
+        kfree(drvdata);
         return ret;
 }
 
 static int of_isp1760_remove(struct platform_device *dev)
 {
-        struct usb_hcd *hcd = dev_get_drvdata(&dev->dev);
+        struct isp1760 *drvdata = dev_get_drvdata(&dev->dev);
 
         dev_set_drvdata(&dev->dev, NULL);
 
-        usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
+        usb_remove_hcd(drvdata->hcd);
+        iounmap(drvdata->hcd->regs);
+        release_mem_region(drvdata->hcd->rsrc_start, drvdata->hcd->rsrc_len);
+        usb_put_hcd(drvdata->hcd);
+
+        if (gpio_is_valid(drvdata->rst_gpio))
+                gpio_free(drvdata->rst_gpio);
+
+        kfree(drvdata);
         return 0;
 }
 
@@ -240,7 +280,7 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
 
         dev->dev.dma_mask = NULL;
         hcd = isp1760_register(pci_mem_phy0, memlength, dev->irq,
-                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
+                IRQF_SHARED, -ENOENT, &dev->dev, dev_name(&dev->dev),
                 devflags);
         if (IS_ERR(hcd)) {
                 ret_status = -ENODEV;
@@ -313,7 +353,7 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         resource_size_t mem_size;
         struct isp1760_platform_data *priv = pdev->dev.platform_data;
         unsigned int devflags = 0;
-        unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED;
+        unsigned long irqflags = IRQF_SHARED;
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!mem_res) {
@@ -351,7 +391,8 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         }
 
         hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
-                               irqflags, &pdev->dev, dev_name(&pdev->dev), devflags);
+                               irqflags, -ENOENT,
+                               &pdev->dev, dev_name(&pdev->dev), devflags);
         if (IS_ERR(hcd)) {
                 pr_warning("isp1760: Failed to register the HCD device\n");
                 ret = -ENODEV;
@@ -396,7 +437,7 @@ static int __init isp1760_init(void)
         ret = platform_driver_register(&isp1760_plat_driver);
         if (!ret)
                 any_ret = 0;
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_OF
         ret = platform_driver_register(&isp1760_of_driver);
         if (!ret)
                 any_ret = 0;
@@ -416,7 +457,7 @@ module_init(isp1760_init);
 static void __exit isp1760_exit(void)
 {
         platform_driver_unregister(&isp1760_plat_driver);
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_OF
         platform_driver_unregister(&isp1760_of_driver);
 #endif
 #ifdef CONFIG_PCI
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 944291e10f97..95a9fec38e89 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -35,8 +35,7 @@ extern int usb_disabled(void);
 
 static void at91_start_clock(void)
 {
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
-                clk_enable(hclk);
+        clk_enable(hclk);
         clk_enable(iclk);
         clk_enable(fclk);
         clocked = 1;
@@ -46,8 +45,7 @@ static void at91_stop_clock(void)
 {
         clk_disable(fclk);
         clk_disable(iclk);
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
-                clk_disable(hclk);
+        clk_disable(hclk);
         clocked = 0;
 }
 
@@ -142,8 +140,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
 
         iclk = clk_get(&pdev->dev, "ohci_clk");
         fclk = clk_get(&pdev->dev, "uhpck");
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
-                hclk = clk_get(&pdev->dev, "hck0");
+        hclk = clk_get(&pdev->dev, "hclk");
 
         at91_start_hc(pdev);
         ohci_hcd_init(hcd_to_ohci(hcd));
@@ -155,8 +152,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         /* Error handling */
         at91_stop_hc(pdev);
 
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
-                clk_put(hclk);
+        clk_put(hclk);
         clk_put(fclk);
         clk_put(iclk);
 
@@ -192,8 +188,7 @@ static void usb_hcd_at91_remove(struct usb_hcd *hcd,
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
-                clk_put(hclk);
+        clk_put(hclk);
         clk_put(fclk);
         clk_put(iclk);
         fclk = iclk = hclk = NULL;
@@ -223,6 +218,162 @@ ohci_at91_start (struct usb_hcd *hcd)
         return 0;
 }
 
+static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
+{
+        if (port < 0 || port >= 2)
+                return;
+
+        if (pdata->vbus_pin[port] <= 0)
+                return;
+
+        gpio_set_value(pdata->vbus_pin[port], !pdata->vbus_pin_inverted ^ enable);
+}
+
+static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
+{
+        if (port < 0 || port >= 2)
+                return -EINVAL;
+
+        if (pdata->vbus_pin[port] <= 0)
+                return -EINVAL;
+
+        return gpio_get_value(pdata->vbus_pin[port]) ^ !pdata->vbus_pin_inverted;
+}
+
+/*
+ * Update the status data from the hub with the over-current indicator change.
+ */
+static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
+        int length = ohci_hub_status_data(hcd, buf);
+        int port;
+
+        for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
+                if (pdata->overcurrent_changed[port]) {
+                        if (! length)
+                                length = 1;
+                        buf[0] |= 1 << (port + 1);
+                }
+        }
+
+        return length;
+}
+
+/*
+ * Look at the control requests to the root hub and see if we need to override.
+ */
+static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                 u16 wIndex, char *buf, u16 wLength)
+{
+        struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
+        struct usb_hub_descriptor *desc;
+        int ret = -EINVAL;
+        u32 *data = (u32 *)buf;
+
+        dev_dbg(hcd->self.controller,
+                "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
+                hcd, typeReq, wValue, wIndex, buf, wLength);
+
+        switch (typeReq) {
+        case SetPortFeature:
+                if (wValue == USB_PORT_FEAT_POWER) {
+                        dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
+                        ohci_at91_usb_set_power(pdata, wIndex - 1, 1);
+                        goto out;
+                }
+                break;
+
+        case ClearPortFeature:
+                switch (wValue) {
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        dev_dbg(hcd->self.controller,
+                                "ClearPortFeature: C_OVER_CURRENT\n");
+
+                        if (wIndex == 1 || wIndex == 2) {
+                                pdata->overcurrent_changed[wIndex-1] = 0;
+                                pdata->overcurrent_status[wIndex-1] = 0;
+                        }
+
+                        goto out;
+
+                case USB_PORT_FEAT_OVER_CURRENT:
+                        dev_dbg(hcd->self.controller,
+                                "ClearPortFeature: OVER_CURRENT\n");
+
+                        if (wIndex == 1 || wIndex == 2) {
+                                pdata->overcurrent_status[wIndex-1] = 0;
+                        }
+
+                        goto out;
+
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(hcd->self.controller,
+                                "ClearPortFeature: POWER\n");
+
+                        if (wIndex == 1 || wIndex == 2) {
+                                ohci_at91_usb_set_power(pdata, wIndex - 1, 0);
+                                return 0;
+                        }
+                }
+                break;
+        }
+
+        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        if (ret)
+                goto out;
+
+        switch (typeReq) {
+        case GetHubDescriptor:
+
+                /* update the hub's descriptor */
+
+                desc = (struct usb_hub_descriptor *)buf;
+
+                dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
+                        desc->wHubCharacteristics);
+
+                /* remove the old configurations for power-switching, and
+                 * over-current protection, and insert our new configuration
+                 */
+
+                desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
+                desc->wHubCharacteristics |= cpu_to_le16(0x0001);
+
+                if (pdata->overcurrent_supported) {
+                        desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
+                        desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
+                }
+
+                dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
+                        desc->wHubCharacteristics);
+
+                return ret;
+
+        case GetPortStatus:
+                /* check port status */
+
+                dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
+
+                if (wIndex == 1 || wIndex == 2) {
+                        if (! ohci_at91_usb_get_power(pdata, wIndex-1)) {
+                                *data &= ~cpu_to_le32(RH_PS_PPS);
+                        }
+
+                        if (pdata->overcurrent_changed[wIndex-1]) {
+                                *data |= cpu_to_le32(RH_PS_OCIC);
+                        }
+
+                        if (pdata->overcurrent_status[wIndex-1]) {
+                                *data |= cpu_to_le32(RH_PS_POCI);
+                        }
+                }
+        }
+
+ out:
+        return ret;
+}
+
 /*-------------------------------------------------------------------------*/
 
 static const struct hc_driver ohci_at91_hc_driver = {
@@ -258,8 +409,8 @@ static const struct hc_driver ohci_at91_hc_driver = {
         /*
          * root hub support
          */
-        .hub_status_data =      ohci_hub_status_data,
-        .hub_control =          ohci_hub_control,
+        .hub_status_data =      ohci_at91_hub_status_data,
+        .hub_control =          ohci_at91_hub_control,
 #ifdef CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
@@ -269,22 +420,71 @@ static const struct hc_driver ohci_at91_hc_driver = {
 
 /*-------------------------------------------------------------------------*/
 
+static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
+{
+        struct platform_device *pdev = data;
+        struct at91_usbh_data *pdata = pdev->dev.platform_data;
+        int val, gpio, port;
+
+        /* From the GPIO notifying the over-current situation, find
+         * out the corresponding port */
+        gpio = irq_to_gpio(irq);
+        for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
+                if (pdata->overcurrent_pin[port] == gpio)
+                        break;
+        }
+
+        if (port == ARRAY_SIZE(pdata->overcurrent_pin)) {
+                dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
+                return IRQ_HANDLED;
+        }
+
+        val = gpio_get_value(gpio);
+
+        /* When notified of an over-current situation, disable power
+           on the corresponding port, and mark this port in
+           over-current. */
+        if (! val) {
+                ohci_at91_usb_set_power(pdata, port, 0);
+                pdata->overcurrent_status[port]  = 1;
+                pdata->overcurrent_changed[port] = 1;
+        }
+
+        dev_dbg(& pdev->dev, "overcurrent situation %s\n",
+                val ? "exited" : "notified");
+
+        return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
 {
         struct at91_usbh_data   *pdata = pdev->dev.platform_data;
         int                     i;
 
         if (pdata) {
-                /* REVISIT make the driver support per-port power switching,
-                 * and also overcurrent detection.  Here we assume the ports
-                 * are always powered while this driver is active, and use
-                 * active-low power switches.
-                 */
                 for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
                         if (pdata->vbus_pin[i] <= 0)
                                 continue;
                         gpio_request(pdata->vbus_pin[i], "ohci_vbus");
-                        gpio_direction_output(pdata->vbus_pin[i], 0);
+                        ohci_at91_usb_set_power(pdata, i, 1);
+                }
+
+                for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
+                        int ret;
+
+                        if (pdata->overcurrent_pin[i] <= 0)
+                                continue;
+                        gpio_request(pdata->overcurrent_pin[i], "ohci_overcurrent");
+
+                        ret = request_irq(gpio_to_irq(pdata->overcurrent_pin[i]),
+                                          ohci_hcd_at91_overcurrent_irq,
+                                          IRQF_SHARED, "ohci_overcurrent", pdev);
+                        if (ret) {
+                                gpio_free(pdata->overcurrent_pin[i]);
+                                dev_warn(& pdev->dev, "cannot get GPIO IRQ for overcurrent\n");
+                        }
                 }
         }
 
@@ -301,9 +501,16 @@ static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
                 for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
                         if (pdata->vbus_pin[i] <= 0)
                                 continue;
-                        gpio_direction_output(pdata->vbus_pin[i], 1);
+                        ohci_at91_usb_set_power(pdata, i, 0);
                         gpio_free(pdata->vbus_pin[i]);
                 }
+
+                for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
+                        if (pdata->overcurrent_pin[i] <= 0)
+                                continue;
+                        free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
+                        gpio_free(pdata->overcurrent_pin[i]);
+                }
         }
 
         device_init_wakeup(&pdev->dev, 0);
diff --git a/drivers/usb/host/ohci-ath79.c b/drivers/usb/host/ohci-ath79.c
index c620c50f6770..18d574d6958b 100644
--- a/drivers/usb/host/ohci-ath79.c
+++ b/drivers/usb/host/ohci-ath79.c
@@ -111,7 +111,7 @@ static int ohci_ath79_probe(struct platform_device *pdev)
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, 0);
         if (ret)
                 goto err_stop_hcd;
 
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 958d985f2951..9b66df8278f3 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -23,92 +23,9 @@
 
 #include <asm/mach-au1x00/au1000.h>
 
-#ifndef CONFIG_SOC_AU1200
-
-#define USBH_ENABLE_BE (1<<0)
-#define USBH_ENABLE_C  (1<<1)
-#define USBH_ENABLE_E  (1<<2)
-#define USBH_ENABLE_CE (1<<3)
-#define USBH_ENABLE_RD (1<<4)
-
-#ifdef __LITTLE_ENDIAN
-#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C)
-#elif defined(__BIG_ENDIAN)
-#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C | \
-                          USBH_ENABLE_BE)
-#else
-#error not byte order defined
-#endif
-
-#else   /* Au1200 */
-
-#define USB_HOST_CONFIG    (USB_MSR_BASE + USB_MSR_MCFG)
-#define USB_MCFG_PFEN     (1<<31)
-#define USB_MCFG_RDCOMB   (1<<30)
-#define USB_MCFG_SSDEN    (1<<23)
-#define USB_MCFG_OHCCLKEN (1<<16)
-#ifdef CONFIG_DMA_COHERENT
-#define USB_MCFG_UCAM     (1<<7)
-#else
-#define USB_MCFG_UCAM     (0)
-#endif
-#define USB_MCFG_OBMEN    (1<<1)
-#define USB_MCFG_OMEMEN   (1<<0)
-
-#define USBH_ENABLE_CE    USB_MCFG_OHCCLKEN
-
-#define USBH_ENABLE_INIT  (USB_MCFG_PFEN  | USB_MCFG_RDCOMB     |       \
-                           USBH_ENABLE_CE | USB_MCFG_SSDEN      |       \
-                           USB_MCFG_UCAM  |                             \
-                           USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
-
-#define USBH_DISABLE      (USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
-
-#endif  /* Au1200 */
 
 extern int usb_disabled(void);
 
-static void au1xxx_start_ohc(void)
-{
-        /* enable host controller */
-#ifndef CONFIG_SOC_AU1200
-        au_writel(USBH_ENABLE_CE, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-
-        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-
-        /* wait for reset complete (read register twice; see au1500 errata) */
-        while (au_readl(USB_HOST_CONFIG),
-                !(au_readl(USB_HOST_CONFIG) & USBH_ENABLE_RD))
-                udelay(1000);
-
-#else   /* Au1200 */
-        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_CE, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-
-        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
-        au_sync();
-        udelay(2000);
-#endif  /* Au1200 */
-}
-
-static void au1xxx_stop_ohc(void)
-{
-#ifdef CONFIG_SOC_AU1200
-        /* Disable mem */
-        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_DISABLE, USB_HOST_CONFIG);
-        au_sync();
-        udelay(1000);
-#endif
-        /* Disable clock */
-        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_ENABLE_CE, USB_HOST_CONFIG);
-        au_sync();
-}
-
 static int __devinit ohci_au1xxx_start(struct usb_hcd *hcd)
 {
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
@@ -178,17 +95,6 @@ static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         if (usb_disabled())
                 return -ENODEV;
 
-#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
-        /* Au1200 AB USB does not support coherent memory */
-        if (!(read_c0_prid() & 0xff)) {
-                printk(KERN_INFO "%s: this is chip revision AB !!\n",
-                        pdev->name);
-                printk(KERN_INFO "%s: update your board or re-configure "
-                                 "the kernel\n", pdev->name);
-                return -ENODEV;
-        }
-#endif
-
         if (pdev->resource[1].flags != IORESOURCE_IRQ) {
                 pr_debug("resource[1] is not IORESOURCE_IRQ\n");
                 return -ENOMEM;
@@ -214,17 +120,23 @@ static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        au1xxx_start_ohc();
+        if (alchemy_usb_control(ALCHEMY_USB_OHCI0, 1)) {
+                printk(KERN_INFO "%s: controller init failed!\n", pdev->name);
+                ret = -ENODEV;
+                goto err3;
+        }
+
         ohci_hcd_init(hcd_to_ohci(hcd));
 
         ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                          IRQF_DISABLED | IRQF_SHARED);
+                          IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
                 return ret;
         }
 
-        au1xxx_stop_ohc();
+        alchemy_usb_control(ALCHEMY_USB_OHCI0, 0);
+err3:
         iounmap(hcd->regs);
 err2:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
@@ -238,7 +150,7 @@ static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        au1xxx_stop_ohc();
+        alchemy_usb_control(ALCHEMY_USB_OHCI0, 0);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
@@ -275,7 +187,7 @@ static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
-        au1xxx_stop_ohc();
+        alchemy_usb_control(ALCHEMY_USB_OHCI0, 0);
 bail:
         spin_unlock_irqrestore(&ohci->lock, flags);
 
@@ -286,7 +198,7 @@ static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
 
-        au1xxx_start_ohc();
+        alchemy_usb_control(ALCHEMY_USB_OHCI0, 1);
 
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
         ohci_finish_controller_resume(hcd);
diff --git a/drivers/usb/host/ohci-da8xx.c b/drivers/usb/host/ohci-da8xx.c
index 6aca2c4453f7..843509778a33 100644
--- a/drivers/usb/host/ohci-da8xx.c
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -344,7 +344,7 @@ static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
                 error = -ENODEV;
                 goto err4;
         }
-        error = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        error = usb_add_hcd(hcd, irq, 0);
         if (error)
                 goto err4;
 
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index 4e681613e7ae..dc45d489d00e 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -81,7 +81,7 @@ static int usb_hcd_ep93xx_probe(const struct hc_driver *driver,
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, pdev->resource[1].start, 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index f9cf3f04b742..b2639191549e 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -389,17 +389,14 @@ ohci_shutdown (struct usb_hcd *hcd)
         struct ohci_hcd *ohci;
 
         ohci = hcd_to_ohci (hcd);
-        ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
-        ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
+        ohci_writel(ohci, (u32) ~0, &ohci->regs->intrdisable);
 
-        /* If the SHUTDOWN quirk is set, don't put the controller in RESET */
-        ohci->hc_control &= (ohci->flags & OHCI_QUIRK_SHUTDOWN ?
-                        OHCI_CTRL_RWC | OHCI_CTRL_HCFS :
-                        OHCI_CTRL_RWC);
-        ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
+        /* Software reset, after which the controller goes into SUSPEND */
+        ohci_writel(ohci, OHCI_HCR, &ohci->regs->cmdstatus);
+        ohci_readl(ohci, &ohci->regs->cmdstatus);       /* flush the writes */
+        udelay(10);
 
-        /* flush the writes */
-        (void) ohci_readl (ohci, &ohci->regs->control);
+        ohci_writel(ohci, ohci->fminterval, &ohci->regs->fminterval);
 }
 
 static int check_ed(struct ohci_hcd *ohci, struct ed *ed)
@@ -1114,6 +1111,11 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_ath79_driver
 #endif
 
+#ifdef CONFIG_NLM_XLR
+#include "ohci-xls.c"
+#define PLATFORM_DRIVER         ohci_xls_driver
+#endif
+
 #if     !defined(PCI_DRIVER) &&         \
         !defined(PLATFORM_DRIVER) &&    \
         !defined(OMAP1_PLATFORM_DRIVER) &&      \
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 9154615292db..2f00040fc408 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -356,10 +356,7 @@ static void ohci_finish_controller_resume(struct usb_hcd *hcd)
                 msleep(20);
         }
 
-        /* Does the root hub have a port wakeup pending? */
-        if (ohci_readl(ohci, &ohci->regs->intrstatus) &
-                        (OHCI_INTR_RD | OHCI_INTR_RHSC))
-                usb_hcd_resume_root_hub(hcd);
+        usb_hcd_resume_root_hub(hcd);
 }
 
 /* Carry out polling-, autostop-, and autoresume-related state changes */
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
index d8b45647d1dc..d469bf9b9e54 100644
--- a/drivers/usb/host/ohci-octeon.c
+++ b/drivers/usb/host/ohci-octeon.c
@@ -164,7 +164,7 @@ static int ohci_octeon_drv_probe(struct platform_device *pdev)
 
         ohci_hcd_init(ohci);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret) {
                 dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
                 goto err3;
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 5645f70b9214..e4b8782cc6e2 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -14,7 +14,7 @@
  * This file is licenced under the GPL.
  */
 
-#include <linux/signal.h>       /* IRQF_DISABLED */
+#include <linux/signal.h>
 #include <linux/jiffies.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
@@ -363,7 +363,7 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
                 retval = -ENXIO;
                 goto err3;
         }
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, irq, 0);
         if (retval)
                 goto err3;
 
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index 6048f2f64f73..516ebc4d6cc2 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -149,7 +149,7 @@ static int __devinit ohci_hcd_omap3_probe(struct platform_device *pdev)
 
         res = platform_get_resource_byname(pdev,
                                 IORESOURCE_MEM, "ohci");
-        if (!ret) {
+        if (!res) {
                 dev_err(dev, "UHH OHCI get resource failed\n");
                 return -ENOMEM;
         }
@@ -180,7 +180,7 @@ static int __devinit ohci_hcd_omap3_probe(struct platform_device *pdev)
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, 0);
         if (ret) {
                 dev_dbg(dev, "failed to add hcd with err %d\n", ret);
                 goto err_add_hcd;
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index ad8166c681e2..bc01b064585a 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -175,28 +175,6 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
         return 0;
 }
 
-/* nVidia controllers continue to drive Reset signalling on the bus
- * even after system shutdown, wasting power.  This flag tells the
- * shutdown routine to leave the controller OPERATIONAL instead of RESET.
- */
-static int ohci_quirk_nvidia_shutdown(struct usb_hcd *hcd)
-{
-        struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-
-        /* Evidently nVidia fixed their later hardware; this is a guess at
-         * the changeover point.
-         */
-#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB           0x026d
-
-        if (pdev->device < PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB) {
-                ohci->flags |= OHCI_QUIRK_SHUTDOWN;
-                ohci_dbg(ohci, "enabled nVidia shutdown quirk\n");
-        }
-
-        return 0;
-}
-
 static void sb800_prefetch(struct ohci_hcd *ohci, int on)
 {
         struct pci_dev *pdev;
@@ -260,10 +238,6 @@ static const struct pci_device_id ohci_pci_quirks[] = {
                 PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4399),
                 .driver_data = (unsigned long)ohci_quirk_amd700,
         },
-        {
-                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
-                .driver_data = (unsigned long) ohci_quirk_nvidia_shutdown,
-        },
 
         /* FIXME for some of the early AMD 760 southbridges, OHCI
          * won't work at all.  blacklist them.
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 653d6a60edb5..0013db7bdf92 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -26,7 +26,7 @@
 
 #include <mach/platform.h>
 #include <mach/irqs.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #define USB_CTRL        IO_ADDRESS(PNX4008_PWRMAN_BASE + 0x64)
 
@@ -398,7 +398,7 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
         ohci_hcd_init(ohci);
 
         dev_info(&pdev->dev, "at 0x%p, irq %d\n", hcd->regs, hcd->irq);
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, 0);
         if (ret == 0)
                 return ret;
 
diff --git a/drivers/usb/host/ohci-pnx8550.c b/drivers/usb/host/ohci-pnx8550.c
index 28467e288a93..f13d08f94d6b 100644
--- a/drivers/usb/host/ohci-pnx8550.c
+++ b/drivers/usb/host/ohci-pnx8550.c
@@ -107,7 +107,7 @@ int usb_hcd_pnx8550_probe (const struct hc_driver *driver,
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, dev->resource[1].start, 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 0c12f4e14dcd..d24cc89de16f 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -143,7 +143,7 @@ static int __devinit ohci_hcd_ppc_of_probe(struct platform_device *op)
 
         ohci_hcd_init(ohci);
 
-        rv = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        rv = usb_add_hcd(hcd, irq, 0);
         if (rv == 0)
                 return 0;
 
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index c0f595c44487..1514b7067470 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -80,7 +80,7 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
 #endif
         ohci_hcd_init(ohci);
 
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, irq, 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-ps3.c b/drivers/usb/host/ohci-ps3.c
index 700950455f4d..6fd4fa1f19bb 100644
--- a/drivers/usb/host/ohci-ps3.c
+++ b/drivers/usb/host/ohci-ps3.c
@@ -164,7 +164,7 @@ static int __devinit ps3_ohci_probe(struct ps3_system_bus_device *dev)
 
         ps3_system_bus_set_drvdata(dev, hcd);
 
-        result = usb_add_hcd(hcd, virq, IRQF_DISABLED);
+        result = usb_add_hcd(hcd, virq, 0);
 
         if (result) {
                 dev_dbg(&dev->core, "%s:%d: usb_add_hcd failed (%d)\n",
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 80be5472783a..29dfefe1c726 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -359,7 +359,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, irq, 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index dd24fc115e48..15dc51ded61a 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -428,7 +428,7 @@ static struct ed *ed_get (
                 ed->type = usb_pipetype(pipe);
 
                 info |= (ep->desc.bEndpointAddress & ~USB_DIR_IN) << 7;
-                info |= le16_to_cpu(ep->desc.wMaxPacketSize) << 16;
+                info |= usb_endpoint_maxp(&ep->desc) << 16;
                 if (udev->speed == USB_SPEED_LOW)
                         info |= ED_LOWSPEED;
                 /* only control transfers store pids in tds */
@@ -444,7 +444,7 @@ static struct ed *ed_get (
                                 ed->load = usb_calc_bus_time (
                                         udev->speed, !is_out,
                                         ed->type == PIPE_ISOCHRONOUS,
-                                        le16_to_cpu(ep->desc.wMaxPacketSize))
+                                        usb_endpoint_maxp(&ep->desc))
                                                 / 1000;
                         }
                 }
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index 7c9a4d55526b..a1877c47601e 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -384,7 +384,7 @@ static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, dev->resource[1].start, 0);
         if (retval != 0)
                 goto err_ioremap;
 
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index 4204d9720d23..4bde4f9821ba 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -143,7 +143,7 @@ int usb_hcd_sa1111_probe (const struct hc_driver *driver,
         sa1111_start_hc(dev);
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, dev->irq[1], IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, dev->irq[1], 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index 14cecb52a9fe..afc4eb6bb9d0 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -109,7 +109,7 @@ static int ohci_hcd_sh_probe(struct platform_device *pdev)
         hcd->regs = (void __iomem *)res->start;
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret != 0) {
                 err("Failed to add hcd");
                 usb_put_hcd(hcd);
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 78918ca0da23..968cea2b6d4e 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -165,7 +165,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval)
                 goto err5;
 
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 4fd4bea9ac7a..69874654f3b5 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -152,7 +152,7 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
         spear_start_ohci(ohci_p);
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
index c4aea3b8315e..5ba18595d6f7 100644
--- a/drivers/usb/host/ohci-ssb.c
+++ b/drivers/usb/host/ohci-ssb.c
@@ -169,7 +169,7 @@ static int ssb_ohci_attach(struct ssb_device *dev)
         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs)
                 goto err_put_hcd;
-        err = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
+        err = usb_add_hcd(hcd, dev->irq, IRQF_SHARED);
         if (err)
                 goto err_iounmap;
 
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 57ad1271fc9b..06331d931171 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -244,7 +244,7 @@ static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
         ohci = hcd_to_ohci(hcd);
         ohci_hcd_init(ohci);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, 0);
         if (ret)
                 goto err_add_hcd;
 
diff --git a/drivers/usb/host/ohci-xls.c b/drivers/usb/host/ohci-xls.c
new file mode 100644
index 000000000000..a3a9c6f45b91
--- /dev/null
+++ b/drivers/usb/host/ohci-xls.c
@@ -0,0 +1,151 @@
+/*
+ * OHCI HCD for Netlogic XLS processors.
+ *
+ * (C) Copyright 2011 Netlogic Microsystems Inc.
+ *
+ *  Based on ohci-au1xxx.c, and other Linux OHCI drivers.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/signal.h>
+
+static int ohci_xls_probe_internal(const struct hc_driver *driver,
+                        struct platform_device *dev)
+{
+        struct resource *res;
+        struct usb_hcd *hcd;
+        int retval, irq;
+
+        /* Get our IRQ from an earlier registered Platform Resource */
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
+                dev_err(&dev->dev, "Found HC with no IRQ\n");
+                return -ENODEV;
+        }
+
+        /* Get our Memory Handle */
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&dev->dev, "MMIO Handle incorrect!\n");
+                return -ENODEV;
+        }
+
+        hcd = usb_create_hcd(driver, &dev->dev, "XLS");
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err1;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                        driver->description)) {
+                dev_dbg(&dev->dev, "Controller already in use\n");
+                retval = -EBUSY;
+                goto err2;
+        }
+
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&dev->dev, "error mapping memory\n");
+                retval = -EFAULT;
+                goto err3;
+        }
+
+        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (retval != 0)
+                goto err4;
+        return retval;
+
+err4:
+        iounmap(hcd->regs);
+err3:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err2:
+        usb_put_hcd(hcd);
+err1:
+        dev_err(&dev->dev, "init fail, %d\n", retval);
+        return retval;
+}
+
+static int ohci_xls_reset(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+
+        ohci_hcd_init(ohci);
+        return ohci_init(ohci);
+}
+
+static int __devinit ohci_xls_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci;
+        int ret;
+
+        ohci = hcd_to_ohci(hcd);
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                err("can't start %s", hcd->self.bus_name);
+                ohci_stop(hcd);
+                return ret;
+        }
+        return 0;
+}
+
+static struct hc_driver ohci_xls_hc_driver = {
+        .description    = hcd_name,
+        .product_desc   = "XLS OHCI Host Controller",
+        .hcd_priv_size  = sizeof(struct ohci_hcd),
+        .irq            = ohci_irq,
+        .flags          = HCD_MEMORY | HCD_USB11,
+        .reset          = ohci_xls_reset,
+        .start          = ohci_xls_start,
+        .stop           = ohci_stop,
+        .shutdown       = ohci_shutdown,
+        .urb_enqueue    = ohci_urb_enqueue,
+        .urb_dequeue    = ohci_urb_dequeue,
+        .endpoint_disable = ohci_endpoint_disable,
+        .get_frame_number = ohci_get_frame,
+        .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,
+};
+
+static int ohci_xls_probe(struct platform_device *dev)
+{
+        int ret;
+
+        pr_debug("In ohci_xls_probe");
+        if (usb_disabled())
+                return -ENODEV;
+        ret = ohci_xls_probe_internal(&ohci_xls_hc_driver, dev);
+        return ret;
+}
+
+static int ohci_xls_remove(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        return 0;
+}
+
+static struct platform_driver ohci_xls_driver = {
+        .probe          = ohci_xls_probe,
+        .remove         = ohci_xls_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name   = "ohci-xls-0",
+                .owner  = THIS_MODULE,
+        },
+};
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 35e5fd640ce7..0795b934d00c 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -403,7 +403,6 @@ struct ohci_hcd {
 #define OHCI_QUIRK_HUB_POWER    0x100                   /* distrust firmware power/oc setup */
 #define OHCI_QUIRK_AMD_PLL      0x200                   /* AMD PLL quirk*/
 #define OHCI_QUIRK_AMD_PREFETCH 0x400                   /* pre-fetch for ISO transfer */
-#define OHCI_QUIRK_SHUTDOWN     0x800                   /* nVidia power bug */
         // there are also chip quirks/bugs in init logic
 
         struct work_struct      nec_work;       /* Worker for NEC quirk */
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 629a96813fd6..caf87428ca43 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -13,6 +13,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/export.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include "pci-quirks.h"
@@ -36,6 +37,7 @@
 #define OHCI_INTRENABLE         0x10
 #define OHCI_INTRDISABLE        0x14
 #define OHCI_FMINTERVAL         0x34
+#define OHCI_HCFS               (3 << 6)        /* hc functional state */
 #define OHCI_HCR                (1 << 0)        /* host controller reset */
 #define OHCI_OCR                (1 << 3)        /* ownership change request */
 #define OHCI_CTRL_RWC           (1 << 9)        /* remote wakeup connected */
@@ -465,6 +467,8 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
 {
         void __iomem *base;
         u32 control;
+        u32 fminterval;
+        int cnt;
 
         if (!mmio_resource_enabled(pdev, 0))
                 return;
@@ -497,41 +501,32 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         }
 #endif
 
-        /* reset controller, preserving RWC (and possibly IR) */
-        writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
-        readl(base + OHCI_CONTROL);
+        /* disable interrupts */
+        writel((u32) ~0, base + OHCI_INTRDISABLE);
 
-        /* Some NVIDIA controllers stop working if kept in RESET for too long */
-        if (pdev->vendor == PCI_VENDOR_ID_NVIDIA) {
-                u32 fminterval;
-                int cnt;
+        /* Reset the USB bus, if the controller isn't already in RESET */
+        if (control & OHCI_HCFS) {
+                /* Go into RESET, preserving RWC (and possibly IR) */
+                writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
+                readl(base + OHCI_CONTROL);
 
-                /* drive reset for at least 50 ms (7.1.7.5) */
+                /* drive bus reset for at least 50 ms (7.1.7.5) */
                 msleep(50);
+        }
 
-                /* software reset of the controller, preserving HcFmInterval */
-                fminterval = readl(base + OHCI_FMINTERVAL);
-                writel(OHCI_HCR, base + OHCI_CMDSTATUS);
+        /* software reset of the controller, preserving HcFmInterval */
+        fminterval = readl(base + OHCI_FMINTERVAL);
+        writel(OHCI_HCR, base + OHCI_CMDSTATUS);
 
-                /* reset requires max 10 us delay */
-                for (cnt = 30; cnt > 0; --cnt) {        /* ... allow extra time */
-                        if ((readl(base + OHCI_CMDSTATUS) & OHCI_HCR) == 0)
-                                break;
-                        udelay(1);
-                }
-                writel(fminterval, base + OHCI_FMINTERVAL);
-
-                /* Now we're in the SUSPEND state with all devices reset
-                 * and wakeups and interrupts disabled
-                 */
+        /* reset requires max 10 us delay */
+        for (cnt = 30; cnt > 0; --cnt) {        /* ... allow extra time */
+                if ((readl(base + OHCI_CMDSTATUS) & OHCI_HCR) == 0)
+                        break;
+                udelay(1);
         }
+        writel(fminterval, base + OHCI_FMINTERVAL);
 
-        /*
-         * disable interrupts
-         */
-        writel(~(u32)0, base + OHCI_INTRDISABLE);
-        writel(~(u32)0, base + OHCI_INTRSTATUS);
-
+        /* Now the controller is safely in SUSPEND and nothing can wake it up */
         iounmap(base);
 }
 
@@ -626,7 +621,7 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
         void __iomem *base, *op_reg_base;
         u32     hcc_params, cap, val;
         u8      offset, cap_length;
-        int     wait_time, delta, count = 256/4;
+        int     wait_time, count = 256/4;
 
         if (!mmio_resource_enabled(pdev, 0))
                 return;
@@ -672,11 +667,10 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
                 writel(val, op_reg_base + EHCI_USBCMD);
 
                 wait_time = 2000;
-                delta = 100;
                 do {
                         writel(0x3f, op_reg_base + EHCI_USBSTS);
-                        udelay(delta);
-                        wait_time -= delta;
+                        udelay(100);
+                        wait_time -= 100;
                         val = readl(op_reg_base + EHCI_USBSTS);
                         if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
                                 break;
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 40a0d8b03ad7..e84ca1928dbf 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -959,7 +959,7 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
         info.pipenum = get_empty_pipenum(r8a66597, ep);
         info.address = get_urb_to_r8a66597_addr(r8a66597, urb);
         info.epnum = usb_endpoint_num(ep);
-        info.maxpacket = le16_to_cpu(ep->wMaxPacketSize);
+        info.maxpacket = usb_endpoint_maxp(ep);
         info.type = get_r8a66597_type(usb_endpoint_type(ep));
         info.bufnum = get_bufnum(info.pipenum);
         info.buf_bsize = get_buf_bsize(info.pipenum);
@@ -2519,7 +2519,7 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->has_tt = 1;
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
+        ret = usb_add_hcd(hcd, irq, irq_trigger);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to add hcd\n");
                 goto clean_up3;
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 1a996245ab98..961d6638d8f9 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1729,7 +1729,7 @@ sl811h_probe(struct platform_device *dev)
          * Use resource IRQ flags if set by platform device setup.
          */
         irqflags |= IRQF_SHARED;
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | irqflags);
+        retval = usb_add_hcd(hcd, irq, irqflags);
         if (retval != 0)
                 goto err6;
 
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index fba99b120588..c8ae199cfbb8 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -294,50 +294,50 @@ __acquires(uhci->lock)
          * and that remote wakeups should be enabled.
          */
         egsm_enable = USBCMD_EGSM;
-        uhci->RD_enable = 1;
         int_enable = USBINTR_RESUME;
         wakeup_enable = 1;
 
-        /* In auto-stop mode wakeups must always be detected, but
-         * Resume-Detect interrupts may be prohibited.  (In the absence
-         * of CONFIG_PM, they are always disallowed.)
+        /*
+         * In auto-stop mode, we must be able to detect new connections.
+         * The user can force us to poll by disabling remote wakeup;
+         * otherwise we will use the EGSM/RD mechanism.
          */
         if (auto_stop) {
                 if (!device_may_wakeup(&rhdev->dev))
-                        int_enable = 0;
+                        egsm_enable = int_enable = 0;
+        }
 
-        /* In bus-suspend mode wakeups may be disabled, but if they are
-         * allowed then so are Resume-Detect interrupts.
-         */
-        } else {
 #ifdef CONFIG_PM
+        /*
+         * In bus-suspend mode, we use the wakeup setting specified
+         * for the root hub.
+         */
+        else {
                 if (!rhdev->do_remote_wakeup)
                         wakeup_enable = 0;
-#endif
         }
+#endif
 
-        /* EGSM causes the root hub to echo a 'K' signal (resume) out any
-         * port which requests a remote wakeup.  According to the USB spec,
-         * every hub is supposed to do this.  But if we are ignoring
-         * remote-wakeup requests anyway then there's no point to it.
-         * We also shouldn't enable EGSM if it's broken.
-         */
-        if (!wakeup_enable || global_suspend_mode_is_broken(uhci))
-                egsm_enable = 0;
-
-        /* If we're ignoring wakeup events then there's no reason to
-         * enable Resume-Detect interrupts.  We also shouldn't enable
-         * them if they are broken or disallowed.
+        /*
+         * UHCI doesn't distinguish between wakeup requests from downstream
+         * devices and local connect/disconnect events.  There's no way to
+         * enable one without the other; both are controlled by EGSM.  Thus
+         * if wakeups are disallowed then EGSM must be turned off -- in which
+         * case remote wakeup requests from downstream during system sleep
+         * will be lost.
+         *
+         * In addition, if EGSM is broken then we can't use it.  Likewise,
+         * if Resume-Detect interrupts are broken then we can't use them.
          *
-         * This logic may lead us to enabling RD but not EGSM.  The UHCI
-         * spec foolishly says that RD works only when EGSM is on, but
-         * there's no harm in enabling it anyway -- perhaps some chips
-         * will implement it!
+         * Finally, neither EGSM nor RD is useful by itself.  Without EGSM,
+         * the RD status bit will never get set.  Without RD, the controller
+         * won't generate interrupts to tell the system about wakeup events.
          */
-        if (!wakeup_enable || resume_detect_interrupts_are_broken(uhci) ||
-                        !int_enable)
-                uhci->RD_enable = int_enable = 0;
+        if (!wakeup_enable || global_suspend_mode_is_broken(uhci) ||
+                        resume_detect_interrupts_are_broken(uhci))
+                egsm_enable = int_enable = 0;
 
+        uhci->RD_enable = !!int_enable;
         uhci_writew(uhci, int_enable, USBINTR);
         uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
         mb();
@@ -364,10 +364,12 @@ __acquires(uhci->lock)
         uhci->rh_state = new_state;
         uhci->is_stopped = UHCI_IS_STOPPED;
 
-        /* If interrupts don't work and remote wakeup is enabled then
-         * the suspended root hub needs to be polled.
+        /*
+         * If remote wakeup is enabled but either EGSM or RD interrupts
+         * doesn't work, then we won't get an interrupt when a wakeup event
+         * occurs.  Thus the suspended root hub needs to be polled.
          */
-        if (!int_enable && wakeup_enable)
+        if (wakeup_enable && (!int_enable || !egsm_enable))
                 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
         else
                 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 84ed28b34f93..f6ca80ee4cec 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -280,7 +280,7 @@ static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
                         qh->load = usb_calc_bus_time(udev->speed,
                                         usb_endpoint_dir_in(&hep->desc),
                                         qh->type == USB_ENDPOINT_XFER_ISOC,
-                                        le16_to_cpu(hep->desc.wMaxPacketSize))
+                                        usb_endpoint_maxp(&hep->desc))
                                 / 1000 + 1;
 
         } else {                /* Skeleton QH */
@@ -792,7 +792,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
 {
         struct uhci_td *td;
         unsigned long destination, status;
-        int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
+        int maxsze = usb_endpoint_maxp(&qh->hep->desc);
         int len = urb->transfer_buffer_length;
         dma_addr_t data = urb->transfer_dma;
         __hc32 *plink;
@@ -918,7 +918,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
 {
         struct uhci_td *td;
         unsigned long destination, status;
-        int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
+        int maxsze = usb_endpoint_maxp(&qh->hep->desc);
         int len = urb->transfer_buffer_length;
         int this_sg_len;
         dma_addr_t data;
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c
index 767af265e002..ba61dae9e4d2 100644
--- a/drivers/usb/host/whci/debug.c
+++ b/drivers/usb/host/whci/debug.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
+#include <linux/export.h>
 
 #include "../../wusbcore/wusbhc.h"
 
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 9546f6cd01f0..1e141f755b26 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -17,6 +17,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/module.h>
 #include <linux/uwb/umc.h>
 
 #include "../../wusbcore/wusbhc.h"
diff --git a/drivers/usb/host/xhci-ext-caps.h b/drivers/usb/host/xhci-ext-caps.h
index ce5c9e51748e..c7f33123d4c0 100644
--- a/drivers/usb/host/xhci-ext-caps.h
+++ b/drivers/usb/host/xhci-ext-caps.h
@@ -65,6 +65,12 @@
 /* bits 1:2, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */
 #define XHCI_LEGACY_DISABLE_SMI         ((0x3 << 1) + (0xff << 5) + (0x7 << 17))
 
+/* USB 2.0 xHCI 0.96 L1C capability - section 7.2.2.1.3.2 */
+#define XHCI_L1C               (1 << 16)
+
+/* USB 2.0 xHCI 1.0 hardware LMP capability - section 7.2.2.1.3.2 */
+#define XHCI_HLC               (1 << 19)
+
 /* command register values to disable interrupts and halt the HC */
 /* start/stop HC execution - do not write unless HC is halted*/
 #define XHCI_CMD_RUN            (1 << 0)
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 1e96d1f1fe6b..430e88fd3f6c 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -20,6 +20,7 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/gfp.h>
 #include <asm/unaligned.h>
 
 #include "xhci.h"
@@ -28,6 +29,25 @@
 #define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
                          PORT_RC | PORT_PLC | PORT_PE)
 
+/* usb 1.1 root hub device descriptor */
+static u8 usb_bos_descriptor [] = {
+        USB_DT_BOS_SIZE,                /*  __u8 bLength, 5 bytes */
+        USB_DT_BOS,                     /*  __u8 bDescriptorType */
+        0x0F, 0x00,                     /*  __le16 wTotalLength, 15 bytes */
+        0x1,                            /*  __u8 bNumDeviceCaps */
+        /* First device capability */
+        USB_DT_USB_SS_CAP_SIZE,         /*  __u8 bLength, 10 bytes */
+        USB_DT_DEVICE_CAPABILITY,       /* Device Capability */
+        USB_SS_CAP_TYPE,                /* bDevCapabilityType, SUPERSPEED_USB */
+        0x00,                           /* bmAttributes, LTM off by default */
+        USB_5GBPS_OPERATION, 0x00,      /* wSpeedsSupported, 5Gbps only */
+        0x03,                           /* bFunctionalitySupport,
+                                           USB 3.0 speed only */
+        0x00,                           /* bU1DevExitLat, set later. */
+        0x00, 0x00                      /* __le16 bU2DevExitLat, set later. */
+};
+
+
 static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
                 struct usb_hub_descriptor *desc, int ports)
 {
@@ -232,7 +252,7 @@ int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
                         continue;
                 speed = xhci->devs[i]->udev->speed;
                 if (((speed == USB_SPEED_SUPER) == (hcd->speed == HCD_USB3))
-                                && xhci->devs[i]->port == port) {
+                                && xhci->devs[i]->fake_port == port) {
                         slot_id = i;
                         break;
                 }
@@ -392,13 +412,39 @@ static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
         return max_ports;
 }
 
+void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 link_state)
+{
+        u32 temp;
+
+        temp = xhci_readl(xhci, port_array[port_id]);
+        temp = xhci_port_state_to_neutral(temp);
+        temp &= ~PORT_PLS_MASK;
+        temp |= PORT_LINK_STROBE | link_state;
+        xhci_writel(xhci, temp, port_array[port_id]);
+}
+
+/* Test and clear port RWC bit */
+void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 port_bit)
+{
+        u32 temp;
+
+        temp = xhci_readl(xhci, port_array[port_id]);
+        if (temp & port_bit) {
+                temp = xhci_port_state_to_neutral(temp);
+                temp |= port_bit;
+                xhci_writel(xhci, temp, port_array[port_id]);
+        }
+}
+
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 u16 wIndex, char *buf, u16 wLength)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         int max_ports;
         unsigned long flags;
-        u32 temp, temp1, status;
+        u32 temp, status;
         int retval = 0;
         __le32 __iomem **port_array;
         int slot_id;
@@ -429,6 +475,21 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 xhci_hub_descriptor(hcd, xhci,
                                 (struct usb_hub_descriptor *) buf);
                 break;
+        case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
+                if ((wValue & 0xff00) != (USB_DT_BOS << 8))
+                        goto error;
+
+                if (hcd->speed != HCD_USB3)
+                        goto error;
+
+                memcpy(buf, &usb_bos_descriptor,
+                                USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);
+                temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
+                buf[12] = HCS_U1_LATENCY(temp);
+                put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
+
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;
         case GetPortStatus:
                 if (!wIndex || wIndex > max_ports)
                         goto error;
@@ -472,11 +533,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 xhci_dbg(xhci, "Resume USB2 port %d\n",
                                         wIndex + 1);
                                 bus_state->resume_done[wIndex] = 0;
-                                temp1 = xhci_port_state_to_neutral(temp);
-                                temp1 &= ~PORT_PLS_MASK;
-                                temp1 |= PORT_LINK_STROBE | XDEV_U0;
-                                xhci_writel(xhci, temp1, port_array[wIndex]);
-
+                                xhci_set_link_state(xhci, port_array, wIndex,
+                                                        XDEV_U0);
                                 xhci_dbg(xhci, "set port %d resume\n",
                                         wIndex + 1);
                                 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
@@ -551,10 +609,19 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
                         temp = xhci_readl(xhci, port_array[wIndex]);
+                        if ((temp & PORT_PLS_MASK) != XDEV_U0) {
+                                /* Resume the port to U0 first */
+                                xhci_set_link_state(xhci, port_array, wIndex,
+                                                        XDEV_U0);
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                msleep(10);
+                                spin_lock_irqsave(&xhci->lock, flags);
+                        }
                         /* In spec software should not attempt to suspend
                          * a port unless the port reports that it is in the
                          * enabled (PED = ‘1’,PLS < ‘3’) state.
                          */
+                        temp = xhci_readl(xhci, port_array[wIndex]);
                         if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
                                 || (temp & PORT_PLS_MASK) >= XDEV_U3) {
                                 xhci_warn(xhci, "USB core suspending device "
@@ -573,10 +640,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         xhci_stop_device(xhci, slot_id, 1);
                         spin_lock_irqsave(&xhci->lock, flags);
 
-                        temp = xhci_port_state_to_neutral(temp);
-                        temp &= ~PORT_PLS_MASK;
-                        temp |= PORT_LINK_STROBE | XDEV_U3;
-                        xhci_writel(xhci, temp, port_array[wIndex]);
+                        xhci_set_link_state(xhci, port_array, wIndex, XDEV_U3);
 
                         spin_unlock_irqrestore(&xhci->lock, flags);
                         msleep(10); /* wait device to enter */
@@ -610,10 +674,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 }
                         }
 
-                        temp = xhci_port_state_to_neutral(temp);
-                        temp &= ~PORT_PLS_MASK;
-                        temp |= PORT_LINK_STROBE | link_state;
-                        xhci_writel(xhci, temp, port_array[wIndex]);
+                        xhci_set_link_state(xhci, port_array, wIndex,
+                                                link_state);
 
                         spin_unlock_irqrestore(&xhci->lock, flags);
                         msleep(20); /* wait device to enter */
@@ -677,24 +739,13 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 if ((temp & PORT_PE) == 0)
                                         goto error;
 
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp &= ~PORT_PLS_MASK;
-                                temp |= PORT_LINK_STROBE | XDEV_RESUME;
-                                xhci_writel(xhci, temp,
-                                                port_array[wIndex]);
-
-                                spin_unlock_irqrestore(&xhci->lock,
-                                                       flags);
+                                xhci_set_link_state(xhci, port_array, wIndex,
+                                                        XDEV_RESUME);
+                                spin_unlock_irqrestore(&xhci->lock, flags);
                                 msleep(20);
                                 spin_lock_irqsave(&xhci->lock, flags);
-
-                                temp = xhci_readl(xhci,
-                                                port_array[wIndex]);
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp &= ~PORT_PLS_MASK;
-                                temp |= PORT_LINK_STROBE | XDEV_U0;
-                                xhci_writel(xhci, temp,
-                                                port_array[wIndex]);
+                                xhci_set_link_state(xhci, port_array, wIndex,
+                                                        XDEV_U0);
                         }
                         bus_state->port_c_suspend |= 1 << wIndex;
 
@@ -761,7 +812,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         memset(buf, 0, retval);
         status = 0;
 
-        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
@@ -910,25 +961,18 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                 if (test_bit(port_index, &bus_state->bus_suspended) &&
                     (temp & PORT_PLS_MASK)) {
                         if (DEV_SUPERSPEED(temp)) {
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp &= ~PORT_PLS_MASK;
-                                temp |= PORT_LINK_STROBE | XDEV_U0;
-                                xhci_writel(xhci, temp, port_array[port_index]);
+                                xhci_set_link_state(xhci, port_array,
+                                                        port_index, XDEV_U0);
                         } else {
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp &= ~PORT_PLS_MASK;
-                                temp |= PORT_LINK_STROBE | XDEV_RESUME;
-                                xhci_writel(xhci, temp, port_array[port_index]);
+                                xhci_set_link_state(xhci, port_array,
+                                                port_index, XDEV_RESUME);
 
                                 spin_unlock_irqrestore(&xhci->lock, flags);
                                 msleep(20);
                                 spin_lock_irqsave(&xhci->lock, flags);
 
-                                temp = xhci_readl(xhci, port_array[port_index]);
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp &= ~PORT_PLS_MASK;
-                                temp |= PORT_LINK_STROBE | XDEV_U0;
-                                xhci_writel(xhci, temp, port_array[port_index]);
+                                xhci_set_link_state(xhci, port_array,
+                                                        port_index, XDEV_U0);
                         }
                         /* wait for the port to enter U0 and report port link
                          * state change.
@@ -938,12 +982,8 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                         spin_lock_irqsave(&xhci->lock, flags);
 
                         /* Clear PLC */
-                        temp = xhci_readl(xhci, port_array[port_index]);
-                        if (temp & PORT_PLC) {
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp |= PORT_PLC;
-                                xhci_writel(xhci, temp, port_array[port_index]);
-                        }
+                        xhci_test_and_clear_bit(xhci, port_array, port_index,
+                                                PORT_PLC);
 
                         slot_id = xhci_find_slot_id_by_port(hcd,
                                         xhci, port_index + 1);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index d446886b22b0..0e4b25fa3bcd 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -61,8 +61,6 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flag
 
 static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
 {
-        if (!seg)
-                return;
         if (seg->trbs) {
                 xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n",
                                 seg->trbs, (unsigned long long)seg->dma);
@@ -81,7 +79,7 @@ static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
  * related flags, such as End TRB, Toggle Cycle, and no snoop.
  */
 static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
-                struct xhci_segment *next, bool link_trbs)
+                struct xhci_segment *next, bool link_trbs, bool isoc)
 {
         u32 val;
 
@@ -97,7 +95,9 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                 val &= ~TRB_TYPE_BITMASK;
                 val |= TRB_TYPE(TRB_LINK);
                 /* Always set the chain bit with 0.95 hardware */
-                if (xhci_link_trb_quirk(xhci))
+                /* Set chain bit for isoc rings on AMD 0.96 host */
+                if (xhci_link_trb_quirk(xhci) ||
+                                (isoc && (xhci->quirks & XHCI_AMD_0x96_HOST)))
                         val |= TRB_CHAIN;
                 prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
         }
@@ -112,18 +112,20 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
         struct xhci_segment *seg;
         struct xhci_segment *first_seg;
 
-        if (!ring || !ring->first_seg)
+        if (!ring)
                 return;
-        first_seg = ring->first_seg;
-        seg = first_seg->next;
-        xhci_dbg(xhci, "Freeing ring at %p\n", ring);
-        while (seg != first_seg) {
-                struct xhci_segment *next = seg->next;
-                xhci_segment_free(xhci, seg);
-                seg = next;
+        if (ring->first_seg) {
+                first_seg = ring->first_seg;
+                seg = first_seg->next;
+                xhci_dbg(xhci, "Freeing ring at %p\n", ring);
+                while (seg != first_seg) {
+                        struct xhci_segment *next = seg->next;
+                        xhci_segment_free(xhci, seg);
+                        seg = next;
+                }
+                xhci_segment_free(xhci, first_seg);
+                ring->first_seg = NULL;
         }
-        xhci_segment_free(xhci, first_seg);
-        ring->first_seg = NULL;
         kfree(ring);
 }
 
@@ -152,7 +154,7 @@ static void xhci_initialize_ring_info(struct xhci_ring *ring)
  * See section 4.9.1 and figures 15 and 16.
  */
 static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
-                unsigned int num_segs, bool link_trbs, gfp_t flags)
+                unsigned int num_segs, bool link_trbs, bool isoc, gfp_t flags)
 {
         struct xhci_ring        *ring;
         struct xhci_segment     *prev;
@@ -178,12 +180,12 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                 next = xhci_segment_alloc(xhci, flags);
                 if (!next)
                         goto fail;
-                xhci_link_segments(xhci, prev, next, link_trbs);
+                xhci_link_segments(xhci, prev, next, link_trbs, isoc);
 
                 prev = next;
                 num_segs--;
         }
-        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs);
+        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs, isoc);
 
         if (link_trbs) {
                 /* See section 4.9.2.1 and 6.4.4.1 */
@@ -229,14 +231,14 @@ void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
  * pointers to the beginning of the ring.
  */
 static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
-                struct xhci_ring *ring)
+                struct xhci_ring *ring, bool isoc)
 {
         struct xhci_segment     *seg = ring->first_seg;
         do {
                 memset(seg->trbs, 0,
                                 sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
                 /* All endpoint rings have link TRBs */
-                xhci_link_segments(xhci, seg, seg->next, 1);
+                xhci_link_segments(xhci, seg, seg->next, 1, isoc);
                 seg = seg->next;
         } while (seg != ring->first_seg);
         xhci_initialize_ring_info(ring);
@@ -315,7 +317,7 @@ static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
         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,
+                dma_free_coherent(&pdev->dev,
                                 sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
                                 stream_ctx, dma);
         else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
@@ -343,9 +345,9 @@ static struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
         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,
+                return dma_alloc_coherent(&pdev->dev,
                                 sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
-                                dma);
+                                dma, mem_flags);
         else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
                 return dma_pool_alloc(xhci->small_streams_pool,
                                 mem_flags, dma);
@@ -540,7 +542,7 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
          */
         for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
                 stream_info->stream_rings[cur_stream] =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
                 cur_ring = stream_info->stream_rings[cur_stream];
                 if (!cur_ring)
                         goto cleanup_rings;
@@ -687,11 +689,103 @@ static void xhci_init_endpoint_timer(struct xhci_hcd *xhci,
         ep->xhci = xhci;
 }
 
-/* All the xhci_tds in the ring's TD list should be freed at this point */
+static void xhci_free_tt_info(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                int slot_id)
+{
+        struct list_head *tt;
+        struct list_head *tt_list_head;
+        struct list_head *tt_next;
+        struct xhci_tt_bw_info *tt_info;
+
+        /* If the device never made it past the Set Address stage,
+         * it may not have the real_port set correctly.
+         */
+        if (virt_dev->real_port == 0 ||
+                        virt_dev->real_port > HCS_MAX_PORTS(xhci->hcs_params1)) {
+                xhci_dbg(xhci, "Bad real port.\n");
+                return;
+        }
+
+        tt_list_head = &(xhci->rh_bw[virt_dev->real_port - 1].tts);
+        if (list_empty(tt_list_head))
+                return;
+
+        list_for_each(tt, tt_list_head) {
+                tt_info = list_entry(tt, struct xhci_tt_bw_info, tt_list);
+                if (tt_info->slot_id == slot_id)
+                        break;
+        }
+        /* Cautionary measure in case the hub was disconnected before we
+         * stored the TT information.
+         */
+        if (tt_info->slot_id != slot_id)
+                return;
+
+        tt_next = tt->next;
+        tt_info = list_entry(tt, struct xhci_tt_bw_info,
+                        tt_list);
+        /* Multi-TT hubs will have more than one entry */
+        do {
+                list_del(tt);
+                kfree(tt_info);
+                tt = tt_next;
+                if (list_empty(tt_list_head))
+                        break;
+                tt_next = tt->next;
+                tt_info = list_entry(tt, struct xhci_tt_bw_info,
+                                tt_list);
+        } while (tt_info->slot_id == slot_id);
+}
+
+int xhci_alloc_tt_info(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                struct usb_device *hdev,
+                struct usb_tt *tt, gfp_t mem_flags)
+{
+        struct xhci_tt_bw_info          *tt_info;
+        unsigned int                    num_ports;
+        int                             i, j;
+
+        if (!tt->multi)
+                num_ports = 1;
+        else
+                num_ports = hdev->maxchild;
+
+        for (i = 0; i < num_ports; i++, tt_info++) {
+                struct xhci_interval_bw_table *bw_table;
+
+                tt_info = kzalloc(sizeof(*tt_info), mem_flags);
+                if (!tt_info)
+                        goto free_tts;
+                INIT_LIST_HEAD(&tt_info->tt_list);
+                list_add(&tt_info->tt_list,
+                                &xhci->rh_bw[virt_dev->real_port - 1].tts);
+                tt_info->slot_id = virt_dev->udev->slot_id;
+                if (tt->multi)
+                        tt_info->ttport = i+1;
+                bw_table = &tt_info->bw_table;
+                for (j = 0; j < XHCI_MAX_INTERVAL; j++)
+                        INIT_LIST_HEAD(&bw_table->interval_bw[j].endpoints);
+        }
+        return 0;
+
+free_tts:
+        xhci_free_tt_info(xhci, virt_dev, virt_dev->udev->slot_id);
+        return -ENOMEM;
+}
+
+
+/* All the xhci_tds in the ring's TD list should be freed at this point.
+ * Should be called with xhci->lock held if there is any chance the TT lists
+ * will be manipulated by the configure endpoint, allocate device, or update
+ * hub functions while this function is removing the TT entries from the list.
+ */
 void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
 {
         struct xhci_virt_device *dev;
         int i;
+        int old_active_eps = 0;
 
         /* Slot ID 0 is reserved */
         if (slot_id == 0 || !xhci->devs[slot_id])
@@ -702,13 +796,29 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
         if (!dev)
                 return;
 
+        if (dev->tt_info)
+                old_active_eps = dev->tt_info->active_eps;
+
         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);
+                /* Endpoints on the TT/root port lists should have been removed
+                 * when usb_disable_device() was called for the device.
+                 * We can't drop them anyway, because the udev might have gone
+                 * away by this point, and we can't tell what speed it was.
+                 */
+                if (!list_empty(&dev->eps[i].bw_endpoint_list))
+                        xhci_warn(xhci, "Slot %u endpoint %u "
+                                        "not removed from BW list!\n",
+                                        slot_id, i);
         }
+        /* If this is a hub, free the TT(s) from the TT list */
+        xhci_free_tt_info(xhci, dev, slot_id);
+        /* If necessary, update the number of active TTs on this root port */
+        xhci_update_tt_active_eps(xhci, dev, old_active_eps);
 
         if (dev->ring_cache) {
                 for (i = 0; i < dev->num_rings_cached; i++)
@@ -762,10 +872,11 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         for (i = 0; i < 31; i++) {
                 xhci_init_endpoint_timer(xhci, &dev->eps[i]);
                 INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list);
+                INIT_LIST_HEAD(&dev->eps[i].bw_endpoint_list);
         }
 
         /* Allocate endpoint 0 ring */
-        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);
+        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, false, flags);
         if (!dev->eps[0].ring)
                 goto fail;
 
@@ -871,7 +982,6 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         struct xhci_virt_device *dev;
         struct xhci_ep_ctx      *ep0_ctx;
         struct xhci_slot_ctx    *slot_ctx;
-        struct xhci_input_control_ctx *ctrl_ctx;
         u32                     port_num;
         struct usb_device *top_dev;
 
@@ -883,12 +993,8 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                 return -EINVAL;
         }
         ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0);
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
 
-        /* 2) New slot context and endpoint 0 context are valid*/
-        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
-
         /* 3) Only the control endpoint is valid - one endpoint context */
         slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | udev->route);
         switch (udev->speed) {
@@ -921,9 +1027,40 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
                         top_dev = top_dev->parent)
                 /* Found device below root hub */;
-        dev->port = top_dev->portnum;
+        dev->fake_port = top_dev->portnum;
+        dev->real_port = port_num;
         xhci_dbg(xhci, "Set root hub portnum to %d\n", port_num);
-        xhci_dbg(xhci, "Set fake root hub portnum to %d\n", dev->port);
+        xhci_dbg(xhci, "Set fake root hub portnum to %d\n", dev->fake_port);
+
+        /* Find the right bandwidth table that this device will be a part of.
+         * If this is a full speed device attached directly to a root port (or a
+         * decendent of one), it counts as a primary bandwidth domain, not a
+         * secondary bandwidth domain under a TT.  An xhci_tt_info structure
+         * will never be created for the HS root hub.
+         */
+        if (!udev->tt || !udev->tt->hub->parent) {
+                dev->bw_table = &xhci->rh_bw[port_num - 1].bw_table;
+        } else {
+                struct xhci_root_port_bw_info *rh_bw;
+                struct xhci_tt_bw_info *tt_bw;
+
+                rh_bw = &xhci->rh_bw[port_num - 1];
+                /* Find the right TT. */
+                list_for_each_entry(tt_bw, &rh_bw->tts, tt_list) {
+                        if (tt_bw->slot_id != udev->tt->hub->slot_id)
+                                continue;
+
+                        if (!dev->udev->tt->multi ||
+                                        (udev->tt->multi &&
+                                         tt_bw->ttport == dev->udev->ttport)) {
+                                dev->bw_table = &tt_bw->bw_table;
+                                dev->tt_info = tt_bw;
+                                break;
+                        }
+                }
+                if (!dev->tt_info)
+                        xhci_warn(xhci, "WARN: Didn't find a matching TT\n");
+        }
 
         /* Is this a LS/FS device under an external HS hub? */
         if (udev->tt && udev->tt->hub->parent) {
@@ -1141,8 +1278,8 @@ static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
         if (udev->speed == USB_SPEED_SUPER)
                 return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval);
 
-        max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
-        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize) & 0x1800) >> 11;
+        max_packet = GET_MAX_PACKET(usb_endpoint_maxp(&ep->desc));
+        max_burst = (usb_endpoint_maxp(&ep->desc) & 0x1800) >> 11;
         /* A 0 in max burst means 1 transfer per ESIT */
         return max_packet * (max_burst + 1);
 }
@@ -1175,10 +1312,10 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
          */
         if (usb_endpoint_xfer_isoc(&ep->desc))
                 virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 8, true, mem_flags);
+                        xhci_ring_alloc(xhci, 8, true, true, mem_flags);
         else
                 virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
         if (!virt_dev->eps[ep_index].new_ring) {
                 /* Attempt to use the ring cache */
                 if (virt_dev->num_rings_cached == 0)
@@ -1187,7 +1324,8 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                         virt_dev->ring_cache[virt_dev->num_rings_cached];
                 virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
                 virt_dev->num_rings_cached--;
-                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring);
+                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
+                        usb_endpoint_xfer_isoc(&ep->desc) ? true : false);
         }
         virt_dev->eps[ep_index].skip = false;
         ep_ring = virt_dev->eps[ep_index].new_ring;
@@ -1211,7 +1349,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         /* Set the max packet size and max burst */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                max_packet = le16_to_cpu(ep->desc.wMaxPacketSize);
+                max_packet = usb_endpoint_maxp(&ep->desc);
                 ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 /* dig out max burst from ep companion desc */
                 max_packet = ep->ss_ep_comp.bMaxBurst;
@@ -1223,14 +1361,14 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                  */
                 if (usb_endpoint_xfer_isoc(&ep->desc) ||
                                 usb_endpoint_xfer_int(&ep->desc)) {
-                        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize)
+                        max_burst = (usb_endpoint_maxp(&ep->desc)
                                      & 0x1800) >> 11;
                         ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_burst));
                 }
                 /* Fall through */
         case USB_SPEED_FULL:
         case USB_SPEED_LOW:
-                max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
+                max_packet = GET_MAX_PACKET(usb_endpoint_maxp(&ep->desc));
                 ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 break;
         default:
@@ -1286,6 +1424,70 @@ void xhci_endpoint_zero(struct xhci_hcd *xhci,
          */
 }
 
+void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info)
+{
+        bw_info->ep_interval = 0;
+        bw_info->mult = 0;
+        bw_info->num_packets = 0;
+        bw_info->max_packet_size = 0;
+        bw_info->type = 0;
+        bw_info->max_esit_payload = 0;
+}
+
+void xhci_update_bw_info(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_input_control_ctx *ctrl_ctx,
+                struct xhci_virt_device *virt_dev)
+{
+        struct xhci_bw_info *bw_info;
+        struct xhci_ep_ctx *ep_ctx;
+        unsigned int ep_type;
+        int i;
+
+        for (i = 1; i < 31; ++i) {
+                bw_info = &virt_dev->eps[i].bw_info;
+
+                /* We can't tell what endpoint type is being dropped, but
+                 * unconditionally clearing the bandwidth info for non-periodic
+                 * endpoints should be harmless because the info will never be
+                 * set in the first place.
+                 */
+                if (!EP_IS_ADDED(ctrl_ctx, i) && EP_IS_DROPPED(ctrl_ctx, i)) {
+                        /* Dropped endpoint */
+                        xhci_clear_endpoint_bw_info(bw_info);
+                        continue;
+                }
+
+                if (EP_IS_ADDED(ctrl_ctx, i)) {
+                        ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, i);
+                        ep_type = CTX_TO_EP_TYPE(le32_to_cpu(ep_ctx->ep_info2));
+
+                        /* Ignore non-periodic endpoints */
+                        if (ep_type != ISOC_OUT_EP && ep_type != INT_OUT_EP &&
+                                        ep_type != ISOC_IN_EP &&
+                                        ep_type != INT_IN_EP)
+                                continue;
+
+                        /* Added or changed endpoint */
+                        bw_info->ep_interval = CTX_TO_EP_INTERVAL(
+                                        le32_to_cpu(ep_ctx->ep_info));
+                        /* Number of packets and mult are zero-based in the
+                         * input context, but we want one-based for the
+                         * interval table.
+                         */
+                        bw_info->mult = CTX_TO_EP_MULT(
+                                        le32_to_cpu(ep_ctx->ep_info)) + 1;
+                        bw_info->num_packets = CTX_TO_MAX_BURST(
+                                        le32_to_cpu(ep_ctx->ep_info2)) + 1;
+                        bw_info->max_packet_size = MAX_PACKET_DECODED(
+                                        le32_to_cpu(ep_ctx->ep_info2));
+                        bw_info->type = ep_type;
+                        bw_info->max_esit_payload = CTX_TO_MAX_ESIT_PAYLOAD(
+                                        le32_to_cpu(ep_ctx->tx_info));
+                }
+        }
+}
+
 /* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy.
  * Useful when you want to change one particular aspect of the endpoint and then
  * issue a configure endpoint command.
@@ -1344,10 +1546,9 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         if (!xhci->scratchpad)
                 goto fail_sp;
 
-        xhci->scratchpad->sp_array =
-                pci_alloc_consistent(to_pci_dev(dev),
+        xhci->scratchpad->sp_array = dma_alloc_coherent(dev,
                                      num_sp * sizeof(u64),
-                                     &xhci->scratchpad->sp_dma);
+                                     &xhci->scratchpad->sp_dma, flags);
         if (!xhci->scratchpad->sp_array)
                 goto fail_sp2;
 
@@ -1364,8 +1565,8 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma);
         for (i = 0; i < num_sp; i++) {
                 dma_addr_t dma;
-                void *buf = pci_alloc_consistent(to_pci_dev(dev),
-                                                 xhci->page_size, &dma);
+                void *buf = dma_alloc_coherent(dev, xhci->page_size, &dma,
+                                flags);
                 if (!buf)
                         goto fail_sp5;
 
@@ -1378,7 +1579,7 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
 
  fail_sp5:
         for (i = i - 1; i >= 0; i--) {
-                pci_free_consistent(to_pci_dev(dev), xhci->page_size,
+                dma_free_coherent(dev, xhci->page_size,
                                     xhci->scratchpad->sp_buffers[i],
                                     xhci->scratchpad->sp_dma_buffers[i]);
         }
@@ -1388,7 +1589,7 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         kfree(xhci->scratchpad->sp_buffers);
 
  fail_sp3:
-        pci_free_consistent(to_pci_dev(dev), num_sp * sizeof(u64),
+        dma_free_coherent(dev, num_sp * sizeof(u64),
                             xhci->scratchpad->sp_array,
                             xhci->scratchpad->sp_dma);
 
@@ -1412,13 +1613,13 @@ static void scratchpad_free(struct xhci_hcd *xhci)
         num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);
 
         for (i = 0; i < num_sp; i++) {
-                pci_free_consistent(pdev, xhci->page_size,
+                dma_free_coherent(&pdev->dev, xhci->page_size,
                                     xhci->scratchpad->sp_buffers[i],
                                     xhci->scratchpad->sp_dma_buffers[i]);
         }
         kfree(xhci->scratchpad->sp_dma_buffers);
         kfree(xhci->scratchpad->sp_buffers);
-        pci_free_consistent(pdev, num_sp * sizeof(u64),
+        dma_free_coherent(&pdev->dev, num_sp * sizeof(u64),
                             xhci->scratchpad->sp_array,
                             xhci->scratchpad->sp_dma);
         kfree(xhci->scratchpad);
@@ -1463,18 +1664,10 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
 
 void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv)
 {
-        int last;
-
-        if (!urb_priv)
-                return;
-
-        last = urb_priv->length - 1;
-        if (last >= 0) {
-                int     i;
-                for (i = 0; i <= last; i++)
-                        kfree(urb_priv->td[i]);
+        if (urb_priv) {
+                kfree(urb_priv->td[0]);
+                kfree(urb_priv);
         }
-        kfree(urb_priv);
 }
 
 void xhci_free_command(struct xhci_hcd *xhci,
@@ -1489,6 +1682,8 @@ void xhci_free_command(struct xhci_hcd *xhci,
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct dev_info *dev_info, *next;
+        unsigned long   flags;
         int size;
         int i;
 
@@ -1500,7 +1695,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         }
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
-                pci_free_consistent(pdev, size,
+                dma_free_coherent(&pdev->dev, size,
                                 xhci->erst.entries, xhci->erst.erst_dma_addr);
         xhci->erst.entries = NULL;
         xhci_dbg(xhci, "Freed ERST\n");
@@ -1540,17 +1735,25 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
 
         xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr);
         if (xhci->dcbaa)
-                pci_free_consistent(pdev, sizeof(*xhci->dcbaa),
+                dma_free_coherent(&pdev->dev, sizeof(*xhci->dcbaa),
                                 xhci->dcbaa, xhci->dcbaa->dma);
         xhci->dcbaa = NULL;
 
         scratchpad_free(xhci);
 
+        spin_lock_irqsave(&xhci->lock, flags);
+        list_for_each_entry_safe(dev_info, next, &xhci->lpm_failed_devs, list) {
+                list_del(&dev_info->list);
+                kfree(dev_info);
+        }
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
         xhci->num_usb2_ports = 0;
         xhci->num_usb3_ports = 0;
         kfree(xhci->usb2_ports);
         kfree(xhci->usb3_ports);
         kfree(xhci->port_array);
+        kfree(xhci->rh_bw);
 
         xhci->page_size = 0;
         xhci->page_shift = 0;
@@ -1762,6 +1965,23 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
         if (port_offset == 0 || (port_offset + port_count - 1) > num_ports)
                 /* WTF? "Valid values are ‘1’ to MaxPorts" */
                 return;
+
+        /* Check the host's USB2 LPM capability */
+        if ((xhci->hci_version == 0x96) && (major_revision != 0x03) &&
+                        (temp & XHCI_L1C)) {
+                xhci_dbg(xhci, "xHCI 0.96: support USB2 software lpm\n");
+                xhci->sw_lpm_support = 1;
+        }
+
+        if ((xhci->hci_version >= 0x100) && (major_revision != 0x03)) {
+                xhci_dbg(xhci, "xHCI 1.0: support USB2 software lpm\n");
+                xhci->sw_lpm_support = 1;
+                if (temp & XHCI_HLC) {
+                        xhci_dbg(xhci, "xHCI 1.0: support USB2 hardware lpm\n");
+                        xhci->hw_lpm_support = 1;
+                }
+        }
+
         port_offset--;
         for (i = port_offset; i < (port_offset + port_count); i++) {
                 /* Duplicate entry.  Ignore the port if the revisions differ. */
@@ -1806,7 +2026,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
         __le32 __iomem *addr;
         u32 offset;
         unsigned int num_ports;
-        int i, port_index;
+        int i, j, port_index;
 
         addr = &xhci->cap_regs->hcc_params;
         offset = XHCI_HCC_EXT_CAPS(xhci_readl(xhci, addr));
@@ -1821,6 +2041,18 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
         if (!xhci->port_array)
                 return -ENOMEM;
 
+        xhci->rh_bw = kzalloc(sizeof(*xhci->rh_bw)*num_ports, flags);
+        if (!xhci->rh_bw)
+                return -ENOMEM;
+        for (i = 0; i < num_ports; i++) {
+                struct xhci_interval_bw_table *bw_table;
+
+                INIT_LIST_HEAD(&xhci->rh_bw[i].tts);
+                bw_table = &xhci->rh_bw[i].bw_table;
+                for (j = 0; j < XHCI_MAX_INTERVAL; j++)
+                        INIT_LIST_HEAD(&bw_table->interval_bw[j].endpoints);
+        }
+
         /*
          * For whatever reason, the first capability offset is from the
          * capability register base, not from the HCCPARAMS register.
@@ -1959,8 +2191,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          * Section 5.4.8 - doorbell array must be
          * "physically contiguous and 64-byte (cache line) aligned".
          */
-        xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev),
-                        sizeof(*xhci->dcbaa), &dma);
+        xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
+                        GFP_KERNEL);
         if (!xhci->dcbaa)
                 goto fail;
         memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa));
@@ -1994,14 +2226,14 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                 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()
+         * will be allocated with dma_alloc_coherent()
          */
 
         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);
+        xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, false, flags);
         if (!xhci->cmd_ring)
                 goto fail;
         xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring);
@@ -2032,14 +2264,16 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          * the event ring segment table (ERST).  Section 4.9.3.
          */
         xhci_dbg(xhci, "// Allocating event ring\n");
-        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags);
+        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, false,
+                                                flags);
         if (!xhci->event_ring)
                 goto fail;
         if (xhci_check_trb_in_td_math(xhci, flags) < 0)
                 goto fail;
 
-        xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev),
-                        sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma);
+        xhci->erst.entries = dma_alloc_coherent(dev,
+                        sizeof(struct xhci_erst_entry) * ERST_NUM_SEGS, &dma,
+                        GFP_KERNEL);
         if (!xhci->erst.entries)
                 goto fail;
         xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n",
@@ -2102,6 +2336,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         if (xhci_setup_port_arrays(xhci, flags))
                 goto fail;
 
+        INIT_LIST_HEAD(&xhci->lpm_failed_devs);
+
         return 0;
 
 fail:
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index cb16de213f64..ef98b38626fb 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -22,6 +22,7 @@
 
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/module.h>
 
 #include "xhci.h"
 
@@ -51,61 +52,9 @@ static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
         return 0;
 }
 
-/* called during probe() after chip reset completes */
-static int xhci_pci_setup(struct usb_hcd *hcd)
+static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
-        struct xhci_hcd         *xhci;
-        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
-        int                     retval;
-        u32                     temp;
-
-        hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
-
-        if (usb_hcd_is_primary_hcd(hcd)) {
-                xhci = kzalloc(sizeof(struct xhci_hcd), GFP_KERNEL);
-                if (!xhci)
-                        return -ENOMEM;
-                *((struct xhci_hcd **) hcd->hcd_priv) = xhci;
-                xhci->main_hcd = hcd;
-                /* Mark the first roothub as being USB 2.0.
-                 * The xHCI driver will register the USB 3.0 roothub.
-                 */
-                hcd->speed = HCD_USB2;
-                hcd->self.root_hub->speed = USB_SPEED_HIGH;
-                /*
-                 * USB 2.0 roothub under xHCI has an integrated TT,
-                 * (rate matching hub) as opposed to having an OHCI/UHCI
-                 * companion controller.
-                 */
-                hcd->has_tt = 1;
-        } else {
-                /* xHCI private pointer was set in xhci_pci_probe for the second
-                 * registered roothub.
-                 */
-                xhci = hcd_to_xhci(hcd);
-                temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-                if (HCC_64BIT_ADDR(temp)) {
-                        xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
-                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
-                } else {
-                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
-                }
-                return 0;
-        }
-
-        xhci->cap_regs = hcd->regs;
-        xhci->op_regs = hcd->regs +
-                HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
-        xhci->run_regs = hcd->regs +
-                (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
-        /* Cache read-only capability registers */
-        xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
-        xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
-        xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
-        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
-        xhci->hci_version = HC_VERSION(xhci->hcc_params);
-        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-        xhci_print_registers(xhci);
+        struct pci_dev          *pdev = to_pci_dev(dev);
 
         /* Look for vendor-specific quirks */
         if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
@@ -128,6 +77,9 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         if (pdev->vendor == PCI_VENDOR_ID_NEC)
                 xhci->quirks |= XHCI_NEC_HOST;
 
+        if (pdev->vendor == PCI_VENDOR_ID_AMD && xhci->hci_version == 0x96)
+                xhci->quirks |= XHCI_AMD_0x96_HOST;
+
         /* AMD PLL quirk */
         if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
                 xhci->quirks |= XHCI_AMD_PLL_FIX;
@@ -136,39 +88,29 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
                 xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
                 xhci->quirks |= XHCI_EP_LIMIT_QUIRK;
                 xhci->limit_active_eps = 64;
+                xhci->quirks |= XHCI_SW_BW_CHECKING;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
                 xhci_dbg(xhci, "QUIRK: Resetting on resume\n");
         }
+}
 
-        /* Make sure the HC is halted. */
-        retval = xhci_halt(xhci);
-        if (retval)
-                goto error;
+/* called during probe() after chip reset completes */
+static int xhci_pci_setup(struct usb_hcd *hcd)
+{
+        struct xhci_hcd         *xhci;
+        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+        int                     retval;
 
-        xhci_dbg(xhci, "Resetting HCD\n");
-        /* Reset the internal HC memory state and registers. */
-        retval = xhci_reset(xhci);
+        retval = xhci_gen_setup(hcd, xhci_pci_quirks);
         if (retval)
-                goto error;
-        xhci_dbg(xhci, "Reset complete\n");
-
-        temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-        if (HCC_64BIT_ADDR(temp)) {
-                xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
-                dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
-        } else {
-                dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
-        }
+                return retval;
 
-        xhci_dbg(xhci, "Calling HCD init\n");
-        /* Initialize HCD and host controller data structures. */
-        retval = xhci_init(hcd);
-        if (retval)
-                goto error;
-        xhci_dbg(xhci, "Called HCD init\n");
+        xhci = hcd_to_xhci(hcd);
+        if (!usb_hcd_is_primary_hcd(hcd))
+                return 0;
 
         pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn);
         xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn);
@@ -178,7 +120,6 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         if (!retval)
                 return retval;
 
-error:
         kfree(xhci);
         return retval;
 }
@@ -222,7 +163,7 @@ static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
 
         retval = usb_add_hcd(xhci->shared_hcd, dev->irq,
-                        IRQF_DISABLED | IRQF_SHARED);
+                        IRQF_SHARED);
         if (retval)
                 goto put_usb3_hcd;
         /* Roothub already marked as USB 3.0 speed */
@@ -344,6 +285,11 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .hub_status_data =      xhci_hub_status_data,
         .bus_suspend =          xhci_bus_suspend,
         .bus_resume =           xhci_bus_resume,
+        /*
+         * call back when device connected and addressed
+         */
+        .update_device =        xhci_update_device,
+        .set_usb2_hw_lpm =      xhci_set_usb2_hardware_lpm,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -375,12 +321,12 @@ static struct pci_driver xhci_pci_driver = {
 #endif
 };
 
-int xhci_register_pci(void)
+int __init xhci_register_pci(void)
 {
         return pci_register_driver(&xhci_pci_driver);
 }
 
-void xhci_unregister_pci(void)
+void __exit 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 54139a2f06ce..9f1d4b15d818 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -185,7 +185,7 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
  *                      prepare_transfer()?
  */
 static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
-                bool consumer, bool more_trbs_coming)
+                bool consumer, bool more_trbs_coming, bool isoc)
 {
         u32 chain;
         union xhci_trb *next;
@@ -212,11 +212,13 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                                 if (!chain && !more_trbs_coming)
                                         break;
 
-                                /* If we're not dealing with 0.95 hardware,
+                                /* If we're not dealing with 0.95 hardware or
+                                 * isoc rings on AMD 0.96 host,
                                  * carry over the chain bit of the previous TRB
                                  * (which may mean the chain bit is cleared).
                                  */
-                                if (!xhci_link_trb_quirk(xhci)) {
+                                if (!(isoc && (xhci->quirks & XHCI_AMD_0x96_HOST))
+                                                && !xhci_link_trb_quirk(xhci)) {
                                         next->link.control &=
                                                 cpu_to_le32(~TRB_CHAIN);
                                         next->link.control |=
@@ -814,23 +816,24 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
         struct xhci_ring *ring;
         struct xhci_td *cur_td;
         int ret, i, j;
+        unsigned long flags;
 
         ep = (struct xhci_virt_ep *) arg;
         xhci = ep->xhci;
 
-        spin_lock(&xhci->lock);
+        spin_lock_irqsave(&xhci->lock, flags);
 
         ep->stop_cmds_pending--;
         if (xhci->xhc_state & XHCI_STATE_DYING) {
                 xhci_dbg(xhci, "Stop EP timer ran, but another timer marked "
                                 "xHCI as DYING, exiting.\n");
-                spin_unlock(&xhci->lock);
+                spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
         }
         if (!(ep->stop_cmds_pending == 0 && (ep->ep_state & EP_HALT_PENDING))) {
                 xhci_dbg(xhci, "Stop EP timer ran, but no command pending, "
                                 "exiting.\n");
-                spin_unlock(&xhci->lock);
+                spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
         }
 
@@ -842,11 +845,11 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
         xhci->xhc_state |= XHCI_STATE_DYING;
         /* Disable interrupts from the host controller and start halting it */
         xhci_quiesce(xhci);
-        spin_unlock(&xhci->lock);
+        spin_unlock_irqrestore(&xhci->lock, flags);
 
         ret = xhci_halt(xhci);
 
-        spin_lock(&xhci->lock);
+        spin_lock_irqsave(&xhci->lock, flags);
         if (ret < 0) {
                 /* This is bad; the host is not responding to commands and it's
                  * not allowing itself to be halted.  At least interrupts are
@@ -894,7 +897,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                         }
                 }
         }
-        spin_unlock(&xhci->lock);
+        spin_unlock_irqrestore(&xhci->lock, flags);
         xhci_dbg(xhci, "Calling usb_hc_died()\n");
         usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
         xhci_dbg(xhci, "xHCI host controller is dead.\n");
@@ -1329,10 +1332,8 @@ static void handle_port_status(struct xhci_hcd *xhci,
 
                 if (DEV_SUPERSPEED(temp)) {
                         xhci_dbg(xhci, "resume SS port %d\n", port_id);
-                        temp = xhci_port_state_to_neutral(temp);
-                        temp &= ~PORT_PLS_MASK;
-                        temp |= PORT_LINK_STROBE | XDEV_U0;
-                        xhci_writel(xhci, temp, port_array[faked_port_index]);
+                        xhci_set_link_state(xhci, port_array, faked_port_index,
+                                                XDEV_U0);
                         slot_id = xhci_find_slot_id_by_port(hcd, xhci,
                                         faked_port_index);
                         if (!slot_id) {
@@ -1342,10 +1343,8 @@ static void handle_port_status(struct xhci_hcd *xhci,
                         xhci_ring_device(xhci, slot_id);
                         xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
                         /* Clear PORT_PLC */
-                        temp = xhci_readl(xhci, port_array[faked_port_index]);
-                        temp = xhci_port_state_to_neutral(temp);
-                        temp |= PORT_PLC;
-                        xhci_writel(xhci, temp, port_array[faked_port_index]);
+                        xhci_test_and_clear_bit(xhci, port_array,
+                                                faked_port_index, PORT_PLC);
                 } else {
                         xhci_dbg(xhci, "resume HS port %d\n", port_id);
                         bus_state->resume_done[faked_port_index] = jiffies +
@@ -1356,6 +1355,10 @@ static void handle_port_status(struct xhci_hcd *xhci,
                 }
         }
 
+        if (hcd->speed != HCD_USB3)
+                xhci_test_and_clear_bit(xhci, port_array, faked_port_index,
+                                        PORT_PLC);
+
 cleanup:
         /* Update event ring dequeue pointer before dropping the lock */
         inc_deq(xhci, xhci->event_ring, true);
@@ -1934,8 +1937,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         int status = -EINPROGRESS;
         struct urb_priv *urb_priv;
         struct xhci_ep_ctx *ep_ctx;
+        struct list_head *tmp;
         u32 trb_comp_code;
         int ret = 0;
+        int td_num = 0;
 
         slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
@@ -1957,6 +1962,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 return -ENODEV;
         }
 
+        /* Count current td numbers if ep->skip is set */
+        if (ep->skip) {
+                list_for_each(tmp, &ep_ring->td_list)
+                        td_num++;
+        }
+
         event_dma = le64_to_cpu(event->buffer);
         trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         /* Look for common error cases */
@@ -2068,7 +2079,18 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         goto cleanup;
                 }
 
+                /* We've skipped all the TDs on the ep ring when ep->skip set */
+                if (ep->skip && td_num == 0) {
+                        ep->skip = false;
+                        xhci_dbg(xhci, "All tds on the ep_ring skipped. "
+                                                "Clear skip flag.\n");
+                        ret = 0;
+                        goto cleanup;
+                }
+
                 td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list);
+                if (ep->skip)
+                        td_num--;
 
                 /* Is this a TRB in the currently executing TD? */
                 event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
@@ -2173,7 +2195,8 @@ cleanup:
                         if ((urb->actual_length != urb->transfer_buffer_length &&
                                                 (urb->transfer_flags &
                                                  URB_SHORT_NOT_OK)) ||
-                                        status != 0)
+                                        (status != 0 &&
+                                         !usb_endpoint_xfer_isoc(&urb->ep->desc)))
                                 xhci_dbg(xhci, "Giveback URB %p, len = %d, "
                                                 "expected = %x, status = %d\n",
                                                 urb, urb->actual_length,
@@ -2390,7 +2413,7 @@ irqreturn_t xhci_msi_irq(int irq, struct usb_hcd *hcd)
  *                      prepare_transfer()?
  */
 static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
-                bool consumer, bool more_trbs_coming,
+                bool consumer, bool more_trbs_coming, bool isoc,
                 u32 field1, u32 field2, u32 field3, u32 field4)
 {
         struct xhci_generic_trb *trb;
@@ -2400,7 +2423,7 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
         trb->field[1] = cpu_to_le32(field2);
         trb->field[2] = cpu_to_le32(field3);
         trb->field[3] = cpu_to_le32(field4);
-        inc_enq(xhci, ring, consumer, more_trbs_coming);
+        inc_enq(xhci, ring, consumer, more_trbs_coming, isoc);
 }
 
 /*
@@ -2408,7 +2431,7 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
  * FIXME allocate segments if the ring is full.
  */
 static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
-                u32 ep_state, unsigned int num_trbs, gfp_t mem_flags)
+                u32 ep_state, unsigned int num_trbs, bool isoc, gfp_t mem_flags)
 {
         /* Make sure the endpoint has been added to xHC schedule */
         switch (ep_state) {
@@ -2450,10 +2473,11 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 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 we're not dealing with 0.95 hardware or isoc rings
+                         * on AMD 0.96 host, clear the chain bit.
                          */
-                        if (!xhci_link_trb_quirk(xhci))
+                        if (!xhci_link_trb_quirk(xhci) && !(isoc &&
+                                        (xhci->quirks & XHCI_AMD_0x96_HOST)))
                                 next->link.control &= cpu_to_le32(~TRB_CHAIN);
                         else
                                 next->link.control |= cpu_to_le32(TRB_CHAIN);
@@ -2486,6 +2510,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
                 unsigned int num_trbs,
                 struct urb *urb,
                 unsigned int td_index,
+                bool isoc,
                 gfp_t mem_flags)
 {
         int ret;
@@ -2503,7 +2528,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
 
         ret = prepare_ring(xhci, ep_ring,
                            le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
-                           num_trbs, mem_flags);
+                           num_trbs, isoc, mem_flags);
         if (ret)
                 return ret;
 
@@ -2692,7 +2717,7 @@ static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
          * running_total.
          */
         packets_transferred = (running_total + trb_buff_len) /
-                le16_to_cpu(urb->ep->desc.wMaxPacketSize);
+                usb_endpoint_maxp(&urb->ep->desc);
 
         return xhci_td_remainder(total_packet_count - packets_transferred);
 }
@@ -2722,11 +2747,11 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         num_trbs = count_sg_trbs_needed(xhci, urb);
         num_sgs = urb->num_sgs;
         total_packet_count = roundup(urb->transfer_buffer_length,
-                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                        usb_endpoint_maxp(&urb->ep->desc));
 
         trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
         if (trb_buff_len < 0)
                 return trb_buff_len;
 
@@ -2821,7 +2846,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         more_trbs_coming = true;
                 else
                         more_trbs_coming = false;
-                queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                queue_trb(xhci, ep_ring, false, more_trbs_coming, false,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
@@ -2912,7 +2937,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         ret = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
         if (ret < 0)
                 return ret;
 
@@ -2929,7 +2954,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         running_total = 0;
         total_packet_count = roundup(urb->transfer_buffer_length,
-                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                        usb_endpoint_maxp(&urb->ep->desc));
         /* How much data is in the first TRB? */
         addr = (u64) urb->transfer_dma;
         trb_buff_len = TRB_MAX_BUFF_SIZE -
@@ -2984,7 +3009,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         more_trbs_coming = true;
                 else
                         more_trbs_coming = false;
-                queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                queue_trb(xhci, ep_ring, false, more_trbs_coming, false,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
@@ -3044,7 +3069,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 num_trbs++;
         ret = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
         if (ret < 0)
                 return ret;
 
@@ -3077,7 +3102,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 }
         }
 
-        queue_trb(xhci, ep_ring, false, true,
+        queue_trb(xhci, ep_ring, false, true, false,
                   setup->bRequestType | setup->bRequest << 8 | le16_to_cpu(setup->wValue) << 16,
                   le16_to_cpu(setup->wIndex) | le16_to_cpu(setup->wLength) << 16,
                   TRB_LEN(8) | TRB_INTR_TARGET(0),
@@ -3097,7 +3122,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         if (urb->transfer_buffer_length > 0) {
                 if (setup->bRequestType & USB_DIR_IN)
                         field |= TRB_DIR_IN;
-                queue_trb(xhci, ep_ring, false, true,
+                queue_trb(xhci, ep_ring, false, true, false,
                                 lower_32_bits(urb->transfer_dma),
                                 upper_32_bits(urb->transfer_dma),
                                 length_field,
@@ -3113,7 +3138,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 field = 0;
         else
                 field = TRB_DIR_IN;
-        queue_trb(xhci, ep_ring, false, false,
+        queue_trb(xhci, ep_ring, false, false, false,
                         0,
                         0,
                         TRB_INTR_TARGET(0),
@@ -3250,7 +3275,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 td_len = urb->iso_frame_desc[i].length;
                 td_remain_len = td_len;
                 total_packet_count = roundup(td_len,
-                                le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                                usb_endpoint_maxp(&urb->ep->desc));
                 /* A zero-length transfer still involves at least one packet. */
                 if (total_packet_count == 0)
                         total_packet_count++;
@@ -3262,7 +3287,8 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 trbs_per_td = count_isoc_trbs_needed(xhci, urb, i);
 
                 ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
-                                urb->stream_id, trbs_per_td, urb, i, mem_flags);
+                                urb->stream_id, trbs_per_td, urb, i, true,
+                                mem_flags);
                 if (ret < 0) {
                         if (i == 0)
                                 return ret;
@@ -3332,7 +3358,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 remainder |
                                 TRB_INTR_TARGET(0);
 
-                        queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                        queue_trb(xhci, ep_ring, false, more_trbs_coming, true,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
@@ -3414,7 +3440,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
          * Do not insert any td of the urb to the ring if the check failed.
          */
         ret = prepare_ring(xhci, ep_ring, le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
-                           num_trbs, mem_flags);
+                           num_trbs, true, mem_flags);
         if (ret)
                 return ret;
 
@@ -3473,7 +3499,7 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                 reserved_trbs++;
 
         ret = prepare_ring(xhci, xhci->cmd_ring, EP_STATE_RUNNING,
-                        reserved_trbs, GFP_ATOMIC);
+                        reserved_trbs, false, GFP_ATOMIC);
         if (ret < 0) {
                 xhci_err(xhci, "ERR: No room for command on command ring\n");
                 if (command_must_succeed)
@@ -3481,8 +3507,8 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                                         "unfailable commands failed.\n");
                 return ret;
         }
-        queue_trb(xhci, xhci->cmd_ring, false, false, field1, field2, field3,
-                        field4 | xhci->cmd_ring->cycle_state);
+        queue_trb(xhci, xhci->cmd_ring, false, false, false, field1, field2,
+                        field3, field4 | xhci->cmd_ring->cycle_state);
         return 0;
 }
 
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 3a0f695138f4..aa94c0195791 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -175,28 +175,19 @@ int xhci_reset(struct xhci_hcd *xhci)
         return handshake(xhci, &xhci->op_regs->status, STS_CNR, 0, 250 * 1000);
 }
 
-/*
- * Free IRQs
- * free all IRQs request
- */
-static void xhci_free_irq(struct xhci_hcd *xhci)
+#ifdef CONFIG_PCI
+static int xhci_free_msi(struct xhci_hcd *xhci)
 {
         int i;
-        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
 
-        /* return if using legacy interrupt */
-        if (xhci_to_hcd(xhci)->irq >= 0)
-                return;
-
-        if (xhci->msix_entries) {
-                for (i = 0; i < xhci->msix_count; i++)
-                        if (xhci->msix_entries[i].vector)
-                                free_irq(xhci->msix_entries[i].vector,
-                                                xhci_to_hcd(xhci));
-        } else if (pdev->irq >= 0)
-                free_irq(pdev->irq, xhci_to_hcd(xhci));
+        if (!xhci->msix_entries)
+                return -EINVAL;
 
-        return;
+        for (i = 0; i < xhci->msix_count; i++)
+                if (xhci->msix_entries[i].vector)
+                        free_irq(xhci->msix_entries[i].vector,
+                                        xhci_to_hcd(xhci));
+        return 0;
 }
 
 /*
@@ -224,6 +215,28 @@ static int xhci_setup_msi(struct xhci_hcd *xhci)
 }
 
 /*
+ * Free IRQs
+ * free all IRQs request
+ */
+static void xhci_free_irq(struct xhci_hcd *xhci)
+{
+        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        int ret;
+
+        /* return if using legacy interrupt */
+        if (xhci_to_hcd(xhci)->irq >= 0)
+                return;
+
+        ret = xhci_free_msi(xhci);
+        if (!ret)
+                return;
+        if (pdev->irq >= 0)
+                free_irq(pdev->irq, xhci_to_hcd(xhci));
+
+        return;
+}
+
+/*
  * Set up MSI-X
  */
 static int xhci_setup_msix(struct xhci_hcd *xhci)
@@ -302,6 +315,72 @@ static void xhci_cleanup_msix(struct xhci_hcd *xhci)
         return;
 }
 
+static void xhci_msix_sync_irqs(struct xhci_hcd *xhci)
+{
+        int i;
+
+        if (xhci->msix_entries) {
+                for (i = 0; i < xhci->msix_count; i++)
+                        synchronize_irq(xhci->msix_entries[i].vector);
+        }
+}
+
+static int xhci_try_enable_msi(struct usb_hcd *hcd)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        int ret;
+
+        /*
+         * Some Fresco Logic host controllers advertise MSI, but fail to
+         * generate interrupts.  Don't even try to enable MSI.
+         */
+        if (xhci->quirks & XHCI_BROKEN_MSI)
+                return 0;
+
+        /* unregister the legacy interrupt */
+        if (hcd->irq)
+                free_irq(hcd->irq, hcd);
+        hcd->irq = -1;
+
+        ret = xhci_setup_msix(xhci);
+        if (ret)
+                /* fall back to msi*/
+                ret = xhci_setup_msi(xhci);
+
+        if (!ret)
+                /* hcd->irq is -1, we have MSI */
+                return 0;
+
+        /* fall back to legacy interrupt*/
+        ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
+                        hcd->irq_descr, hcd);
+        if (ret) {
+                xhci_err(xhci, "request interrupt %d failed\n",
+                                pdev->irq);
+                return ret;
+        }
+        hcd->irq = pdev->irq;
+        return 0;
+}
+
+#else
+
+static int xhci_try_enable_msi(struct usb_hcd *hcd)
+{
+        return 0;
+}
+
+static void xhci_cleanup_msix(struct xhci_hcd *xhci)
+{
+}
+
+static void xhci_msix_sync_irqs(struct xhci_hcd *xhci)
+{
+}
+
+#endif
+
 /*
  * Initialize memory for HCD and xHC (one-time init).
  *
@@ -316,7 +395,7 @@ int xhci_init(struct usb_hcd *hcd)
 
         xhci_dbg(xhci, "xhci_init\n");
         spin_lock_init(&xhci->lock);
-        if (link_quirk) {
+        if (xhci->hci_version == 0x95 && link_quirk) {
                 xhci_dbg(xhci, "QUIRK: Not clearing Link TRB chain bits.\n");
                 xhci->quirks |= XHCI_LINK_TRB_QUIRK;
         } else {
@@ -413,9 +492,8 @@ int xhci_run(struct usb_hcd *hcd)
 {
         u32 temp;
         u64 temp_64;
-        u32 ret;
+        int ret;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
 
         /* Start the xHCI host controller running only after the USB 2.0 roothub
          * is setup.
@@ -426,34 +504,10 @@ int xhci_run(struct usb_hcd *hcd)
                 return xhci_run_finished(xhci);
 
         xhci_dbg(xhci, "xhci_run\n");
-        /* unregister the legacy interrupt */
-        if (hcd->irq)
-                free_irq(hcd->irq, hcd);
-        hcd->irq = -1;
 
-        /* Some Fresco Logic host controllers advertise MSI, but fail to
-         * generate interrupts.  Don't even try to enable MSI.
-         */
-        if (xhci->quirks & XHCI_BROKEN_MSI)
-                goto legacy_irq;
-
-        ret = xhci_setup_msix(xhci);
+        ret = xhci_try_enable_msi(hcd);
         if (ret)
-                /* fall back to msi*/
-                ret = xhci_setup_msi(xhci);
-
-        if (ret) {
-legacy_irq:
-                /* fall back to legacy interrupt*/
-                ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
-                                        hcd->irq_descr, hcd);
-                if (ret) {
-                        xhci_err(xhci, "request interrupt %d failed\n",
-                                        pdev->irq);
-                        return ret;
-                }
-                hcd->irq = pdev->irq;
-        }
+                return ret;
 
 #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
         init_timer(&xhci->event_ring_timer);
@@ -694,7 +748,6 @@ int xhci_suspend(struct xhci_hcd *xhci)
         int                     rc = 0;
         struct usb_hcd          *hcd = xhci_to_hcd(xhci);
         u32                     command;
-        int                     i;
 
         spin_lock_irq(&xhci->lock);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
@@ -730,10 +783,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
 
         /* step 5: remove core well power */
         /* synchronize irq when using MSI-X */
-        if (xhci->msix_entries) {
-                for (i = 0; i < xhci->msix_count; i++)
-                        synchronize_irq(xhci->msix_entries[i].vector);
-        }
+        xhci_msix_sync_irqs(xhci);
 
         return rc;
 }
@@ -749,7 +799,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         u32                     command, temp = 0;
         struct usb_hcd          *hcd = xhci_to_hcd(xhci);
         struct usb_hcd          *secondary_hcd;
-        int                     retval;
+        int                     retval = 0;
 
         /* Wait a bit if either of the roothubs need to settle from the
          * transition into bus suspend.
@@ -759,6 +809,9 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                                 xhci->bus_state[1].next_statechange))
                 msleep(100);
 
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
+
         spin_lock_irq(&xhci->lock);
         if (xhci->quirks & XHCI_RESET_ON_RESUME)
                 hibernated = true;
@@ -828,20 +881,13 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                         return retval;
                 xhci_dbg(xhci, "Start the primary HCD\n");
                 retval = xhci_run(hcd->primary_hcd);
-                if (retval)
-                        goto failed_restart;
-
-                xhci_dbg(xhci, "Start the secondary HCD\n");
-                retval = xhci_run(secondary_hcd);
                 if (!retval) {
-                        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-                        set_bit(HCD_FLAG_HW_ACCESSIBLE,
-                                        &xhci->shared_hcd->flags);
+                        xhci_dbg(xhci, "Start the secondary HCD\n");
+                        retval = xhci_run(secondary_hcd);
                 }
-failed_restart:
                 hcd->state = HC_STATE_SUSPENDED;
                 xhci->shared_hcd->state = HC_STATE_SUSPENDED;
-                return retval;
+                goto done;
         }
 
         /* step 4: set Run/Stop bit */
@@ -860,11 +906,14 @@ failed_restart:
          * Running endpoints by ringing their doorbells
          */
 
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
-
         spin_unlock_irq(&xhci->lock);
-        return 0;
+
+ done:
+        if (retval == 0) {
+                usb_hcd_resume_root_hub(hcd);
+                usb_hcd_resume_root_hub(xhci->shared_hcd);
+        }
+        return retval;
 }
 #endif  /* CONFIG_PM */
 
@@ -945,8 +994,7 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
                 return -ENODEV;
 
         if (check_virt_dev) {
-                if (!udev->slot_id || !xhci->devs
-                        || !xhci->devs[udev->slot_id]) {
+                if (!udev->slot_id || !xhci->devs[udev->slot_id]) {
                         printk(KERN_DEBUG "xHCI %s called with unaddressed "
                                                 "device\n", func);
                         return -EINVAL;
@@ -987,7 +1035,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
         out_ctx = xhci->devs[slot_id]->out_ctx;
         ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
         hw_max_packet_size = MAX_PACKET_DECODED(le32_to_cpu(ep_ctx->ep_info2));
-        max_packet_size = le16_to_cpu(urb->dev->ep0.desc.wMaxPacketSize);
+        max_packet_size = usb_endpoint_maxp(&urb->dev->ep0.desc);
         if (hw_max_packet_size != max_packet_size) {
                 xhci_dbg(xhci, "Max Packet Size for ep 0 changed.\n");
                 xhci_dbg(xhci, "Max packet size in usb_device = %d\n",
@@ -1035,6 +1083,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
 int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct xhci_td *buffer;
         unsigned long flags;
         int ret = 0;
         unsigned int slot_id, ep_index;
@@ -1065,13 +1114,15 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
         if (!urb_priv)
                 return -ENOMEM;
 
+        buffer = kzalloc(size * sizeof(struct xhci_td), mem_flags);
+        if (!buffer) {
+                kfree(urb_priv);
+                return -ENOMEM;
+        }
+
         for (i = 0; i < size; i++) {
-                urb_priv->td[i] = kzalloc(sizeof(struct xhci_td), mem_flags);
-                if (!urb_priv->td[i]) {
-                        urb_priv->length = i;
-                        xhci_urb_free_priv(xhci, urb_priv);
-                        return -ENOMEM;
-                }
+                urb_priv->td[i] = buffer;
+                buffer++;
         }
 
         urb_priv->length = size;
@@ -1747,6 +1798,564 @@ static void xhci_finish_resource_reservation(struct xhci_hcd *xhci,
                                 xhci->num_active_eps);
 }
 
+unsigned int xhci_get_block_size(struct usb_device *udev)
+{
+        switch (udev->speed) {
+        case USB_SPEED_LOW:
+        case USB_SPEED_FULL:
+                return FS_BLOCK;
+        case USB_SPEED_HIGH:
+                return HS_BLOCK;
+        case USB_SPEED_SUPER:
+                return SS_BLOCK;
+        case USB_SPEED_UNKNOWN:
+        case USB_SPEED_WIRELESS:
+        default:
+                /* Should never happen */
+                return 1;
+        }
+}
+
+unsigned int xhci_get_largest_overhead(struct xhci_interval_bw *interval_bw)
+{
+        if (interval_bw->overhead[LS_OVERHEAD_TYPE])
+                return LS_OVERHEAD;
+        if (interval_bw->overhead[FS_OVERHEAD_TYPE])
+                return FS_OVERHEAD;
+        return HS_OVERHEAD;
+}
+
+/* If we are changing a LS/FS device under a HS hub,
+ * make sure (if we are activating a new TT) that the HS bus has enough
+ * bandwidth for this new TT.
+ */
+static int xhci_check_tt_bw_table(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                int old_active_eps)
+{
+        struct xhci_interval_bw_table *bw_table;
+        struct xhci_tt_bw_info *tt_info;
+
+        /* Find the bandwidth table for the root port this TT is attached to. */
+        bw_table = &xhci->rh_bw[virt_dev->real_port - 1].bw_table;
+        tt_info = virt_dev->tt_info;
+        /* If this TT already had active endpoints, the bandwidth for this TT
+         * has already been added.  Removing all periodic endpoints (and thus
+         * making the TT enactive) will only decrease the bandwidth used.
+         */
+        if (old_active_eps)
+                return 0;
+        if (old_active_eps == 0 && tt_info->active_eps != 0) {
+                if (bw_table->bw_used + TT_HS_OVERHEAD > HS_BW_LIMIT)
+                        return -ENOMEM;
+                return 0;
+        }
+        /* Not sure why we would have no new active endpoints...
+         *
+         * Maybe because of an Evaluate Context change for a hub update or a
+         * control endpoint 0 max packet size change?
+         * FIXME: skip the bandwidth calculation in that case.
+         */
+        return 0;
+}
+
+static int xhci_check_ss_bw(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev)
+{
+        unsigned int bw_reserved;
+
+        bw_reserved = DIV_ROUND_UP(SS_BW_RESERVED*SS_BW_LIMIT_IN, 100);
+        if (virt_dev->bw_table->ss_bw_in > (SS_BW_LIMIT_IN - bw_reserved))
+                return -ENOMEM;
+
+        bw_reserved = DIV_ROUND_UP(SS_BW_RESERVED*SS_BW_LIMIT_OUT, 100);
+        if (virt_dev->bw_table->ss_bw_out > (SS_BW_LIMIT_OUT - bw_reserved))
+                return -ENOMEM;
+
+        return 0;
+}
+
+/*
+ * This algorithm is a very conservative estimate of the worst-case scheduling
+ * scenario for any one interval.  The hardware dynamically schedules the
+ * packets, so we can't tell which microframe could be the limiting factor in
+ * the bandwidth scheduling.  This only takes into account periodic endpoints.
+ *
+ * Obviously, we can't solve an NP complete problem to find the minimum worst
+ * case scenario.  Instead, we come up with an estimate that is no less than
+ * the worst case bandwidth used for any one microframe, but may be an
+ * over-estimate.
+ *
+ * We walk the requirements for each endpoint by interval, starting with the
+ * smallest interval, and place packets in the schedule where there is only one
+ * possible way to schedule packets for that interval.  In order to simplify
+ * this algorithm, we record the largest max packet size for each interval, and
+ * assume all packets will be that size.
+ *
+ * For interval 0, we obviously must schedule all packets for each interval.
+ * The bandwidth for interval 0 is just the amount of data to be transmitted
+ * (the sum of all max ESIT payload sizes, plus any overhead per packet times
+ * the number of packets).
+ *
+ * For interval 1, we have two possible microframes to schedule those packets
+ * in.  For this algorithm, if we can schedule the same number of packets for
+ * each possible scheduling opportunity (each microframe), we will do so.  The
+ * remaining number of packets will be saved to be transmitted in the gaps in
+ * the next interval's scheduling sequence.
+ *
+ * As we move those remaining packets to be scheduled with interval 2 packets,
+ * we have to double the number of remaining packets to transmit.  This is
+ * because the intervals are actually powers of 2, and we would be transmitting
+ * the previous interval's packets twice in this interval.  We also have to be
+ * sure that when we look at the largest max packet size for this interval, we
+ * also look at the largest max packet size for the remaining packets and take
+ * the greater of the two.
+ *
+ * The algorithm continues to evenly distribute packets in each scheduling
+ * opportunity, and push the remaining packets out, until we get to the last
+ * interval.  Then those packets and their associated overhead are just added
+ * to the bandwidth used.
+ */
+static int xhci_check_bw_table(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                int old_active_eps)
+{
+        unsigned int bw_reserved;
+        unsigned int max_bandwidth;
+        unsigned int bw_used;
+        unsigned int block_size;
+        struct xhci_interval_bw_table *bw_table;
+        unsigned int packet_size = 0;
+        unsigned int overhead = 0;
+        unsigned int packets_transmitted = 0;
+        unsigned int packets_remaining = 0;
+        unsigned int i;
+
+        if (virt_dev->udev->speed == USB_SPEED_SUPER)
+                return xhci_check_ss_bw(xhci, virt_dev);
+
+        if (virt_dev->udev->speed == USB_SPEED_HIGH) {
+                max_bandwidth = HS_BW_LIMIT;
+                /* Convert percent of bus BW reserved to blocks reserved */
+                bw_reserved = DIV_ROUND_UP(HS_BW_RESERVED * max_bandwidth, 100);
+        } else {
+                max_bandwidth = FS_BW_LIMIT;
+                bw_reserved = DIV_ROUND_UP(FS_BW_RESERVED * max_bandwidth, 100);
+        }
+
+        bw_table = virt_dev->bw_table;
+        /* We need to translate the max packet size and max ESIT payloads into
+         * the units the hardware uses.
+         */
+        block_size = xhci_get_block_size(virt_dev->udev);
+
+        /* If we are manipulating a LS/FS device under a HS hub, double check
+         * that the HS bus has enough bandwidth if we are activing a new TT.
+         */
+        if (virt_dev->tt_info) {
+                xhci_dbg(xhci, "Recalculating BW for rootport %u\n",
+                                virt_dev->real_port);
+                if (xhci_check_tt_bw_table(xhci, virt_dev, old_active_eps)) {
+                        xhci_warn(xhci, "Not enough bandwidth on HS bus for "
+                                        "newly activated TT.\n");
+                        return -ENOMEM;
+                }
+                xhci_dbg(xhci, "Recalculating BW for TT slot %u port %u\n",
+                                virt_dev->tt_info->slot_id,
+                                virt_dev->tt_info->ttport);
+        } else {
+                xhci_dbg(xhci, "Recalculating BW for rootport %u\n",
+                                virt_dev->real_port);
+        }
+
+        /* Add in how much bandwidth will be used for interval zero, or the
+         * rounded max ESIT payload + number of packets * largest overhead.
+         */
+        bw_used = DIV_ROUND_UP(bw_table->interval0_esit_payload, block_size) +
+                bw_table->interval_bw[0].num_packets *
+                xhci_get_largest_overhead(&bw_table->interval_bw[0]);
+
+        for (i = 1; i < XHCI_MAX_INTERVAL; i++) {
+                unsigned int bw_added;
+                unsigned int largest_mps;
+                unsigned int interval_overhead;
+
+                /*
+                 * How many packets could we transmit in this interval?
+                 * If packets didn't fit in the previous interval, we will need
+                 * to transmit that many packets twice within this interval.
+                 */
+                packets_remaining = 2 * packets_remaining +
+                        bw_table->interval_bw[i].num_packets;
+
+                /* Find the largest max packet size of this or the previous
+                 * interval.
+                 */
+                if (list_empty(&bw_table->interval_bw[i].endpoints))
+                        largest_mps = 0;
+                else {
+                        struct xhci_virt_ep *virt_ep;
+                        struct list_head *ep_entry;
+
+                        ep_entry = bw_table->interval_bw[i].endpoints.next;
+                        virt_ep = list_entry(ep_entry,
+                                        struct xhci_virt_ep, bw_endpoint_list);
+                        /* Convert to blocks, rounding up */
+                        largest_mps = DIV_ROUND_UP(
+                                        virt_ep->bw_info.max_packet_size,
+                                        block_size);
+                }
+                if (largest_mps > packet_size)
+                        packet_size = largest_mps;
+
+                /* Use the larger overhead of this or the previous interval. */
+                interval_overhead = xhci_get_largest_overhead(
+                                &bw_table->interval_bw[i]);
+                if (interval_overhead > overhead)
+                        overhead = interval_overhead;
+
+                /* How many packets can we evenly distribute across
+                 * (1 << (i + 1)) possible scheduling opportunities?
+                 */
+                packets_transmitted = packets_remaining >> (i + 1);
+
+                /* Add in the bandwidth used for those scheduled packets */
+                bw_added = packets_transmitted * (overhead + packet_size);
+
+                /* How many packets do we have remaining to transmit? */
+                packets_remaining = packets_remaining % (1 << (i + 1));
+
+                /* What largest max packet size should those packets have? */
+                /* If we've transmitted all packets, don't carry over the
+                 * largest packet size.
+                 */
+                if (packets_remaining == 0) {
+                        packet_size = 0;
+                        overhead = 0;
+                } else if (packets_transmitted > 0) {
+                        /* Otherwise if we do have remaining packets, and we've
+                         * scheduled some packets in this interval, take the
+                         * largest max packet size from endpoints with this
+                         * interval.
+                         */
+                        packet_size = largest_mps;
+                        overhead = interval_overhead;
+                }
+                /* Otherwise carry over packet_size and overhead from the last
+                 * time we had a remainder.
+                 */
+                bw_used += bw_added;
+                if (bw_used > max_bandwidth) {
+                        xhci_warn(xhci, "Not enough bandwidth. "
+                                        "Proposed: %u, Max: %u\n",
+                                bw_used, max_bandwidth);
+                        return -ENOMEM;
+                }
+        }
+        /*
+         * Ok, we know we have some packets left over after even-handedly
+         * scheduling interval 15.  We don't know which microframes they will
+         * fit into, so we over-schedule and say they will be scheduled every
+         * microframe.
+         */
+        if (packets_remaining > 0)
+                bw_used += overhead + packet_size;
+
+        if (!virt_dev->tt_info && virt_dev->udev->speed == USB_SPEED_HIGH) {
+                unsigned int port_index = virt_dev->real_port - 1;
+
+                /* OK, we're manipulating a HS device attached to a
+                 * root port bandwidth domain.  Include the number of active TTs
+                 * in the bandwidth used.
+                 */
+                bw_used += TT_HS_OVERHEAD *
+                        xhci->rh_bw[port_index].num_active_tts;
+        }
+
+        xhci_dbg(xhci, "Final bandwidth: %u, Limit: %u, Reserved: %u, "
+                "Available: %u " "percent\n",
+                bw_used, max_bandwidth, bw_reserved,
+                (max_bandwidth - bw_used - bw_reserved) * 100 /
+                max_bandwidth);
+
+        bw_used += bw_reserved;
+        if (bw_used > max_bandwidth) {
+                xhci_warn(xhci, "Not enough bandwidth. Proposed: %u, Max: %u\n",
+                                bw_used, max_bandwidth);
+                return -ENOMEM;
+        }
+
+        bw_table->bw_used = bw_used;
+        return 0;
+}
+
+static bool xhci_is_async_ep(unsigned int ep_type)
+{
+        return (ep_type != ISOC_OUT_EP && ep_type != INT_OUT_EP &&
+                                        ep_type != ISOC_IN_EP &&
+                                        ep_type != INT_IN_EP);
+}
+
+static bool xhci_is_sync_in_ep(unsigned int ep_type)
+{
+        return (ep_type == ISOC_IN_EP || ep_type != INT_IN_EP);
+}
+
+static unsigned int xhci_get_ss_bw_consumed(struct xhci_bw_info *ep_bw)
+{
+        unsigned int mps = DIV_ROUND_UP(ep_bw->max_packet_size, SS_BLOCK);
+
+        if (ep_bw->ep_interval == 0)
+                return SS_OVERHEAD_BURST +
+                        (ep_bw->mult * ep_bw->num_packets *
+                                        (SS_OVERHEAD + mps));
+        return DIV_ROUND_UP(ep_bw->mult * ep_bw->num_packets *
+                                (SS_OVERHEAD + mps + SS_OVERHEAD_BURST),
+                                1 << ep_bw->ep_interval);
+
+}
+
+void xhci_drop_ep_from_interval_table(struct xhci_hcd *xhci,
+                struct xhci_bw_info *ep_bw,
+                struct xhci_interval_bw_table *bw_table,
+                struct usb_device *udev,
+                struct xhci_virt_ep *virt_ep,
+                struct xhci_tt_bw_info *tt_info)
+{
+        struct xhci_interval_bw *interval_bw;
+        int normalized_interval;
+
+        if (xhci_is_async_ep(ep_bw->type))
+                return;
+
+        if (udev->speed == USB_SPEED_SUPER) {
+                if (xhci_is_sync_in_ep(ep_bw->type))
+                        xhci->devs[udev->slot_id]->bw_table->ss_bw_in -=
+                                xhci_get_ss_bw_consumed(ep_bw);
+                else
+                        xhci->devs[udev->slot_id]->bw_table->ss_bw_out -=
+                                xhci_get_ss_bw_consumed(ep_bw);
+                return;
+        }
+
+        /* SuperSpeed endpoints never get added to intervals in the table, so
+         * this check is only valid for HS/FS/LS devices.
+         */
+        if (list_empty(&virt_ep->bw_endpoint_list))
+                return;
+        /* For LS/FS devices, we need to translate the interval expressed in
+         * microframes to frames.
+         */
+        if (udev->speed == USB_SPEED_HIGH)
+                normalized_interval = ep_bw->ep_interval;
+        else
+                normalized_interval = ep_bw->ep_interval - 3;
+
+        if (normalized_interval == 0)
+                bw_table->interval0_esit_payload -= ep_bw->max_esit_payload;
+        interval_bw = &bw_table->interval_bw[normalized_interval];
+        interval_bw->num_packets -= ep_bw->num_packets;
+        switch (udev->speed) {
+        case USB_SPEED_LOW:
+                interval_bw->overhead[LS_OVERHEAD_TYPE] -= 1;
+                break;
+        case USB_SPEED_FULL:
+                interval_bw->overhead[FS_OVERHEAD_TYPE] -= 1;
+                break;
+        case USB_SPEED_HIGH:
+                interval_bw->overhead[HS_OVERHEAD_TYPE] -= 1;
+                break;
+        case USB_SPEED_SUPER:
+        case USB_SPEED_UNKNOWN:
+        case USB_SPEED_WIRELESS:
+                /* Should never happen because only LS/FS/HS endpoints will get
+                 * added to the endpoint list.
+                 */
+                return;
+        }
+        if (tt_info)
+                tt_info->active_eps -= 1;
+        list_del_init(&virt_ep->bw_endpoint_list);
+}
+
+static void xhci_add_ep_to_interval_table(struct xhci_hcd *xhci,
+                struct xhci_bw_info *ep_bw,
+                struct xhci_interval_bw_table *bw_table,
+                struct usb_device *udev,
+                struct xhci_virt_ep *virt_ep,
+                struct xhci_tt_bw_info *tt_info)
+{
+        struct xhci_interval_bw *interval_bw;
+        struct xhci_virt_ep *smaller_ep;
+        int normalized_interval;
+
+        if (xhci_is_async_ep(ep_bw->type))
+                return;
+
+        if (udev->speed == USB_SPEED_SUPER) {
+                if (xhci_is_sync_in_ep(ep_bw->type))
+                        xhci->devs[udev->slot_id]->bw_table->ss_bw_in +=
+                                xhci_get_ss_bw_consumed(ep_bw);
+                else
+                        xhci->devs[udev->slot_id]->bw_table->ss_bw_out +=
+                                xhci_get_ss_bw_consumed(ep_bw);
+                return;
+        }
+
+        /* For LS/FS devices, we need to translate the interval expressed in
+         * microframes to frames.
+         */
+        if (udev->speed == USB_SPEED_HIGH)
+                normalized_interval = ep_bw->ep_interval;
+        else
+                normalized_interval = ep_bw->ep_interval - 3;
+
+        if (normalized_interval == 0)
+                bw_table->interval0_esit_payload += ep_bw->max_esit_payload;
+        interval_bw = &bw_table->interval_bw[normalized_interval];
+        interval_bw->num_packets += ep_bw->num_packets;
+        switch (udev->speed) {
+        case USB_SPEED_LOW:
+                interval_bw->overhead[LS_OVERHEAD_TYPE] += 1;
+                break;
+        case USB_SPEED_FULL:
+                interval_bw->overhead[FS_OVERHEAD_TYPE] += 1;
+                break;
+        case USB_SPEED_HIGH:
+                interval_bw->overhead[HS_OVERHEAD_TYPE] += 1;
+                break;
+        case USB_SPEED_SUPER:
+        case USB_SPEED_UNKNOWN:
+        case USB_SPEED_WIRELESS:
+                /* Should never happen because only LS/FS/HS endpoints will get
+                 * added to the endpoint list.
+                 */
+                return;
+        }
+
+        if (tt_info)
+                tt_info->active_eps += 1;
+        /* Insert the endpoint into the list, largest max packet size first. */
+        list_for_each_entry(smaller_ep, &interval_bw->endpoints,
+                        bw_endpoint_list) {
+                if (ep_bw->max_packet_size >=
+                                smaller_ep->bw_info.max_packet_size) {
+                        /* Add the new ep before the smaller endpoint */
+                        list_add_tail(&virt_ep->bw_endpoint_list,
+                                        &smaller_ep->bw_endpoint_list);
+                        return;
+                }
+        }
+        /* Add the new endpoint at the end of the list. */
+        list_add_tail(&virt_ep->bw_endpoint_list,
+                        &interval_bw->endpoints);
+}
+
+void xhci_update_tt_active_eps(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                int old_active_eps)
+{
+        struct xhci_root_port_bw_info *rh_bw_info;
+        if (!virt_dev->tt_info)
+                return;
+
+        rh_bw_info = &xhci->rh_bw[virt_dev->real_port - 1];
+        if (old_active_eps == 0 &&
+                                virt_dev->tt_info->active_eps != 0) {
+                rh_bw_info->num_active_tts += 1;
+                rh_bw_info->bw_table.bw_used += TT_HS_OVERHEAD;
+        } else if (old_active_eps != 0 &&
+                                virt_dev->tt_info->active_eps == 0) {
+                rh_bw_info->num_active_tts -= 1;
+                rh_bw_info->bw_table.bw_used -= TT_HS_OVERHEAD;
+        }
+}
+
+static int xhci_reserve_bandwidth(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                struct xhci_container_ctx *in_ctx)
+{
+        struct xhci_bw_info ep_bw_info[31];
+        int i;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        int old_active_eps = 0;
+
+        if (virt_dev->tt_info)
+                old_active_eps = virt_dev->tt_info->active_eps;
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+
+        for (i = 0; i < 31; i++) {
+                if (!EP_IS_ADDED(ctrl_ctx, i) && !EP_IS_DROPPED(ctrl_ctx, i))
+                        continue;
+
+                /* Make a copy of the BW info in case we need to revert this */
+                memcpy(&ep_bw_info[i], &virt_dev->eps[i].bw_info,
+                                sizeof(ep_bw_info[i]));
+                /* Drop the endpoint from the interval table if the endpoint is
+                 * being dropped or changed.
+                 */
+                if (EP_IS_DROPPED(ctrl_ctx, i))
+                        xhci_drop_ep_from_interval_table(xhci,
+                                        &virt_dev->eps[i].bw_info,
+                                        virt_dev->bw_table,
+                                        virt_dev->udev,
+                                        &virt_dev->eps[i],
+                                        virt_dev->tt_info);
+        }
+        /* Overwrite the information stored in the endpoints' bw_info */
+        xhci_update_bw_info(xhci, virt_dev->in_ctx, ctrl_ctx, virt_dev);
+        for (i = 0; i < 31; i++) {
+                /* Add any changed or added endpoints to the interval table */
+                if (EP_IS_ADDED(ctrl_ctx, i))
+                        xhci_add_ep_to_interval_table(xhci,
+                                        &virt_dev->eps[i].bw_info,
+                                        virt_dev->bw_table,
+                                        virt_dev->udev,
+                                        &virt_dev->eps[i],
+                                        virt_dev->tt_info);
+        }
+
+        if (!xhci_check_bw_table(xhci, virt_dev, old_active_eps)) {
+                /* Ok, this fits in the bandwidth we have.
+                 * Update the number of active TTs.
+                 */
+                xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps);
+                return 0;
+        }
+
+        /* We don't have enough bandwidth for this, revert the stored info. */
+        for (i = 0; i < 31; i++) {
+                if (!EP_IS_ADDED(ctrl_ctx, i) && !EP_IS_DROPPED(ctrl_ctx, i))
+                        continue;
+
+                /* Drop the new copies of any added or changed endpoints from
+                 * the interval table.
+                 */
+                if (EP_IS_ADDED(ctrl_ctx, i)) {
+                        xhci_drop_ep_from_interval_table(xhci,
+                                        &virt_dev->eps[i].bw_info,
+                                        virt_dev->bw_table,
+                                        virt_dev->udev,
+                                        &virt_dev->eps[i],
+                                        virt_dev->tt_info);
+                }
+                /* Revert the endpoint back to its old information */
+                memcpy(&virt_dev->eps[i].bw_info, &ep_bw_info[i],
+                                sizeof(ep_bw_info[i]));
+                /* Add any changed or dropped endpoints back into the table */
+                if (EP_IS_DROPPED(ctrl_ctx, i))
+                        xhci_add_ep_to_interval_table(xhci,
+                                        &virt_dev->eps[i].bw_info,
+                                        virt_dev->bw_table,
+                                        virt_dev->udev,
+                                        &virt_dev->eps[i],
+                                        virt_dev->tt_info);
+        }
+        return -ENOMEM;
+}
+
+
 /* Issue a configure endpoint command or evaluate context command
  * and wait for it to finish.
  */
@@ -1765,17 +2374,30 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
 
         spin_lock_irqsave(&xhci->lock, flags);
         virt_dev = xhci->devs[udev->slot_id];
-        if (command) {
+
+        if (command)
                 in_ctx = command->in_ctx;
-                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
-                                xhci_reserve_host_resources(xhci, in_ctx)) {
-                        spin_unlock_irqrestore(&xhci->lock, flags);
-                        xhci_warn(xhci, "Not enough host resources, "
-                                        "active endpoint contexts = %u\n",
-                                        xhci->num_active_eps);
-                        return -ENOMEM;
-                }
+        else
+                in_ctx = virt_dev->in_ctx;
 
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
+                        xhci_reserve_host_resources(xhci, in_ctx)) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_warn(xhci, "Not enough host resources, "
+                                "active endpoint contexts = %u\n",
+                                xhci->num_active_eps);
+                return -ENOMEM;
+        }
+        if ((xhci->quirks & XHCI_SW_BW_CHECKING) &&
+                        xhci_reserve_bandwidth(xhci, virt_dev, in_ctx)) {
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
+                        xhci_free_host_resources(xhci, in_ctx);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_warn(xhci, "Not enough bandwidth\n");
+                return -ENOMEM;
+        }
+
+        if (command) {
                 cmd_completion = command->completion;
                 cmd_status = &command->status;
                 command->command_trb = xhci->cmd_ring->enqueue;
@@ -1789,15 +2411,6 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
 
                 list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
         } else {
-                in_ctx = virt_dev->in_ctx;
-                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
-                                xhci_reserve_host_resources(xhci, in_ctx)) {
-                        spin_unlock_irqrestore(&xhci->lock, flags);
-                        xhci_warn(xhci, "Not enough host resources, "
-                                        "active endpoint contexts = %u\n",
-                                        xhci->num_active_eps);
-                        return -ENOMEM;
-                }
                 cmd_completion = &virt_dev->cmd_completion;
                 cmd_status = &virt_dev->cmd_status;
         }
@@ -1888,6 +2501,12 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
         ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
         ctrl_ctx->drop_flags &= cpu_to_le32(~(SLOT_FLAG | EP0_FLAG));
+
+        /* Don't issue the command if there's no endpoints to update. */
+        if (ctrl_ctx->add_flags == cpu_to_le32(SLOT_FLAG) &&
+                        ctrl_ctx->drop_flags == 0)
+                return 0;
+
         xhci_dbg(xhci, "New Input Control Context:\n");
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
@@ -2525,6 +3144,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         int timeleft;
         int last_freed_endpoint;
         struct xhci_slot_ctx *slot_ctx;
+        int old_active_eps = 0;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, false, __func__);
         if (ret <= 0)
@@ -2666,7 +3286,18 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                         xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
                         last_freed_endpoint = i;
                 }
-        }
+                if (!list_empty(&virt_dev->eps[i].bw_endpoint_list))
+                        xhci_drop_ep_from_interval_table(xhci,
+                                        &virt_dev->eps[i].bw_info,
+                                        virt_dev->bw_table,
+                                        udev,
+                                        &virt_dev->eps[i],
+                                        virt_dev->tt_info);
+                xhci_clear_endpoint_bw_info(&virt_dev->eps[i].bw_info);
+        }
+        /* If necessary, update the number of active TTs on this root port */
+        xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps);
+
         xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
         ret = 0;
@@ -2704,6 +3335,11 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 del_timer_sync(&virt_dev->eps[i].stop_cmd_timer);
         }
 
+        if (udev->usb2_hw_lpm_enabled) {
+                xhci_set_usb2_hardware_lpm(hcd, udev, 0);
+                udev->usb2_hw_lpm_enabled = 0;
+        }
+
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
         state = xhci_readl(xhci, &xhci->op_regs->status);
@@ -2867,6 +3503,10 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         /* Otherwise, update the control endpoint ring enqueue pointer. */
         else
                 xhci_copy_ep0_dequeue_into_input_ctx(xhci, udev);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
+        ctrl_ctx->drop_flags = 0;
+
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
 
@@ -2889,7 +3529,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
          * command on a timeout.
          */
         if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for a slot\n",
+                xhci_warn(xhci, "%s while waiting for address device command\n",
                                 timeleft == 0 ? "Timeout" : "Signal");
                 /* FIXME cancel the address device command */
                 return -ETIME;
@@ -2948,7 +3588,6 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         virt_dev->address = (le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK)
                 + 1;
         /* Zero the input context control for later use */
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         ctrl_ctx->add_flags = 0;
         ctrl_ctx->drop_flags = 0;
 
@@ -2957,6 +3596,254 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         return 0;
 }
 
+#ifdef CONFIG_USB_SUSPEND
+
+/* BESL to HIRD Encoding array for USB2 LPM */
+static int xhci_besl_encoding[16] = {125, 150, 200, 300, 400, 500, 1000, 2000,
+        3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000};
+
+/* Calculate HIRD/BESL for USB2 PORTPMSC*/
+static int xhci_calculate_hird_besl(int u2del, bool use_besl)
+{
+        int hird;
+
+        if (use_besl) {
+                for (hird = 0; hird < 16; hird++) {
+                        if (xhci_besl_encoding[hird] >= u2del)
+                                break;
+                }
+        } else {
+                if (u2del <= 50)
+                        hird = 0;
+                else
+                        hird = (u2del - 51) / 75 + 1;
+
+                if (hird > 15)
+                        hird = 15;
+        }
+
+        return hird;
+}
+
+static int xhci_usb2_software_lpm_test(struct usb_hcd *hcd,
+                                        struct usb_device *udev)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct dev_info *dev_info;
+        __le32 __iomem  **port_array;
+        __le32 __iomem  *addr, *pm_addr;
+        u32             temp, dev_id;
+        unsigned int    port_num;
+        unsigned long   flags;
+        int             u2del, hird;
+        int             ret;
+
+        if (hcd->speed == HCD_USB3 || !xhci->sw_lpm_support ||
+                        !udev->lpm_capable)
+                return -EINVAL;
+
+        /* we only support lpm for non-hub device connected to root hub yet */
+        if (!udev->parent || udev->parent->parent ||
+                        udev->descriptor.bDeviceClass == USB_CLASS_HUB)
+                return -EINVAL;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        /* Look for devices in lpm_failed_devs list */
+        dev_id = le16_to_cpu(udev->descriptor.idVendor) << 16 |
+                        le16_to_cpu(udev->descriptor.idProduct);
+        list_for_each_entry(dev_info, &xhci->lpm_failed_devs, list) {
+                if (dev_info->dev_id == dev_id) {
+                        ret = -EINVAL;
+                        goto finish;
+                }
+        }
+
+        port_array = xhci->usb2_ports;
+        port_num = udev->portnum - 1;
+
+        if (port_num > HCS_MAX_PORTS(xhci->hcs_params1)) {
+                xhci_dbg(xhci, "invalid port number %d\n", udev->portnum);
+                ret = -EINVAL;
+                goto finish;
+        }
+
+        /*
+         * Test USB 2.0 software LPM.
+         * FIXME: some xHCI 1.0 hosts may implement a new register to set up
+         * hardware-controlled USB 2.0 LPM. See section 5.4.11 and 4.23.5.1.1.1
+         * in the June 2011 errata release.
+         */
+        xhci_dbg(xhci, "test port %d software LPM\n", port_num);
+        /*
+         * Set L1 Device Slot and HIRD/BESL.
+         * Check device's USB 2.0 extension descriptor to determine whether
+         * HIRD or BESL shoule be used. See USB2.0 LPM errata.
+         */
+        pm_addr = port_array[port_num] + 1;
+        u2del = HCS_U2_LATENCY(xhci->hcs_params3);
+        if (le32_to_cpu(udev->bos->ext_cap->bmAttributes) & (1 << 2))
+                hird = xhci_calculate_hird_besl(u2del, 1);
+        else
+                hird = xhci_calculate_hird_besl(u2del, 0);
+
+        temp = PORT_L1DS(udev->slot_id) | PORT_HIRD(hird);
+        xhci_writel(xhci, temp, pm_addr);
+
+        /* Set port link state to U2(L1) */
+        addr = port_array[port_num];
+        xhci_set_link_state(xhci, port_array, port_num, XDEV_U2);
+
+        /* wait for ACK */
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        msleep(10);
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        /* Check L1 Status */
+        ret = handshake(xhci, pm_addr, PORT_L1S_MASK, PORT_L1S_SUCCESS, 125);
+        if (ret != -ETIMEDOUT) {
+                /* enter L1 successfully */
+                temp = xhci_readl(xhci, addr);
+                xhci_dbg(xhci, "port %d entered L1 state, port status 0x%x\n",
+                                port_num, temp);
+                ret = 0;
+        } else {
+                temp = xhci_readl(xhci, pm_addr);
+                xhci_dbg(xhci, "port %d software lpm failed, L1 status %d\n",
+                                port_num, temp & PORT_L1S_MASK);
+                ret = -EINVAL;
+        }
+
+        /* Resume the port */
+        xhci_set_link_state(xhci, port_array, port_num, XDEV_U0);
+
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        msleep(10);
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        /* Clear PLC */
+        xhci_test_and_clear_bit(xhci, port_array, port_num, PORT_PLC);
+
+        /* Check PORTSC to make sure the device is in the right state */
+        if (!ret) {
+                temp = xhci_readl(xhci, addr);
+                xhci_dbg(xhci, "resumed port %d status 0x%x\n", port_num, temp);
+                if (!(temp & PORT_CONNECT) || !(temp & PORT_PE) ||
+                                (temp & PORT_PLS_MASK) != XDEV_U0) {
+                        xhci_dbg(xhci, "port L1 resume fail\n");
+                        ret = -EINVAL;
+                }
+        }
+
+        if (ret) {
+                /* Insert dev to lpm_failed_devs list */
+                xhci_warn(xhci, "device LPM test failed, may disconnect and "
+                                "re-enumerate\n");
+                dev_info = kzalloc(sizeof(struct dev_info), GFP_ATOMIC);
+                if (!dev_info) {
+                        ret = -ENOMEM;
+                        goto finish;
+                }
+                dev_info->dev_id = dev_id;
+                INIT_LIST_HEAD(&dev_info->list);
+                list_add(&dev_info->list, &xhci->lpm_failed_devs);
+        } else {
+                xhci_ring_device(xhci, udev->slot_id);
+        }
+
+finish:
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return ret;
+}
+
+int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
+                        struct usb_device *udev, int enable)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        __le32 __iomem  **port_array;
+        __le32 __iomem  *pm_addr;
+        u32             temp;
+        unsigned int    port_num;
+        unsigned long   flags;
+        int             u2del, hird;
+
+        if (hcd->speed == HCD_USB3 || !xhci->hw_lpm_support ||
+                        !udev->lpm_capable)
+                return -EPERM;
+
+        if (!udev->parent || udev->parent->parent ||
+                        udev->descriptor.bDeviceClass == USB_CLASS_HUB)
+                return -EPERM;
+
+        if (udev->usb2_hw_lpm_capable != 1)
+                return -EPERM;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        port_array = xhci->usb2_ports;
+        port_num = udev->portnum - 1;
+        pm_addr = port_array[port_num] + 1;
+        temp = xhci_readl(xhci, pm_addr);
+
+        xhci_dbg(xhci, "%s port %d USB2 hardware LPM\n",
+                        enable ? "enable" : "disable", port_num);
+
+        u2del = HCS_U2_LATENCY(xhci->hcs_params3);
+        if (le32_to_cpu(udev->bos->ext_cap->bmAttributes) & (1 << 2))
+                hird = xhci_calculate_hird_besl(u2del, 1);
+        else
+                hird = xhci_calculate_hird_besl(u2del, 0);
+
+        if (enable) {
+                temp &= ~PORT_HIRD_MASK;
+                temp |= PORT_HIRD(hird) | PORT_RWE;
+                xhci_writel(xhci, temp, pm_addr);
+                temp = xhci_readl(xhci, pm_addr);
+                temp |= PORT_HLE;
+                xhci_writel(xhci, temp, pm_addr);
+        } else {
+                temp &= ~(PORT_HLE | PORT_RWE | PORT_HIRD_MASK);
+                xhci_writel(xhci, temp, pm_addr);
+        }
+
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return 0;
+}
+
+int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        int             ret;
+
+        ret = xhci_usb2_software_lpm_test(hcd, udev);
+        if (!ret) {
+                xhci_dbg(xhci, "software LPM test succeed\n");
+                if (xhci->hw_lpm_support == 1) {
+                        udev->usb2_hw_lpm_capable = 1;
+                        ret = xhci_set_usb2_hardware_lpm(hcd, udev, 1);
+                        if (!ret)
+                                udev->usb2_hw_lpm_enabled = 1;
+                }
+        }
+
+        return 0;
+}
+
+#else
+
+int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
+                                struct usb_device *udev, int enable)
+{
+        return 0;
+}
+
+int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        return 0;
+}
+
+#endif /* CONFIG_USB_SUSPEND */
+
 /* Once a hub descriptor is fetched for a device, we need to update the xHC's
  * internal data structures for the device.
  */
@@ -2988,6 +3875,14 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
         }
 
         spin_lock_irqsave(&xhci->lock, flags);
+        if (hdev->speed == USB_SPEED_HIGH &&
+                        xhci_alloc_tt_info(xhci, vdev, hdev, tt, GFP_ATOMIC)) {
+                xhci_dbg(xhci, "Could not allocate xHCI TT structure.\n");
+                xhci_free_command(xhci, config_cmd);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return -ENOMEM;
+        }
+
         xhci_slot_copy(xhci, config_cmd->in_ctx, vdev->out_ctx);
         ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx);
         ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
@@ -3051,22 +3946,108 @@ int xhci_get_frame(struct usb_hcd *hcd)
         return xhci_readl(xhci, &xhci->run_regs->microframe_index) >> 3;
 }
 
+int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
+{
+        struct xhci_hcd         *xhci;
+        struct device           *dev = hcd->self.controller;
+        int                     retval;
+        u32                     temp;
+
+        hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
+
+        if (usb_hcd_is_primary_hcd(hcd)) {
+                xhci = kzalloc(sizeof(struct xhci_hcd), GFP_KERNEL);
+                if (!xhci)
+                        return -ENOMEM;
+                *((struct xhci_hcd **) hcd->hcd_priv) = xhci;
+                xhci->main_hcd = hcd;
+                /* Mark the first roothub as being USB 2.0.
+                 * The xHCI driver will register the USB 3.0 roothub.
+                 */
+                hcd->speed = HCD_USB2;
+                hcd->self.root_hub->speed = USB_SPEED_HIGH;
+                /*
+                 * USB 2.0 roothub under xHCI has an integrated TT,
+                 * (rate matching hub) as opposed to having an OHCI/UHCI
+                 * companion controller.
+                 */
+                hcd->has_tt = 1;
+        } else {
+                /* xHCI private pointer was set in xhci_pci_probe for the second
+                 * registered roothub.
+                 */
+                xhci = hcd_to_xhci(hcd);
+                temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+                if (HCC_64BIT_ADDR(temp)) {
+                        xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
+                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
+                } else {
+                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
+                }
+                return 0;
+        }
+
+        xhci->cap_regs = hcd->regs;
+        xhci->op_regs = hcd->regs +
+                HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
+        xhci->run_regs = hcd->regs +
+                (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
+        /* Cache read-only capability registers */
+        xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
+        xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
+        xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
+        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        xhci->hci_version = HC_VERSION(xhci->hcc_params);
+        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+        xhci_print_registers(xhci);
+
+        get_quirks(dev, xhci);
+
+        /* Make sure the HC is halted. */
+        retval = xhci_halt(xhci);
+        if (retval)
+                goto error;
+
+        xhci_dbg(xhci, "Resetting HCD\n");
+        /* Reset the internal HC memory state and registers. */
+        retval = xhci_reset(xhci);
+        if (retval)
+                goto error;
+        xhci_dbg(xhci, "Reset complete\n");
+
+        temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+        if (HCC_64BIT_ADDR(temp)) {
+                xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
+                dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
+        } else {
+                dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
+        }
+
+        xhci_dbg(xhci, "Calling HCD init\n");
+        /* Initialize HCD and host controller data structures. */
+        retval = xhci_init(hcd);
+        if (retval)
+                goto error;
+        xhci_dbg(xhci, "Called HCD init\n");
+        return 0;
+error:
+        kfree(xhci);
+        return retval;
+}
+
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_LICENSE("GPL");
 
 static int __init xhci_hcd_init(void)
 {
-#ifdef CONFIG_PCI
-        int retval = 0;
+        int retval;
 
         retval = xhci_register_pci();
-
         if (retval < 0) {
                 printk(KERN_DEBUG "Problem registering PCI driver.");
                 return retval;
         }
-#endif
         /*
          * Check the compiler generated sizes of structures that must be laid
          * out in specific ways for hardware access.
@@ -3091,8 +4072,6 @@ module_init(xhci_hcd_init);
 
 static void __exit xhci_hcd_cleanup(void)
 {
-#ifdef CONFIG_PCI
         xhci_unregister_pci();
-#endif
 }
 module_exit(xhci_hcd_cleanup);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index cae8e23308bf..3c8fbd2772ea 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -272,6 +272,7 @@ struct xhci_op_regs {
  */
 #define PORT_PLS_MASK   (0xf << 5)
 #define XDEV_U0         (0x0 << 5)
+#define XDEV_U2         (0x2 << 5)
 #define XDEV_U3         (0x3 << 5)
 #define XDEV_RESUME     (0xf << 5)
 /* true: port has power (see HCC_PPC) */
@@ -362,7 +363,13 @@ struct xhci_op_regs {
 /* Bits 24:31 for port testing */
 
 /* USB2 Protocol PORTSPMSC */
-#define PORT_RWE        (1 << 0x3)
+#define PORT_L1S_MASK           7
+#define PORT_L1S_SUCCESS        1
+#define PORT_RWE                (1 << 3)
+#define PORT_HIRD(p)            (((p) & 0xf) << 4)
+#define PORT_HIRD_MASK          (0xf << 4)
+#define PORT_L1DS(p)            (((p) & 0xff) << 8)
+#define PORT_HLE                (1 << 16)
 
 /**
  * struct xhci_intr_reg - Interrupt Register Set
@@ -611,11 +618,13 @@ struct xhci_ep_ctx {
 #define EP_STATE_ERROR          4
 /* Mult - Max number of burtst within an interval, in EP companion desc. */
 #define EP_MULT(p)              (((p) & 0x3) << 8)
+#define CTX_TO_EP_MULT(p)       (((p) >> 8) & 0x3)
 /* bits 10:14 are Max Primary Streams */
 /* bit 15 is Linear Stream Array */
 /* 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 CTX_TO_EP_INTERVAL(p)   (((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) */
@@ -640,6 +649,7 @@ struct xhci_ep_ctx {
 /* bit 6 reserved */
 /* bit 7 is Host Initiate Disable - for disabling stream selection */
 #define MAX_BURST(p)    (((p)&0xff) << 8)
+#define CTX_TO_MAX_BURST(p)     (((p) >> 8) & 0xff)
 #define MAX_PACKET(p)   (((p)&0xffff) << 16)
 #define MAX_PACKET_MASK         (0xffff << 16)
 #define MAX_PACKET_DECODED(p)   (((p) >> 16) & 0xffff)
@@ -652,6 +662,7 @@ struct xhci_ep_ctx {
 /* tx_info bitmasks */
 #define AVG_TRB_LENGTH_FOR_EP(p)        ((p) & 0xffff)
 #define MAX_ESIT_PAYLOAD_FOR_EP(p)      (((p) & 0xffff) << 16)
+#define CTX_TO_MAX_ESIT_PAYLOAD(p)      (((p) >> 16) & 0xffff)
 
 /* deq bitmasks */
 #define EP_CTX_CYCLE_MASK               (1 << 0)
@@ -670,6 +681,11 @@ struct xhci_input_control_ctx {
         __le32  rsvd2[6];
 };
 
+#define EP_IS_ADDED(ctrl_ctx, i) \
+        (le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1)))
+#define EP_IS_DROPPED(ctrl_ctx, i)       \
+        (le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1)))
+
 /* Represents everything that is needed to issue a command on the command ring.
  * It's useful to pre-allocate these for commands that cannot fail due to
  * out-of-memory errors, like freeing streams.
@@ -731,6 +747,67 @@ struct xhci_stream_info {
 #define SMALL_STREAM_ARRAY_SIZE         256
 #define MEDIUM_STREAM_ARRAY_SIZE        1024
 
+/* Some Intel xHCI host controllers need software to keep track of the bus
+ * bandwidth.  Keep track of endpoint info here.  Each root port is allocated
+ * the full bus bandwidth.  We must also treat TTs (including each port under a
+ * multi-TT hub) as a separate bandwidth domain.  The direct memory interface
+ * (DMI) also limits the total bandwidth (across all domains) that can be used.
+ */
+struct xhci_bw_info {
+        /* ep_interval is zero-based */
+        unsigned int            ep_interval;
+        /* mult and num_packets are one-based */
+        unsigned int            mult;
+        unsigned int            num_packets;
+        unsigned int            max_packet_size;
+        unsigned int            max_esit_payload;
+        unsigned int            type;
+};
+
+/* "Block" sizes in bytes the hardware uses for different device speeds.
+ * The logic in this part of the hardware limits the number of bits the hardware
+ * can use, so must represent bandwidth in a less precise manner to mimic what
+ * the scheduler hardware computes.
+ */
+#define FS_BLOCK        1
+#define HS_BLOCK        4
+#define SS_BLOCK        16
+#define DMI_BLOCK       32
+
+/* Each device speed has a protocol overhead (CRC, bit stuffing, etc) associated
+ * with each byte transferred.  SuperSpeed devices have an initial overhead to
+ * set up bursts.  These are in blocks, see above.  LS overhead has already been
+ * translated into FS blocks.
+ */
+#define DMI_OVERHEAD 8
+#define DMI_OVERHEAD_BURST 4
+#define SS_OVERHEAD 8
+#define SS_OVERHEAD_BURST 32
+#define HS_OVERHEAD 26
+#define FS_OVERHEAD 20
+#define LS_OVERHEAD 128
+/* The TTs need to claim roughly twice as much bandwidth (94 bytes per
+ * microframe ~= 24Mbps) of the HS bus as the devices can actually use because
+ * of overhead associated with split transfers crossing microframe boundaries.
+ * 31 blocks is pure protocol overhead.
+ */
+#define TT_HS_OVERHEAD (31 + 94)
+#define TT_DMI_OVERHEAD (25 + 12)
+
+/* Bandwidth limits in blocks */
+#define FS_BW_LIMIT             1285
+#define TT_BW_LIMIT             1320
+#define HS_BW_LIMIT             1607
+#define SS_BW_LIMIT_IN          3906
+#define DMI_BW_LIMIT_IN         3906
+#define SS_BW_LIMIT_OUT         3906
+#define DMI_BW_LIMIT_OUT        3906
+
+/* Percentage of bus bandwidth reserved for non-periodic transfers */
+#define FS_BW_RESERVED          10
+#define HS_BW_RESERVED          20
+#define SS_BW_RESERVED          10
+
 struct xhci_virt_ep {
         struct xhci_ring                *ring;
         /* Related to endpoints that are configured to use stream IDs only */
@@ -772,8 +849,39 @@ struct xhci_virt_ep {
          * process the missed tds on the endpoint ring.
          */
         bool                    skip;
+        /* Bandwidth checking storage */
+        struct xhci_bw_info     bw_info;
+        struct list_head        bw_endpoint_list;
+};
+
+enum xhci_overhead_type {
+        LS_OVERHEAD_TYPE = 0,
+        FS_OVERHEAD_TYPE,
+        HS_OVERHEAD_TYPE,
+};
+
+struct xhci_interval_bw {
+        unsigned int            num_packets;
+        /* Sorted by max packet size.
+         * Head of the list is the greatest max packet size.
+         */
+        struct list_head        endpoints;
+        /* How many endpoints of each speed are present. */
+        unsigned int            overhead[3];
+};
+
+#define XHCI_MAX_INTERVAL       16
+
+struct xhci_interval_bw_table {
+        unsigned int            interval0_esit_payload;
+        struct xhci_interval_bw interval_bw[XHCI_MAX_INTERVAL];
+        /* Includes reserved bandwidth for async endpoints */
+        unsigned int            bw_used;
+        unsigned int            ss_bw_in;
+        unsigned int            ss_bw_out;
 };
 
+
 struct xhci_virt_device {
         struct usb_device               *udev;
         /*
@@ -798,7 +906,32 @@ struct xhci_virt_device {
         /* Status of the last command issued for this device */
         u32                             cmd_status;
         struct list_head                cmd_list;
-        u8                              port;
+        u8                              fake_port;
+        u8                              real_port;
+        struct xhci_interval_bw_table   *bw_table;
+        struct xhci_tt_bw_info          *tt_info;
+};
+
+/*
+ * For each roothub, keep track of the bandwidth information for each periodic
+ * interval.
+ *
+ * If a high speed hub is attached to the roothub, each TT associated with that
+ * hub is a separate bandwidth domain.  The interval information for the
+ * endpoints on the devices under that TT will appear in the TT structure.
+ */
+struct xhci_root_port_bw_info {
+        struct list_head                tts;
+        unsigned int                    num_active_tts;
+        struct xhci_interval_bw_table   bw_table;
+};
+
+struct xhci_tt_bw_info {
+        struct list_head                tt_list;
+        int                             slot_id;
+        int                             ttport;
+        struct xhci_interval_bw_table   bw_table;
+        int                             active_eps;
 };
 
 
@@ -1198,6 +1331,12 @@ struct s3_save {
         u64     erst_dequeue;
 };
 
+/* Use for lpm */
+struct dev_info {
+        u32                     dev_id;
+        struct  list_head       list;
+};
+
 struct xhci_bus_state {
         unsigned long           bus_suspended;
         unsigned long           next_statechange;
@@ -1261,12 +1400,16 @@ struct xhci_hcd {
         struct xhci_erst        erst;
         /* Scratchpad */
         struct xhci_scratchpad  *scratchpad;
+        /* Store LPM test failed devices' information */
+        struct list_head        lpm_failed_devs;
 
         /* slot enabling and address device helpers */
         struct completion       addr_dev;
         int slot_id;
         /* Internal mirror of the HW's dcbaa */
         struct xhci_virt_device *devs[MAX_HC_SLOTS];
+        /* For keeping track of bandwidth domains per roothub. */
+        struct xhci_root_port_bw_info   *rh_bw;
 
         /* DMA pools */
         struct dma_pool *device_pool;
@@ -1318,6 +1461,8 @@ struct xhci_hcd {
 #define XHCI_EP_LIMIT_QUIRK     (1 << 5)
 #define XHCI_BROKEN_MSI         (1 << 6)
 #define XHCI_RESET_ON_RESUME    (1 << 7)
+#define XHCI_SW_BW_CHECKING     (1 << 8)
+#define XHCI_AMD_0x96_HOST      (1 << 9)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
@@ -1330,6 +1475,10 @@ struct xhci_hcd {
         /* Array of pointers to USB 2.0 PORTSC registers */
         __le32 __iomem          **usb2_ports;
         unsigned int            num_usb2_ports;
+        /* support xHCI 0.96 spec USB2 software LPM */
+        unsigned                sw_lpm_support:1;
+        /* support xHCI 1.0 spec USB2 hardware LPM */
+        unsigned                hw_lpm_support:1;
 };
 
 /* convert between an HCD pointer and the corresponding EHCI_HCD */
@@ -1401,9 +1550,7 @@ static inline void xhci_write_64(struct xhci_hcd *xhci,
 
 static inline int xhci_link_trb_quirk(struct xhci_hcd *xhci)
 {
-        u32 temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
-        return ((HC_VERSION(temp) == 0x95) &&
-                        (xhci->quirks & XHCI_LINK_TRB_QUIRK));
+        return xhci->quirks & XHCI_LINK_TRB_QUIRK;
 }
 
 /* xHCI debugging */
@@ -1438,6 +1585,20 @@ unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc);
 unsigned int xhci_get_endpoint_flag_from_index(unsigned int ep_index);
 unsigned int xhci_last_valid_endpoint(u32 added_ctxs);
 void xhci_endpoint_zero(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, struct usb_host_endpoint *ep);
+void xhci_drop_ep_from_interval_table(struct xhci_hcd *xhci,
+                struct xhci_bw_info *ep_bw,
+                struct xhci_interval_bw_table *bw_table,
+                struct usb_device *udev,
+                struct xhci_virt_ep *virt_ep,
+                struct xhci_tt_bw_info *tt_info);
+void xhci_update_tt_active_eps(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                int old_active_eps);
+void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info);
+void xhci_update_bw_info(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_input_control_ctx *ctrl_ctx,
+                struct xhci_virt_device *virt_dev);
 void xhci_endpoint_copy(struct xhci_hcd *xhci,
                 struct xhci_container_ctx *in_ctx,
                 struct xhci_container_ctx *out_ctx,
@@ -1483,9 +1644,13 @@ void xhci_free_command(struct xhci_hcd *xhci,
 /* xHCI PCI glue */
 int xhci_register_pci(void);
 void xhci_unregister_pci(void);
+#else
+static inline int xhci_register_pci(void) { return 0; }
+static inline void xhci_unregister_pci(void) {}
 #endif
 
 /* xHCI host controller glue */
+typedef void (*xhci_get_quirks_t)(struct device *, struct xhci_hcd *);
 void xhci_quiesce(struct xhci_hcd *xhci);
 int xhci_halt(struct xhci_hcd *xhci);
 int xhci_reset(struct xhci_hcd *xhci);
@@ -1493,6 +1658,7 @@ int xhci_init(struct usb_hcd *hcd);
 int xhci_run(struct usb_hcd *hcd);
 void xhci_stop(struct usb_hcd *hcd);
 void xhci_shutdown(struct usb_hcd *hcd);
+int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks);
 
 #ifdef  CONFIG_PM
 int xhci_suspend(struct xhci_hcd *xhci);
@@ -1507,6 +1673,10 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd);
 irqreturn_t xhci_msi_irq(int 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_tt_info(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                struct usb_device *hdev,
+                struct usb_tt *tt, gfp_t mem_flags);
 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);
@@ -1514,6 +1684,9 @@ 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_device(struct usb_hcd *hcd, struct usb_device *udev);
+int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
+                                struct usb_device *udev, int enable);
 int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                         struct usb_tt *tt, gfp_t mem_flags);
 int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags);
@@ -1572,6 +1745,10 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, unsigned int stream_id);
 
 /* xHCI roothub code */
+void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 link_state);
+void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 port_bit);
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
                 char *buf, u16 wLength);
 int xhci_hub_status_data(struct usb_hcd *hcd, char *buf);