55 files changed, 2209 insertions, 824 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f788eb86707..74a14f6ed34 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -65,7 +65,7 @@ config USB_EHCI_HCD
 
 config USB_EHCI_ROOT_HUB_TT
         bool "Root Hub Transaction Translators"
-        depends on USB_EHCI_HCD
+        depends on USB_EHCI_HCD || USB_CHIPIDEA_HOST
         ---help---
           Some EHCI chips have vendor-specific extensions to integrate
           transaction translators, so that no OHCI or UHCI companion
@@ -77,7 +77,7 @@ config USB_EHCI_ROOT_HUB_TT
 
 config USB_EHCI_TT_NEWSCHED
         bool "Improved Transaction Translator scheduling"
-        depends on USB_EHCI_HCD
+        depends on USB_EHCI_HCD || USB_CHIPIDEA_HOST
         default y
         ---help---
           This changes the periodic scheduling code to fill more of the low
@@ -110,13 +110,14 @@ config USB_EHCI_BIG_ENDIAN_MMIO
         depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || \
                                     ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
                                     PPC_MPC512x || CPU_CAVIUM_OCTEON || \
-                                    PMC_MSP || SPARC_LEON)
+                                    PMC_MSP || SPARC_LEON || MIPS_SEAD3)
         default y
 
 config USB_EHCI_BIG_ENDIAN_DESC
         bool
         depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
-                                    PPC_MPC512x || PMC_MSP || SPARC_LEON)
+                                    PPC_MPC512x || PMC_MSP || SPARC_LEON || \
+                                    MIPS_SEAD3)
         default y
 
 config XPS_USB_HCD_XILINX
@@ -291,6 +292,7 @@ config USB_OHCI_HCD
         depends on USB && USB_ARCH_HAS_OHCI
         select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
         select USB_OTG_UTILS if ARCH_OMAP
+        select USB_ISP1301 if ARCH_LPC32XX || ARCH_PNX4008
         ---help---
           The Open Host Controller Interface (OHCI) is a standard for accessing
           USB 1.1 host controller hardware.  It does more in hardware than Intel's
@@ -373,10 +375,15 @@ config USB_OHCI_HCD_PCI
           If unsure, say Y.
 
 config USB_OHCI_HCD_SSB
-        bool "OHCI support for Broadcom SSB OHCI core"
+        bool "OHCI support for Broadcom SSB OHCI core (DEPRECATED)"
         depends on USB_OHCI_HCD && (SSB = y || SSB = USB_OHCI_HCD) && EXPERIMENTAL
+        select USB_HCD_SSB
+        select USB_OHCI_HCD_PLATFORM
         default n
         ---help---
+          This option is deprecated now and the driver was removed, use
+          USB_HCD_SSB and USB_OHCI_HCD_PLATFORM instead.
+
           Support for the Sonics Silicon Backplane (SSB) attached
           Broadcom USB OHCI core.
 
@@ -638,3 +645,27 @@ config USB_OCTEON_OHCI
 config USB_OCTEON2_COMMON
         bool
         default y if USB_OCTEON_EHCI || USB_OCTEON_OHCI
+
+config USB_HCD_BCMA
+        tristate "BCMA usb host driver"
+        depends on BCMA && EXPERIMENTAL
+        select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
+        select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
+        help
+          Enbale support for the EHCI and OCHI host controller on an bcma bus.
+          It converts the bcma driver into two platform device drivers
+          for ehci and ohci.
+
+          If unsure, say N.
+
+config USB_HCD_SSB
+        tristate "SSB usb host driver"
+        depends on SSB && EXPERIMENTAL
+        select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
+        select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
+        help
+          Enbale support for the EHCI and OCHI host controller on an bcma bus.
+          It converts the bcma driver into two platform device drivers
+          for ehci and ohci.
+
+          If unsure, say N.
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 0982bcc140b..9e0a89ced15 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -41,3 +41,5 @@ 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
+obj-$(CONFIG_USB_HCD_BCMA)      += bcma-hcd.o
+obj-$(CONFIG_USB_HCD_SSB)       += ssb-hcd.o
diff --git a/drivers/usb/host/bcma-hcd.c b/drivers/usb/host/bcma-hcd.c
new file mode 100644
index 00000000000..443da21d73c
--- /dev/null
+++ b/drivers/usb/host/bcma-hcd.c
@@ -0,0 +1,335 @@
+/*
+ * Broadcom specific Advanced Microcontroller Bus
+ * Broadcom USB-core driver (BCMA bus glue)
+ *
+ * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de>
+ *
+ * Based on ssb-ohci driver
+ * Copyright 2007 Michael Buesch <m@bues.ch>
+ *
+ * Derived from the OHCI-PCI driver
+ * Copyright 1999 Roman Weissgaerber
+ * Copyright 2000-2002 David Brownell
+ * Copyright 1999 Linus Torvalds
+ * Copyright 1999 Gregory P. Smith
+ *
+ * Derived from the USBcore related parts of Broadcom-SB
+ * Copyright 2005-2011 Broadcom Corporation
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+#include <linux/bcma/bcma.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb/ehci_pdriver.h>
+#include <linux/usb/ohci_pdriver.h>
+
+MODULE_AUTHOR("Hauke Mehrtens");
+MODULE_DESCRIPTION("Common USB driver for BCMA Bus");
+MODULE_LICENSE("GPL");
+
+struct bcma_hcd_device {
+        struct platform_device *ehci_dev;
+        struct platform_device *ohci_dev;
+};
+
+/* Wait for bitmask in a register to get set or cleared.
+ * timeout is in units of ten-microseconds.
+ */
+static int bcma_wait_bits(struct bcma_device *dev, u16 reg, u32 bitmask,
+                          int timeout)
+{
+        int i;
+        u32 val;
+
+        for (i = 0; i < timeout; i++) {
+                val = bcma_read32(dev, reg);
+                if ((val & bitmask) == bitmask)
+                        return 0;
+                udelay(10);
+        }
+
+        return -ETIMEDOUT;
+}
+
+static void __devinit bcma_hcd_4716wa(struct bcma_device *dev)
+{
+#ifdef CONFIG_BCMA_DRIVER_MIPS
+        /* Work around for 4716 failures. */
+        if (dev->bus->chipinfo.id == 0x4716) {
+                u32 tmp;
+
+                tmp = bcma_cpu_clock(&dev->bus->drv_mips);
+                if (tmp >= 480000000)
+                        tmp = 0x1846b; /* set CDR to 0x11(fast) */
+                else if (tmp == 453000000)
+                        tmp = 0x1046b; /* set CDR to 0x10(slow) */
+                else
+                        tmp = 0;
+
+                /* Change Shim mdio control reg to fix host not acking at
+                 * high frequencies
+                 */
+                if (tmp) {
+                        bcma_write32(dev, 0x524, 0x1); /* write sel to enable */
+                        udelay(500);
+
+                        bcma_write32(dev, 0x524, tmp);
+                        udelay(500);
+                        bcma_write32(dev, 0x524, 0x4ab);
+                        udelay(500);
+                        bcma_read32(dev, 0x528);
+                        bcma_write32(dev, 0x528, 0x80000000);
+                }
+        }
+#endif /* CONFIG_BCMA_DRIVER_MIPS */
+}
+
+/* based on arch/mips/brcm-boards/bcm947xx/pcibios.c */
+static void __devinit bcma_hcd_init_chip(struct bcma_device *dev)
+{
+        u32 tmp;
+
+        /*
+         * USB 2.0 special considerations:
+         *
+         * 1. Since the core supports both OHCI and EHCI functions, it must
+         *    only be reset once.
+         *
+         * 2. In addition to the standard SI reset sequence, the Host Control
+         *    Register must be programmed to bring the USB core and various
+         *    phy components out of reset.
+         */
+        if (!bcma_core_is_enabled(dev)) {
+                bcma_core_enable(dev, 0);
+                mdelay(10);
+                if (dev->id.rev >= 5) {
+                        /* Enable Misc PLL */
+                        tmp = bcma_read32(dev, 0x1e0);
+                        tmp |= 0x100;
+                        bcma_write32(dev, 0x1e0, tmp);
+                        if (bcma_wait_bits(dev, 0x1e0, 1 << 24, 100))
+                                printk(KERN_EMERG "Failed to enable misc PPL!\n");
+
+                        /* Take out of resets */
+                        bcma_write32(dev, 0x200, 0x4ff);
+                        udelay(25);
+                        bcma_write32(dev, 0x200, 0x6ff);
+                        udelay(25);
+
+                        /* Make sure digital and AFE are locked in USB PHY */
+                        bcma_write32(dev, 0x524, 0x6b);
+                        udelay(50);
+                        tmp = bcma_read32(dev, 0x524);
+                        udelay(50);
+                        bcma_write32(dev, 0x524, 0xab);
+                        udelay(50);
+                        tmp = bcma_read32(dev, 0x524);
+                        udelay(50);
+                        bcma_write32(dev, 0x524, 0x2b);
+                        udelay(50);
+                        tmp = bcma_read32(dev, 0x524);
+                        udelay(50);
+                        bcma_write32(dev, 0x524, 0x10ab);
+                        udelay(50);
+                        tmp = bcma_read32(dev, 0x524);
+
+                        if (bcma_wait_bits(dev, 0x528, 0xc000, 10000)) {
+                                tmp = bcma_read32(dev, 0x528);
+                                printk(KERN_EMERG
+                                       "USB20H mdio_rddata 0x%08x\n", tmp);
+                        }
+                        bcma_write32(dev, 0x528, 0x80000000);
+                        tmp = bcma_read32(dev, 0x314);
+                        udelay(265);
+                        bcma_write32(dev, 0x200, 0x7ff);
+                        udelay(10);
+
+                        /* Take USB and HSIC out of non-driving modes */
+                        bcma_write32(dev, 0x510, 0);
+                } else {
+                        bcma_write32(dev, 0x200, 0x7ff);
+
+                        udelay(1);
+                }
+
+                bcma_hcd_4716wa(dev);
+        }
+}
+
+static const struct usb_ehci_pdata ehci_pdata = {
+};
+
+static const struct usb_ohci_pdata ohci_pdata = {
+};
+
+static struct platform_device * __devinit
+bcma_hcd_create_pdev(struct bcma_device *dev, bool ohci, u32 addr)
+{
+        struct platform_device *hci_dev;
+        struct resource hci_res[2];
+        int ret = -ENOMEM;
+
+        memset(hci_res, 0, sizeof(hci_res));
+
+        hci_res[0].start = addr;
+        hci_res[0].end = hci_res[0].start + 0x1000 - 1;
+        hci_res[0].flags = IORESOURCE_MEM;
+
+        hci_res[1].start = dev->irq;
+        hci_res[1].flags = IORESOURCE_IRQ;
+
+        hci_dev = platform_device_alloc(ohci ? "ohci-platform" :
+                                        "ehci-platform" , 0);
+        if (!hci_dev)
+                return NULL;
+
+        hci_dev->dev.parent = &dev->dev;
+        hci_dev->dev.dma_mask = &hci_dev->dev.coherent_dma_mask;
+
+        ret = platform_device_add_resources(hci_dev, hci_res,
+                                            ARRAY_SIZE(hci_res));
+        if (ret)
+                goto err_alloc;
+        if (ohci)
+                ret = platform_device_add_data(hci_dev, &ohci_pdata,
+                                               sizeof(ohci_pdata));
+        else
+                ret = platform_device_add_data(hci_dev, &ehci_pdata,
+                                               sizeof(ehci_pdata));
+        if (ret)
+                goto err_alloc;
+        ret = platform_device_add(hci_dev);
+        if (ret)
+                goto err_alloc;
+
+        return hci_dev;
+
+err_alloc:
+        platform_device_put(hci_dev);
+        return ERR_PTR(ret);
+}
+
+static int __devinit bcma_hcd_probe(struct bcma_device *dev)
+{
+        int err;
+        u16 chipid_top;
+        u32 ohci_addr;
+        struct bcma_hcd_device *usb_dev;
+        struct bcma_chipinfo *chipinfo;
+
+        chipinfo = &dev->bus->chipinfo;
+        /* USBcores are only connected on embedded devices. */
+        chipid_top = (chipinfo->id & 0xFF00);
+        if (chipid_top != 0x4700 && chipid_top != 0x5300)
+                return -ENODEV;
+
+        /* TODO: Probably need checks here; is the core connected? */
+
+        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
+            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+                return -EOPNOTSUPP;
+
+        usb_dev = kzalloc(sizeof(struct bcma_hcd_device), GFP_KERNEL);
+        if (!usb_dev)
+                return -ENOMEM;
+
+        bcma_hcd_init_chip(dev);
+
+        /* In AI chips EHCI is addrspace 0, OHCI is 1 */
+        ohci_addr = dev->addr1;
+        if ((chipinfo->id == 0x5357 || chipinfo->id == 0x4749)
+            && chipinfo->rev == 0)
+                ohci_addr = 0x18009000;
+
+        usb_dev->ohci_dev = bcma_hcd_create_pdev(dev, true, ohci_addr);
+        if (IS_ERR(usb_dev->ohci_dev)) {
+                err = PTR_ERR(usb_dev->ohci_dev);
+                goto err_free_usb_dev;
+        }
+
+        usb_dev->ehci_dev = bcma_hcd_create_pdev(dev, false, dev->addr);
+        if (IS_ERR(usb_dev->ehci_dev)) {
+                err = PTR_ERR(usb_dev->ehci_dev);
+                goto err_unregister_ohci_dev;
+        }
+
+        bcma_set_drvdata(dev, usb_dev);
+        return 0;
+
+err_unregister_ohci_dev:
+        platform_device_unregister(usb_dev->ohci_dev);
+err_free_usb_dev:
+        kfree(usb_dev);
+        return err;
+}
+
+static void __devexit bcma_hcd_remove(struct bcma_device *dev)
+{
+        struct bcma_hcd_device *usb_dev = bcma_get_drvdata(dev);
+        struct platform_device *ohci_dev = usb_dev->ohci_dev;
+        struct platform_device *ehci_dev = usb_dev->ehci_dev;
+
+        if (ohci_dev)
+                platform_device_unregister(ohci_dev);
+        if (ehci_dev)
+                platform_device_unregister(ehci_dev);
+
+        bcma_core_disable(dev, 0);
+}
+
+static void bcma_hcd_shutdown(struct bcma_device *dev)
+{
+        bcma_core_disable(dev, 0);
+}
+
+#ifdef CONFIG_PM
+
+static int bcma_hcd_suspend(struct bcma_device *dev)
+{
+        bcma_core_disable(dev, 0);
+
+        return 0;
+}
+
+static int bcma_hcd_resume(struct bcma_device *dev)
+{
+        bcma_core_enable(dev, 0);
+
+        return 0;
+}
+
+#else /* !CONFIG_PM */
+#define bcma_hcd_suspend        NULL
+#define bcma_hcd_resume NULL
+#endif /* CONFIG_PM */
+
+static const struct bcma_device_id bcma_hcd_table[] __devinitconst = {
+        BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_USB20_HOST, BCMA_ANY_REV, BCMA_ANY_CLASS),
+        BCMA_CORETABLE_END
+};
+MODULE_DEVICE_TABLE(bcma, bcma_hcd_table);
+
+static struct bcma_driver bcma_hcd_driver = {
+        .name           = KBUILD_MODNAME,
+        .id_table       = bcma_hcd_table,
+        .probe          = bcma_hcd_probe,
+        .remove         = __devexit_p(bcma_hcd_remove),
+        .shutdown       = bcma_hcd_shutdown,
+        .suspend        = bcma_hcd_suspend,
+        .resume         = bcma_hcd_resume,
+};
+
+static int __init bcma_hcd_init(void)
+{
+        return bcma_driver_register(&bcma_hcd_driver);
+}
+module_init(bcma_hcd_init);
+
+static void __exit bcma_hcd_exit(void)
+{
+        bcma_driver_unregister(&bcma_hcd_driver);
+}
+module_exit(bcma_hcd_exit);
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 680e1a31fb8..7561966fbdc 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -1025,10 +1025,8 @@ static ssize_t debug_lpm_write(struct file *file, const char __user *user_buf,
                 if (strict_strtoul(buf + 5, 16, &hird))
                         return -EINVAL;
                 printk(KERN_INFO "setting hird %s %lu\n", buf + 6, hird);
-                temp = ehci_readl(ehci, &ehci->regs->command);
-                temp &= ~CMD_HIRD;
-                temp |= hird << 24;
-                ehci_writel(ehci, temp, &ehci->regs->command);
+                ehci->command = (ehci->command & ~CMD_HIRD) | (hird << 24);
+                ehci_writel(ehci, ehci->command, &ehci->regs->command);
         } else if (strncmp(buf, "disable", 7) == 0) {
                 if (strict_strtoul(buf + 8, 10, &port))
                         return -EINVAL;
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 3e7345172e0..43362577b54 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -1,6 +1,6 @@
 /*
  * Copyright 2005-2009 MontaVista Software, Inc.
- * Copyright 2008      Freescale Semiconductor, Inc.
+ * Copyright 2008,2012      Freescale Semiconductor, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -150,8 +150,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
                         retval = otg_set_host(ehci->transceiver->otg,
                                               &ehci_to_hcd(ehci)->self);
                         if (retval) {
-                                if (ehci->transceiver)
-                                        put_device(ehci->transceiver->dev);
+                                usb_put_transceiver(ehci->transceiver);
                                 goto err4;
                         }
                 } else {
@@ -195,7 +194,7 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
 
         if (ehci->transceiver) {
                 otg_set_host(ehci->transceiver->otg, NULL);
-                put_device(ehci->transceiver->dev);
+                usb_put_transceiver(ehci->transceiver);
         }
 
         usb_remove_hcd(hcd);
@@ -211,19 +210,32 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
         usb_put_hcd(hcd);
 }
 
-static void ehci_fsl_setup_phy(struct ehci_hcd *ehci,
+static void ehci_fsl_setup_phy(struct usb_hcd *hcd,
                                enum fsl_usb2_phy_modes phy_mode,
                                unsigned int port_offset)
 {
-        u32 portsc;
-        struct usb_hcd *hcd = ehci_to_hcd(ehci);
+        u32 portsc, temp;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
+        struct device *dev = hcd->self.controller;
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+
+        if (pdata->controller_ver < 0) {
+                dev_warn(hcd->self.controller, "Could not get controller version\n");
+                return;
+        }
 
         portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]);
         portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW);
 
         switch (phy_mode) {
         case FSL_USB2_PHY_ULPI:
+                if (pdata->controller_ver) {
+                        /* controller version 1.6 or above */
+                        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+                        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp |
+                                USB_CTRL_USB_EN | ULPI_PHY_CLK_SEL);
+                }
                 portsc |= PORT_PTS_ULPI;
                 break;
         case FSL_USB2_PHY_SERIAL:
@@ -233,8 +245,18 @@ static void ehci_fsl_setup_phy(struct ehci_hcd *ehci,
                 portsc |= PORT_PTS_PTW;
                 /* fall through */
         case FSL_USB2_PHY_UTMI:
+                if (pdata->controller_ver) {
+                        /* controller version 1.6 or above */
+                        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+                        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp |
+                                UTMI_PHY_EN | USB_CTRL_USB_EN);
+                        mdelay(FSL_UTMI_PHY_DLY);  /* Delay for UTMI PHY CLK to
+                                                become stable - 10ms*/
+                }
                 /* enable UTMI PHY */
-                setbits32(non_ehci + FSL_SOC_USB_CTRL, CTRL_UTMI_PHY_EN);
+                if (pdata->have_sysif_regs)
+                        setbits32(non_ehci + FSL_SOC_USB_CTRL,
+                                  CTRL_UTMI_PHY_EN);
                 portsc |= PORT_PTS_UTMI;
                 break;
         case FSL_USB2_PHY_NONE:
@@ -271,7 +293,7 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 
         if ((pdata->operating_mode == FSL_USB2_DR_HOST) ||
                         (pdata->operating_mode == FSL_USB2_DR_OTG))
-                ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
+                ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0);
 
         if (pdata->operating_mode == FSL_USB2_MPH_HOST) {
                 unsigned int chip, rev, svr;
@@ -285,9 +307,9 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
                         ehci->has_fsl_port_bug = 1;
 
                 if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
-                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
+                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0);
                 if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
-                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 1);
+                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 1);
         }
 
         if (pdata->have_sysif_regs) {
diff --git a/drivers/usb/host/ehci-fsl.h b/drivers/usb/host/ehci-fsl.h
index 863fb0c080d..88403684d10 100644
--- a/drivers/usb/host/ehci-fsl.h
+++ b/drivers/usb/host/ehci-fsl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2010 Freescale Semiconductor, Inc.
+/* Copyright (C) 2005-2010,2012 Freescale Semiconductor, Inc.
  * Copyright (c) 2005 MontaVista Software
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -50,4 +50,15 @@
 #define CTRL_UTMI_PHY_EN        (1<<9)
 #define CTRL_PHY_CLK_VALID      (1 << 17)
 #define SNOOP_SIZE_2GB          0x1e
+
+/* control Register Bit Masks */
+#define ULPI_INT_EN             (1<<0)
+#define WU_INT_EN               (1<<1)
+#define USB_CTRL_USB_EN         (1<<2)
+#define LINE_STATE_FILTER__EN   (1<<3)
+#define KEEP_OTG_ON             (1<<4)
+#define OTG_PORT                (1<<5)
+#define PLL_RESET               (1<<8)
+#define UTMI_PHY_EN             (1<<9)
+#define ULPI_PHY_CLK_SEL        (1<<10)
 #endif                          /* _EHCI_FSL_H */
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 806cc95317a..b100f5f9f4b 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -226,8 +226,13 @@ static int ehci_halt (struct ehci_hcd *ehci)
         if ((temp & STS_HALT) != 0)
                 return 0;
 
+        /*
+         * This routine gets called during probe before ehci->command
+         * has been initialized, so we can't rely on its value.
+         */
+        ehci->command &= ~CMD_RUN;
         temp = ehci_readl(ehci, &ehci->regs->command);
-        temp &= ~CMD_RUN;
+        temp &= ~(CMD_RUN | CMD_IAAD);
         ehci_writel(ehci, temp, &ehci->regs->command);
         return handshake (ehci, &ehci->regs->status,
                           STS_HALT, STS_HALT, 16 * 125);
@@ -363,16 +368,14 @@ static void ehci_quiesce (struct ehci_hcd *ehci)
 #endif
 
         /* wait for any schedule enables/disables to take effect */
-        temp = ehci_readl(ehci, &ehci->regs->command) << 10;
-        temp &= STS_ASS | STS_PSS;
+        temp = (ehci->command << 10) & (STS_ASS | STS_PSS);
         if (handshake_on_error_set_halt(ehci, &ehci->regs->status,
                                         STS_ASS | STS_PSS, temp, 16 * 125))
                 return;
 
         /* then disable anything that's still active */
-        temp = ehci_readl(ehci, &ehci->regs->command);
-        temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
-        ehci_writel(ehci, temp, &ehci->regs->command);
+        ehci->command &= ~(CMD_ASE | CMD_PSE);
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
 
         /* hardware can take 16 microframes to turn off ... */
         handshake_on_error_set_halt(ehci, &ehci->regs->status,
@@ -417,9 +420,6 @@ static void ehci_iaa_watchdog(unsigned long param)
                  * CMD_IAAD when it sets STS_IAA.)
                  */
                 cmd = ehci_readl(ehci, &ehci->regs->command);
-                if (cmd & CMD_IAAD)
-                        ehci_writel(ehci, cmd & ~CMD_IAAD,
-                                        &ehci->regs->command);
 
                 /* If IAA is set here it either legitimately triggered
                  * before we cleared IAAD above (but _way_ late, so we'll
@@ -858,8 +858,13 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                 goto dead;
         }
 
+        /*
+         * We don't use STS_FLR, but some controllers don't like it to
+         * remain on, so mask it out along with the other status bits.
+         */
+        masked_status = status & (INTR_MASK | STS_FLR);
+
         /* Shared IRQ? */
-        masked_status = status & INTR_MASK;
         if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
                 spin_unlock(&ehci->lock);
                 return IRQ_NONE;
@@ -889,11 +894,8 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
         /* complete the unlinking of some qh [4.15.2.3] */
         if (status & STS_IAA) {
                 /* guard against (alleged) silicon errata */
-                if (cmd & CMD_IAAD) {
-                        ehci_writel(ehci, cmd & ~CMD_IAAD,
-                                        &ehci->regs->command);
+                if (cmd & CMD_IAAD)
                         ehci_dbg(ehci, "IAA with IAAD still set?\n");
-                }
                 if (ehci->reclaim) {
                         COUNT(ehci->stats.reclaim);
                         end_unlink_async(ehci);
@@ -910,7 +912,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                 pcd_status = status;
 
                 /* resume root hub? */
-                if (!(cmd & CMD_RUN))
+                if (ehci->rh_state == EHCI_RH_SUSPENDED)
                         usb_hcd_resume_root_hub(hcd);
 
                 /* get per-port change detect bits */
@@ -1243,6 +1245,13 @@ static int ehci_get_frame (struct usb_hcd *hcd)
 }
 
 /*-------------------------------------------------------------------------*/
+/*
+ * The EHCI in ChipIdea HDRC cannot be a separate module or device,
+ * because its registers (and irq) are shared between host/gadget/otg
+ * functions  and in order to facilitate role switching we cannot
+ * give the ehci driver exclusive access to those.
+ */
+#ifndef CHIPIDEA_EHCI
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR (DRIVER_AUTHOR);
@@ -1373,6 +1382,11 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_ls1x_driver
 #endif
 
+#ifdef CONFIG_MIPS_SEAD3
+#include "ehci-sead3.c"
+#define PLATFORM_DRIVER         ehci_hcd_sead3_driver
+#endif
+
 #ifdef CONFIG_USB_EHCI_HCD_PLATFORM
 #include "ehci-platform.c"
 #define PLATFORM_DRIVER         ehci_platform_driver
@@ -1496,3 +1510,4 @@ static void __exit ehci_hcd_cleanup(void)
 }
 module_exit(ehci_hcd_cleanup);
 
+#endif /* CHIPIDEA_EHCI */
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 38fe0762315..fc9e7cc6ac9 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -233,7 +233,6 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
         /* stop schedules, clean any completed work */
         if (ehci->rh_state == EHCI_RH_RUNNING)
                 ehci_quiesce (ehci);
-        ehci->command = ehci_readl(ehci, &ehci->regs->command);
         ehci_work(ehci);
 
         /* Unlike other USB host controller types, EHCI doesn't have
@@ -374,6 +373,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
 
         /* restore CMD_RUN, framelist size, and irq threshold */
+        ehci->command |= CMD_RUN;
         ehci_writel(ehci, ehci->command, &ehci->regs->command);
         ehci->rh_state = EHCI_RH_RUNNING;
 
@@ -531,7 +531,8 @@ static int check_reset_complete (
                 if (ehci->has_amcc_usb23)
                         set_ohci_hcfs(ehci, 1);
         } else {
-                ehci_dbg (ehci, "port %d high speed\n", index + 1);
+                ehci_dbg(ehci, "port %d reset complete, port enabled\n",
+                        index + 1);
                 /* ensure 440EPx ohci controller state is suspended */
                 if (ehci->has_amcc_usb23)
                         set_ohci_hcfs(ehci, 0);
@@ -699,6 +700,7 @@ static int ehci_hub_control (
                         goto error;
                 wIndex--;
                 temp = ehci_readl(ehci, status_reg);
+                temp &= ~PORT_RWC_BITS;
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
@@ -712,8 +714,7 @@ static int ehci_hub_control (
                         ehci_writel(ehci, temp & ~PORT_PE, status_reg);
                         break;
                 case USB_PORT_FEAT_C_ENABLE:
-                        ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC,
-                                        status_reg);
+                        ehci_writel(ehci, temp | PORT_PEC, status_reg);
                         break;
                 case USB_PORT_FEAT_SUSPEND:
                         if (temp & PORT_RESET)
@@ -742,7 +743,7 @@ static int ehci_hub_control (
                                 spin_lock_irqsave(&ehci->lock, flags);
                         }
                         /* resume signaling for 20 msec */
-                        temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                        temp &= ~PORT_WAKE_BITS;
                         ehci_writel(ehci, temp | PORT_RESUME, status_reg);
                         ehci->reset_done[wIndex] = jiffies
                                         + msecs_to_jiffies(20);
@@ -752,9 +753,8 @@ static int ehci_hub_control (
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC (ehci->hcs_params))
-                                ehci_writel(ehci,
-                                          temp & ~(PORT_RWC_BITS | PORT_POWER),
-                                          status_reg);
+                                ehci_writel(ehci, temp & ~PORT_POWER,
+                                                status_reg);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
                         if (ehci->has_lpm) {
@@ -762,12 +762,10 @@ static int ehci_hub_control (
                                 temp &= ~PORT_LPM;
                                 temp &= ~PORT_DEV_ADDR;
                         }
-                        ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC,
-                                        status_reg);
+                        ehci_writel(ehci, temp | PORT_CSC, status_reg);
                         break;
                 case USB_PORT_FEAT_C_OVER_CURRENT:
-                        ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC,
-                                        status_reg);
+                        ehci_writel(ehci, temp | PORT_OCC, status_reg);
                         break;
                 case USB_PORT_FEAT_C_RESET:
                         /* GetPortStatus clears reset */
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index bba9850f32f..a44294d1349 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -42,6 +42,7 @@
 #include <plat/usb.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
+#include <linux/gpio.h>
 
 /* EHCI Register Set */
 #define EHCI_INSNREG04                                  (0xA0)
@@ -191,6 +192,19 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 }
         }
 
+        if (pdata->phy_reset) {
+                if (gpio_is_valid(pdata->reset_gpio_port[0]))
+                        gpio_request_one(pdata->reset_gpio_port[0],
+                                         GPIOF_OUT_INIT_LOW, "USB1 PHY reset");
+
+                if (gpio_is_valid(pdata->reset_gpio_port[1]))
+                        gpio_request_one(pdata->reset_gpio_port[1],
+                                         GPIOF_OUT_INIT_LOW, "USB2 PHY reset");
+
+                /* Hold the PHY in RESET for enough time till DIR is high */
+                udelay(10);
+        }
+
         pm_runtime_enable(dev);
         pm_runtime_get_sync(dev);
 
@@ -228,6 +242,19 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
 
         ehci_reset(omap_ehci);
 
+        if (pdata->phy_reset) {
+                /* Hold the PHY in RESET for enough time till
+                 * PHY is settled and ready
+                 */
+                udelay(10);
+
+                if (gpio_is_valid(pdata->reset_gpio_port[0]))
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 1);
+
+                if (gpio_is_valid(pdata->reset_gpio_port[1]))
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[1], 1);
+        }
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret) {
                 dev_err(dev, "failed to add hcd with err %d\n", ret);
@@ -259,8 +286,9 @@ err_io:
  */
 static int ehci_hcd_omap_remove(struct platform_device *pdev)
 {
-        struct device *dev      = &pdev->dev;
-        struct usb_hcd *hcd     = dev_get_drvdata(dev);
+        struct device *dev                              = &pdev->dev;
+        struct usb_hcd *hcd                             = dev_get_drvdata(dev);
+        struct ehci_hcd_omap_platform_data *pdata       = dev->platform_data;
 
         usb_remove_hcd(hcd);
         disable_put_regulator(dev->platform_data);
@@ -269,6 +297,13 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
         pm_runtime_put_sync(dev);
         pm_runtime_disable(dev);
 
+        if (pdata->phy_reset) {
+                if (gpio_is_valid(pdata->reset_gpio_port[0]))
+                        gpio_free(pdata->reset_gpio_port[0]);
+
+                if (gpio_is_valid(pdata->reset_gpio_port[1]))
+                        gpio_free(pdata->reset_gpio_port[1]);
+        }
         return 0;
 }
 
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 01bb7241d6e..bc94d7bf072 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -144,6 +144,14 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                         hcd->has_tt = 1;
                         tdi_reset(ehci);
                 }
+                if (pdev->subsystem_vendor == PCI_VENDOR_ID_ASUSTEK) {
+                        /* EHCI #1 or #2 on 6 Series/C200 Series chipset */
+                        if (pdev->device == 0x1c26 || pdev->device == 0x1c2d) {
+                                ehci_info(ehci, "broken D3 during system sleep on ASUS\n");
+                                hcd->broken_pci_sleep = 1;
+                                device_set_wakeup_capable(&pdev->dev, false);
+                        }
+                }
                 break;
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
@@ -360,7 +368,9 @@ static bool usb_is_intel_switchable_ehci(struct pci_dev *pdev)
 {
         return pdev->class == PCI_CLASS_SERIAL_USB_EHCI &&
                 pdev->vendor == PCI_VENDOR_ID_INTEL &&
-                pdev->device == 0x1E26;
+                (pdev->device == 0x1E26 ||
+                 pdev->device == 0x8C2D ||
+                 pdev->device == 0x8C26);
 }
 
 static void ehci_enable_xhci_companion(void)
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index d238b4e24bb..dfe881a34ae 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -75,8 +75,6 @@ static const struct hc_driver ehci_platform_hc_driver = {
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
 
-        .update_device          = ehci_update_device,
-
         .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
@@ -94,12 +92,12 @@ static int __devinit ehci_platform_probe(struct platform_device *dev)
 
         irq = platform_get_irq(dev, 0);
         if (irq < 0) {
-                pr_err("no irq provieded");
+                pr_err("no irq provided");
                 return irq;
         }
         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!res_mem) {
-                pr_err("no memory recourse provieded");
+                pr_err("no memory recourse provided");
                 return -ENXIO;
         }
 
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 36ca5077cdf..4378bf72bba 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -943,7 +943,8 @@ qh_make (
                 }
                 break;
         default:
-                dbg ("bogus dev %p speed %d", urb->dev, urb->dev->speed);
+                ehci_dbg(ehci, "bogus dev %p speed %d\n", urb->dev,
+                        urb->dev->speed);
 done:
                 qh_put (qh);
                 return NULL;
@@ -981,14 +982,12 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         head = ehci->async;
         timer_action_done (ehci, TIMER_ASYNC_OFF);
         if (!head->qh_next.qh) {
-                u32     cmd = ehci_readl(ehci, &ehci->regs->command);
-
-                if (!(cmd & CMD_ASE)) {
+                if (!(ehci->command & CMD_ASE)) {
                         /* in case a clear of CMD_ASE didn't take yet */
                         (void)handshake(ehci, &ehci->regs->status,
                                         STS_ASS, 0, 150);
-                        cmd |= CMD_ASE;
-                        ehci_writel(ehci, cmd, &ehci->regs->command);
+                        ehci->command |= CMD_ASE;
+                        ehci_writel(ehci, ehci->command, &ehci->regs->command);
                         /* posted write need not be known to HC yet ... */
                 }
         }
@@ -1204,7 +1203,6 @@ static void end_unlink_async (struct ehci_hcd *ehci)
 
 static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
-        int             cmd = ehci_readl(ehci, &ehci->regs->command);
         struct ehci_qh  *prev;
 
 #ifdef DEBUG
@@ -1222,8 +1220,8 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 if (ehci->rh_state != EHCI_RH_HALTED
                                 && !ehci->reclaim) {
                         /* ... and CMD_IAAD clear */
-                        ehci_writel(ehci, cmd & ~CMD_ASE,
-                                    &ehci->regs->command);
+                        ehci->command &= ~CMD_ASE;
+                        ehci_writel(ehci, ehci->command, &ehci->regs->command);
                         wmb ();
                         // handshake later, if we need to
                         timer_action_done (ehci, TIMER_ASYNC_OFF);
@@ -1253,8 +1251,7 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 return;
         }
 
-        cmd |= CMD_IAAD;
-        ehci_writel(ehci, cmd, &ehci->regs->command);
+        ehci_writel(ehci, ehci->command | CMD_IAAD, &ehci->regs->command);
         (void)ehci_readl(ehci, &ehci->regs->command);
         iaa_watchdog_start(ehci);
 }
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index f098e2a291a..c474cec064e 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -232,6 +232,8 @@ static int s5p_ehci_suspend(struct device *dev)
         if (pdata && pdata->phy_exit)
                 pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
 
+        clk_disable(s5p_ehci->clk);
+
         return rc;
 }
 
@@ -243,6 +245,8 @@ static int s5p_ehci_resume(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
 
+        clk_enable(s5p_ehci->clk);
+
         if (pdata && pdata->phy_init)
                 pdata->phy_init(pdev, S5P_USB_PHY_HOST);
 
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index a60679cbbf8..33182c6d1ff 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -481,7 +481,6 @@ static int tt_no_collision (
 
 static int enable_periodic (struct ehci_hcd *ehci)
 {
-        u32     cmd;
         int     status;
 
         if (ehci->periodic_sched++)
@@ -497,8 +496,8 @@ static int enable_periodic (struct ehci_hcd *ehci)
                 return status;
         }
 
-        cmd = ehci_readl(ehci, &ehci->regs->command) | CMD_PSE;
-        ehci_writel(ehci, cmd, &ehci->regs->command);
+        ehci->command |= CMD_PSE;
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
         /* posted write ... PSS happens later */
 
         /* make sure ehci_work scans these */
@@ -511,7 +510,6 @@ static int enable_periodic (struct ehci_hcd *ehci)
 
 static int disable_periodic (struct ehci_hcd *ehci)
 {
-        u32     cmd;
         int     status;
 
         if (--ehci->periodic_sched)
@@ -537,8 +535,8 @@ static int disable_periodic (struct ehci_hcd *ehci)
                 return status;
         }
 
-        cmd = ehci_readl(ehci, &ehci->regs->command) & ~CMD_PSE;
-        ehci_writel(ehci, cmd, &ehci->regs->command);
+        ehci->command &= ~CMD_PSE;
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
         /* posted write ... */
 
         free_cached_lists(ehci);
@@ -1333,34 +1331,36 @@ sitd_slot_ok (
         if (mask & ~0xffff)
                 return 0;
 
+        /* check bandwidth */
+        uframe %= period_uframes;
+        frame = uframe >> 3;
+
+#ifdef CONFIG_USB_EHCI_TT_NEWSCHED
+        /* The tt's fullspeed bus bandwidth must be available.
+         * tt_available scheduling guarantees 10+% for control/bulk.
+         */
+        uf = uframe & 7;
+        if (!tt_available(ehci, period_uframes >> 3,
+                        stream->udev, frame, uf, stream->tt_usecs))
+                return 0;
+#else
+        /* tt must be idle for start(s), any gap, and csplit.
+         * assume scheduling slop leaves 10+% for control/bulk.
+         */
+        if (!tt_no_collision(ehci, period_uframes >> 3,
+                        stream->udev, frame, mask))
+                return 0;
+#endif
+
         /* this multi-pass logic is simple, but performance may
          * suffer when the schedule data isn't cached.
          */
-
-        /* check bandwidth */
-        uframe %= period_uframes;
         do {
                 u32             max_used;
 
                 frame = uframe >> 3;
                 uf = uframe & 7;
 
-#ifdef CONFIG_USB_EHCI_TT_NEWSCHED
-                /* The tt's fullspeed bus bandwidth must be available.
-                 * tt_available scheduling guarantees 10+% for control/bulk.
-                 */
-                if (!tt_available (ehci, period_uframes << 3,
-                                stream->udev, frame, uf, stream->tt_usecs))
-                        return 0;
-#else
-                /* tt must be idle for start(s), any gap, and csplit.
-                 * assume scheduling slop leaves 10+% for control/bulk.
-                 */
-                if (!tt_no_collision (ehci, period_uframes << 3,
-                                stream->udev, frame, mask))
-                        return 0;
-#endif
-
                 /* check starts (OUT uses more than one) */
                 max_used = ehci->uframe_periodic_max - stream->usecs;
                 for (tmp = stream->raw_mask & 0xff; tmp; tmp >>= 1, uf++) {
@@ -2358,7 +2358,8 @@ restart:
                                  * in the previous frame for completions.
                                  */
                                 if (q.fstn->hw_prev != EHCI_LIST_END(ehci)) {
-                                        dbg ("ignoring completions from FSTNs");
+                                        ehci_dbg(ehci,
+                                                "ignoring completions from FSTNs\n");
                                 }
                                 type = Q_NEXT_TYPE(ehci, q.fstn->hw_next);
                                 q = q.fstn->fstn_next;
@@ -2441,7 +2442,7 @@ restart:
                                 q = *q_p;
                                 break;
                         default:
-                                dbg ("corrupt type %d frame %d shadow %p",
+                                ehci_dbg(ehci, "corrupt type %d frame %d shadow %p\n",
                                         type, frame, q.ptr);
                                 // BUG ();
                                 q.ptr = NULL;
diff --git a/drivers/usb/host/ehci-sead3.c b/drivers/usb/host/ehci-sead3.c
new file mode 100644
index 00000000000..cc199e87a7a
--- /dev/null
+++ b/drivers/usb/host/ehci-sead3.c
@@ -0,0 +1,266 @@
+/*
+ * MIPS CI13320A EHCI Host Controller driver
+ * Based on "ehci-au1xxx.c" by K.Boge <karsten.boge@amd.com>
+ *
+ * Copyright (C) 2012 MIPS Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/platform_device.h>
+
+static int ehci_sead3_setup(struct usb_hcd *hcd)
+{
+        int ret;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        ehci->caps = hcd->regs + 0x100;
+
+#ifdef __BIG_ENDIAN
+        ehci->big_endian_mmio = 1;
+        ehci->big_endian_desc = 1;
+#endif
+
+        ret = ehci_setup(hcd);
+        if (ret)
+                return ret;
+
+        ehci->need_io_watchdog = 0;
+
+        /* Set burst length to 16 words. */
+        ehci_writel(ehci, 0x1010, &ehci->regs->reserved[1]);
+
+        return ret;
+}
+
+const struct hc_driver ehci_sead3_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "SEAD-3 EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         *
+         */
+        .reset                  = ehci_sead3_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 ehci_hcd_sead3_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
+                pr_debug("resource[1] is not IORESOURCE_IRQ");
+                return -ENOMEM;
+        }
+        hcd = usb_create_hcd(&ehci_sead3_hc_driver, &pdev->dev, "SEAD-3");
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_debug("request_mem_region failed");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        /* Root hub has integrated TT. */
+        hcd->has_tt = 1;
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ehci_hcd_sead3_drv_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);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ehci_hcd_sead3_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        unsigned long flags;
+        int rc = 0;
+
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(20);
+
+        /* Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible.  The PM and USB cores make sure that
+         * the root hub is either suspended or stopped.
+         */
+        ehci_prepare_ports_for_controller_suspend(ehci, device_may_wakeup(dev));
+        spin_lock_irqsave(&ehci->lock, flags);
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        (void)ehci_readl(ehci, &ehci->regs->intr_enable);
+
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        /* could save FLADJ in case of Vaux power loss
+         * ... we'd only use it to handle clock skew
+         */
+
+        return rc;
+}
+
+static int ehci_hcd_sead3_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        /* maybe restore FLADJ. */
+
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(100);
+
+        /* Mark hardware accessible again as we are out of D3 state by now */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* If CF is still set, we maintained PCI Vaux power.
+         * Just undo the effect of ehci_pci_suspend().
+         */
+        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
+                int     mask = INTR_MASK;
+
+                ehci_prepare_ports_for_controller_resume(ehci);
+                if (!hcd->self.root_hub->do_remote_wakeup)
+                        mask &= ~STS_PCD;
+                ehci_writel(ehci, mask, &ehci->regs->intr_enable);
+                ehci_readl(ehci, &ehci->regs->intr_enable);
+                return 0;
+        }
+
+        ehci_dbg(ehci, "lost power, restarting\n");
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
+        /* Else reset, to cope with power loss or flush-to-storage
+         * style "resume" having let BIOS kick in during reboot.
+         */
+        (void) ehci_halt(ehci);
+        (void) ehci_reset(ehci);
+
+        /* emptying the schedule aborts any urbs */
+        spin_lock_irq(&ehci->lock);
+        if (ehci->reclaim)
+                end_unlink_async(ehci);
+        ehci_work(ehci);
+        spin_unlock_irq(&ehci->lock);
+
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+
+        /* here we "know" root ports should always stay powered */
+        ehci_port_power(ehci, 1);
+
+        ehci->rh_state = EHCI_RH_SUSPENDED;
+
+        return 0;
+}
+
+static const struct dev_pm_ops sead3_ehci_pmops = {
+        .suspend        = ehci_hcd_sead3_drv_suspend,
+        .resume         = ehci_hcd_sead3_drv_resume,
+};
+
+#define SEAD3_EHCI_PMOPS (&sead3_ehci_pmops)
+
+#else
+#define SEAD3_EHCI_PMOPS NULL
+#endif
+
+static struct platform_driver ehci_hcd_sead3_driver = {
+        .probe          = ehci_hcd_sead3_drv_probe,
+        .remove         = ehci_hcd_sead3_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = "sead3-ehci",
+                .owner  = THIS_MODULE,
+                .pm     = SEAD3_EHCI_PMOPS,
+        }
+};
+
+MODULE_ALIAS("platform:sead3-ehci");
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index 9d9cf47d80d..ca819cdd0c5 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -11,6 +11,7 @@
  */
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/platform_data/ehci-sh.h>
 
 struct ehci_sh_priv {
         struct clk *iclk, *fclk;
@@ -100,6 +101,7 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         const struct hc_driver *driver = &ehci_sh_hc_driver;
         struct resource *res;
         struct ehci_sh_priv *priv;
+        struct ehci_sh_platdata *pdata;
         struct usb_hcd *hcd;
         int irq, ret;
 
@@ -124,6 +126,9 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
                 goto fail_create_hcd;
         }
 
+        if (pdev->dev.platform_data != NULL)
+                pdata = pdev->dev.platform_data;
+
         /* initialize hcd */
         hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
                              dev_name(&pdev->dev));
@@ -168,6 +173,9 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         clk_enable(priv->fclk);
         clk_enable(priv->iclk);
 
+        if (pdata && pdata->phy_init)
+                pdata->phy_init();
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to add hcd");
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 6e928559169..37ba8c8d2fd 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -13,6 +13,7 @@
 
 #include <linux/clk.h>
 #include <linux/jiffies.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 
@@ -25,12 +26,12 @@ struct spear_ehci {
 
 static void spear_start_ehci(struct spear_ehci *ehci)
 {
-        clk_enable(ehci->clk);
+        clk_prepare_enable(ehci->clk);
 }
 
 static void spear_stop_ehci(struct spear_ehci *ehci)
 {
-        clk_disable(ehci->clk);
+        clk_disable_unprepare(ehci->clk);
 }
 
 static int ehci_spear_setup(struct usb_hcd *hcd)
@@ -168,6 +169,8 @@ static int ehci_spear_drv_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(ehci_spear_pm_ops, ehci_spear_drv_suspend,
                 ehci_spear_drv_resume);
 
+static u64 spear_ehci_dma_mask = DMA_BIT_MASK(32);
+
 static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd ;
@@ -175,12 +178,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
         struct resource *res;
         struct clk *usbh_clk;
         const struct hc_driver *driver = &ehci_spear_hc_driver;
-        int *pdata = pdev->dev.platform_data;
         int irq, retval;
         char clk_name[20] = "usbh_clk";
-
-        if (pdata == NULL)
-                return -EFAULT;
+        static int instance = -1;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -191,8 +191,22 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
                 goto fail_irq_get;
         }
 
-        if (*pdata >= 0)
-                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+        /*
+         * Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &spear_ehci_dma_mask;
+
+        /*
+         * Increment the device instance, when probing via device-tree
+         */
+        if (pdev->id < 0)
+                instance++;
+        else
+                instance = pdev->id;
+        sprintf(clk_name, "usbh.%01d_clk", instance);
 
         usbh_clk = clk_get(NULL, clk_name);
         if (IS_ERR(usbh_clk)) {
@@ -277,6 +291,11 @@ static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)
         return 0;
 }
 
+static struct of_device_id spear_ehci_id_table[] __devinitdata = {
+        { .compatible = "st,spear600-ehci", },
+        { },
+};
+
 static struct platform_driver spear_ehci_hcd_driver = {
         .probe          = spear_ehci_hcd_drv_probe,
         .remove         = spear_ehci_hcd_drv_remove,
@@ -285,6 +304,7 @@ static struct platform_driver spear_ehci_hcd_driver = {
                 .name = "spear-ehci",
                 .bus = &platform_bus_type,
                 .pm = &ehci_spear_pm_ops,
+                .of_match_table = of_match_ptr(spear_ehci_id_table),
         }
 };
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 73544bd440b..4a44bf83361 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -24,6 +24,7 @@
 #include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
+#include <linux/pm_runtime.h>
 
 #include <mach/usb_phy.h>
 #include <mach/iomap.h>
@@ -37,9 +38,7 @@ struct tegra_ehci_hcd {
         struct clk *emc_clk;
         struct usb_phy *transceiver;
         int host_resumed;
-        int bus_suspended;
         int port_resuming;
-        int power_down_on_bus_suspend;
         enum tegra_usb_phy_port_speed port_speed;
 };
 
@@ -148,18 +147,7 @@ static int tegra_ehci_hub_control(
 
         spin_lock_irqsave(&ehci->lock, flags);
 
-        /*
-         * In ehci_hub_control() for USB_PORT_FEAT_ENABLE clears the other bits
-         * that are write on clear, by writing back the register read value, so
-         * USB_PORT_FEAT_ENABLE is handled by masking the set on clear bits
-         */
-        if (typeReq == ClearPortFeature && wValue == USB_PORT_FEAT_ENABLE) {
-                temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
-                ehci_writel(ehci, temp & ~PORT_PE, status_reg);
-                goto done;
-        }
-
-        else if (typeReq == GetPortStatus) {
+        if (typeReq == GetPortStatus) {
                 temp = ehci_readl(ehci, status_reg);
                 if (tegra->port_resuming && !(temp & PORT_SUSPEND)) {
                         /* Resume completed, re-enable disconnect detection */
@@ -175,7 +163,7 @@ static int tegra_ehci_hub_control(
                         goto done;
                 }
 
-                temp &= ~PORT_WKCONN_E;
+                temp &= ~(PORT_RWC_BITS | PORT_WKCONN_E);
                 temp |= PORT_WKDISC_E | PORT_WKOC_E;
                 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
 
@@ -273,120 +261,6 @@ static void tegra_ehci_restart(struct usb_hcd *hcd)
         up_write(&ehci_cf_port_reset_rwsem);
 }
 
-static int tegra_usb_suspend(struct usb_hcd *hcd)
-{
-        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
-        struct ehci_regs __iomem *hw = tegra->ehci->regs;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tegra->ehci->lock, flags);
-
-        tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
-        ehci_halt(tegra->ehci);
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        spin_unlock_irqrestore(&tegra->ehci->lock, flags);
-
-        tegra_ehci_power_down(hcd);
-        return 0;
-}
-
-static int tegra_usb_resume(struct usb_hcd *hcd)
-{
-        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        struct ehci_regs __iomem *hw = ehci->regs;
-        unsigned long val;
-
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        tegra_ehci_power_up(hcd);
-
-        if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
-                /* Wait for the phy to detect new devices
-                 * before we restart the controller */
-                msleep(10);
-                goto restart;
-        }
-
-        /* Force the phy to keep data lines in suspend state */
-        tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
-
-        /* Enable host mode */
-        tdi_reset(ehci);
-
-        /* Enable Port Power */
-        val = readl(&hw->port_status[0]);
-        val |= PORT_POWER;
-        writel(val, &hw->port_status[0]);
-        udelay(10);
-
-        /* Check if the phy resume from LP0. When the phy resume from LP0
-         * USB register will be reset. */
-        if (!readl(&hw->async_next)) {
-                /* Program the field PTC based on the saved speed mode */
-                val = readl(&hw->port_status[0]);
-                val &= ~PORT_TEST(~0);
-                if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
-                        val |= PORT_TEST_FORCE;
-                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
-                        val |= PORT_TEST(6);
-                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
-                        val |= PORT_TEST(7);
-                writel(val, &hw->port_status[0]);
-                udelay(10);
-
-                /* Disable test mode by setting PTC field to NORMAL_OP */
-                val = readl(&hw->port_status[0]);
-                val &= ~PORT_TEST(~0);
-                writel(val, &hw->port_status[0]);
-                udelay(10);
-        }
-
-        /* Poll until CCS is enabled */
-        if (handshake(ehci, &hw->port_status[0], PORT_CONNECT,
-                                                 PORT_CONNECT, 2000)) {
-                pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
-                goto restart;
-        }
-
-        /* Poll until PE is enabled */
-        if (handshake(ehci, &hw->port_status[0], PORT_PE,
-                                                 PORT_PE, 2000)) {
-                pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
-                goto restart;
-        }
-
-        /* Clear the PCI status, to avoid an interrupt taken upon resume */
-        val = readl(&hw->status);
-        val |= STS_PCD;
-        writel(val, &hw->status);
-
-        /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
-        val = readl(&hw->port_status[0]);
-        if ((val & PORT_POWER) && (val & PORT_PE)) {
-                val |= PORT_SUSPEND;
-                writel(val, &hw->port_status[0]);
-
-                /* Wait until port suspend completes */
-                if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
-                                                         PORT_SUSPEND, 1000)) {
-                        pr_err("%s: timeout waiting for PORT_SUSPEND\n",
-                                                                __func__);
-                        goto restart;
-                }
-        }
-
-        tegra_ehci_phy_restore_end(tegra->phy);
-        return 0;
-
-restart:
-        if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
-                tegra_ehci_phy_restore_end(tegra->phy);
-
-        tegra_ehci_restart(hcd);
-        return 0;
-}
-
 static void tegra_ehci_shutdown(struct usb_hcd *hcd)
 {
         struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
@@ -434,56 +308,23 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
         return retval;
 }
 
-#ifdef CONFIG_PM
-static int tegra_ehci_bus_suspend(struct usb_hcd *hcd)
-{
-        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
-        int error_status = 0;
-
-        error_status = ehci_bus_suspend(hcd);
-        if (!error_status && tegra->power_down_on_bus_suspend) {
-                tegra_usb_suspend(hcd);
-                tegra->bus_suspended = 1;
-        }
-
-        return error_status;
-}
-
-static int tegra_ehci_bus_resume(struct usb_hcd *hcd)
-{
-        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
-
-        if (tegra->bus_suspended && tegra->power_down_on_bus_suspend) {
-                tegra_usb_resume(hcd);
-                tegra->bus_suspended = 0;
-        }
-
-        tegra_usb_phy_preresume(tegra->phy);
-        tegra->port_resuming = 1;
-        return ehci_bus_resume(hcd);
-}
-#endif
-
-struct temp_buffer {
+struct dma_aligned_buffer {
         void *kmalloc_ptr;
         void *old_xfer_buffer;
         u8 data[0];
 };
 
-static void free_temp_buffer(struct urb *urb)
+static void free_dma_aligned_buffer(struct urb *urb)
 {
-        enum dma_data_direction dir;
-        struct temp_buffer *temp;
+        struct dma_aligned_buffer *temp;
 
         if (!(urb->transfer_flags & URB_ALIGNED_TEMP_BUFFER))
                 return;
 
-        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+        temp = container_of(urb->transfer_buffer,
+                struct dma_aligned_buffer, data);
 
-        temp = container_of(urb->transfer_buffer, struct temp_buffer,
-                            data);
-
-        if (dir == DMA_FROM_DEVICE)
+        if (usb_urb_dir_in(urb))
                 memcpy(temp->old_xfer_buffer, temp->data,
                        urb->transfer_buffer_length);
         urb->transfer_buffer = temp->old_xfer_buffer;
@@ -492,10 +333,9 @@ static void free_temp_buffer(struct urb *urb)
         urb->transfer_flags &= ~URB_ALIGNED_TEMP_BUFFER;
 }
 
-static int alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
+static int alloc_dma_aligned_buffer(struct urb *urb, gfp_t mem_flags)
 {
-        enum dma_data_direction dir;
-        struct temp_buffer *temp, *kmalloc_ptr;
+        struct dma_aligned_buffer *temp, *kmalloc_ptr;
         size_t kmalloc_size;
 
         if (urb->num_sgs || urb->sg ||
@@ -503,22 +343,19 @@ static int alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
             !((uintptr_t)urb->transfer_buffer & (TEGRA_USB_DMA_ALIGN - 1)))
                 return 0;
 
-        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
         /* Allocate a buffer with enough padding for alignment */
         kmalloc_size = urb->transfer_buffer_length +
-                sizeof(struct temp_buffer) + TEGRA_USB_DMA_ALIGN - 1;
+                sizeof(struct dma_aligned_buffer) + TEGRA_USB_DMA_ALIGN - 1;
 
         kmalloc_ptr = kmalloc(kmalloc_size, mem_flags);
         if (!kmalloc_ptr)
                 return -ENOMEM;
 
-        /* Position our struct temp_buffer such that data is aligned */
+        /* Position our struct dma_aligned_buffer such that data is aligned */
         temp = PTR_ALIGN(kmalloc_ptr + 1, TEGRA_USB_DMA_ALIGN) - 1;
-
         temp->kmalloc_ptr = kmalloc_ptr;
         temp->old_xfer_buffer = urb->transfer_buffer;
-        if (dir == DMA_TO_DEVICE)
+        if (usb_urb_dir_out(urb))
                 memcpy(temp->data, urb->transfer_buffer,
                        urb->transfer_buffer_length);
         urb->transfer_buffer = temp->data;
@@ -533,13 +370,13 @@ static int tegra_ehci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
 {
         int ret;
 
-        ret = alloc_temp_buffer(urb, mem_flags);
+        ret = alloc_dma_aligned_buffer(urb, mem_flags);
         if (ret)
                 return ret;
 
         ret = usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
         if (ret)
-                free_temp_buffer(urb);
+                free_dma_aligned_buffer(urb);
 
         return ret;
 }
@@ -547,49 +384,51 @@ static int tegra_ehci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
 static void tegra_ehci_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
 {
         usb_hcd_unmap_urb_for_dma(hcd, urb);
-        free_temp_buffer(urb);
+        free_dma_aligned_buffer(urb);
 }
 
 static const struct hc_driver tegra_ehci_hc_driver = {
         .description            = hcd_name,
         .product_desc           = "Tegra EHCI Host Controller",
         .hcd_priv_size          = sizeof(struct ehci_hcd),
-
         .flags                  = HCD_USB2 | HCD_MEMORY,
 
-        .reset                  = tegra_ehci_setup,
+        /* standard ehci functions */
         .irq                    = ehci_irq,
-
         .start                  = ehci_run,
         .stop                   = ehci_stop,
-        .shutdown               = tegra_ehci_shutdown,
         .urb_enqueue            = ehci_urb_enqueue,
         .urb_dequeue            = ehci_urb_dequeue,
-        .map_urb_for_dma        = tegra_ehci_map_urb_for_dma,
-        .unmap_urb_for_dma      = tegra_ehci_unmap_urb_for_dma,
         .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            = tegra_ehci_hub_control,
         .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
-#ifdef CONFIG_PM
-        .bus_suspend            = tegra_ehci_bus_suspend,
-        .bus_resume             = tegra_ehci_bus_resume,
-#endif
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
+
+        /* modified ehci functions for tegra */
+        .reset                  = tegra_ehci_setup,
+        .shutdown               = tegra_ehci_shutdown,
+        .map_urb_for_dma        = tegra_ehci_map_urb_for_dma,
+        .unmap_urb_for_dma      = tegra_ehci_unmap_urb_for_dma,
+        .hub_control            = tegra_ehci_hub_control,
+#ifdef CONFIG_PM
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
 };
 
-static int setup_vbus_gpio(struct platform_device *pdev)
+static int setup_vbus_gpio(struct platform_device *pdev,
+                           struct tegra_ehci_platform_data *pdata)
 {
         int err = 0;
         int gpio;
 
-        if (!pdev->dev.of_node)
-                return 0;
-
-        gpio = of_get_named_gpio(pdev->dev.of_node, "nvidia,vbus-gpio", 0);
+        gpio = pdata->vbus_gpio;
+        if (!gpio_is_valid(gpio))
+                gpio = of_get_named_gpio(pdev->dev.of_node,
+                                         "nvidia,vbus-gpio", 0);
         if (!gpio_is_valid(gpio))
                 return 0;
 
@@ -603,11 +442,187 @@ static int setup_vbus_gpio(struct platform_device *pdev)
                 dev_err(&pdev->dev, "can't enable vbus\n");
                 return err;
         }
-        gpio_set_value(gpio, 1);
 
         return err;
 }
 
+#ifdef CONFIG_PM
+
+static int controller_suspend(struct device *dev)
+{
+        struct tegra_ehci_hcd *tegra =
+                        platform_get_drvdata(to_platform_device(dev));
+        struct ehci_hcd *ehci = tegra->ehci;
+        struct usb_hcd *hcd = ehci_to_hcd(ehci);
+        struct ehci_regs __iomem *hw = ehci->regs;
+        unsigned long flags;
+
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(10);
+
+        spin_lock_irqsave(&ehci->lock, flags);
+
+        tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
+        ehci_halt(ehci);
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        tegra_ehci_power_down(hcd);
+        return 0;
+}
+
+static int controller_resume(struct device *dev)
+{
+        struct tegra_ehci_hcd *tegra =
+                        platform_get_drvdata(to_platform_device(dev));
+        struct ehci_hcd *ehci = tegra->ehci;
+        struct usb_hcd *hcd = ehci_to_hcd(ehci);
+        struct ehci_regs __iomem *hw = ehci->regs;
+        unsigned long val;
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        tegra_ehci_power_up(hcd);
+
+        if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
+                /* Wait for the phy to detect new devices
+                 * before we restart the controller */
+                msleep(10);
+                goto restart;
+        }
+
+        /* Force the phy to keep data lines in suspend state */
+        tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
+
+        /* Enable host mode */
+        tdi_reset(ehci);
+
+        /* Enable Port Power */
+        val = readl(&hw->port_status[0]);
+        val |= PORT_POWER;
+        writel(val, &hw->port_status[0]);
+        udelay(10);
+
+        /* Check if the phy resume from LP0. When the phy resume from LP0
+         * USB register will be reset. */
+        if (!readl(&hw->async_next)) {
+                /* Program the field PTC based on the saved speed mode */
+                val = readl(&hw->port_status[0]);
+                val &= ~PORT_TEST(~0);
+                if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
+                        val |= PORT_TEST_FORCE;
+                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
+                        val |= PORT_TEST(6);
+                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
+                        val |= PORT_TEST(7);
+                writel(val, &hw->port_status[0]);
+                udelay(10);
+
+                /* Disable test mode by setting PTC field to NORMAL_OP */
+                val = readl(&hw->port_status[0]);
+                val &= ~PORT_TEST(~0);
+                writel(val, &hw->port_status[0]);
+                udelay(10);
+        }
+
+        /* Poll until CCS is enabled */
+        if (handshake(ehci, &hw->port_status[0], PORT_CONNECT,
+                                                 PORT_CONNECT, 2000)) {
+                pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
+                goto restart;
+        }
+
+        /* Poll until PE is enabled */
+        if (handshake(ehci, &hw->port_status[0], PORT_PE,
+                                                 PORT_PE, 2000)) {
+                pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
+                goto restart;
+        }
+
+        /* Clear the PCI status, to avoid an interrupt taken upon resume */
+        val = readl(&hw->status);
+        val |= STS_PCD;
+        writel(val, &hw->status);
+
+        /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
+        val = readl(&hw->port_status[0]);
+        if ((val & PORT_POWER) && (val & PORT_PE)) {
+                val |= PORT_SUSPEND;
+                writel(val, &hw->port_status[0]);
+
+                /* Wait until port suspend completes */
+                if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
+                                                         PORT_SUSPEND, 1000)) {
+                        pr_err("%s: timeout waiting for PORT_SUSPEND\n",
+                                                                __func__);
+                        goto restart;
+                }
+        }
+
+        tegra_ehci_phy_restore_end(tegra->phy);
+        goto done;
+
+ restart:
+        if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
+                tegra_ehci_phy_restore_end(tegra->phy);
+
+        tegra_ehci_restart(hcd);
+
+ done:
+        tegra_usb_phy_preresume(tegra->phy);
+        tegra->port_resuming = 1;
+        return 0;
+}
+
+static int tegra_ehci_suspend(struct device *dev)
+{
+        struct tegra_ehci_hcd *tegra =
+                        platform_get_drvdata(to_platform_device(dev));
+        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+        int rc = 0;
+
+        /*
+         * When system sleep is supported and USB controller wakeup is
+         * implemented: If the controller is runtime-suspended and the
+         * wakeup setting needs to be changed, call pm_runtime_resume().
+         */
+        if (HCD_HW_ACCESSIBLE(hcd))
+                rc = controller_suspend(dev);
+        return rc;
+}
+
+static int tegra_ehci_resume(struct device *dev)
+{
+        int rc;
+
+        rc = controller_resume(dev);
+        if (rc == 0) {
+                pm_runtime_disable(dev);
+                pm_runtime_set_active(dev);
+                pm_runtime_enable(dev);
+        }
+        return rc;
+}
+
+static int tegra_ehci_runtime_suspend(struct device *dev)
+{
+        return controller_suspend(dev);
+}
+
+static int tegra_ehci_runtime_resume(struct device *dev)
+{
+        return controller_resume(dev);
+}
+
+static const struct dev_pm_ops tegra_ehci_pm_ops = {
+        .suspend        = tegra_ehci_suspend,
+        .resume         = tegra_ehci_resume,
+        .runtime_suspend = tegra_ehci_runtime_suspend,
+        .runtime_resume = tegra_ehci_runtime_resume,
+};
+
+#endif
+
 static u64 tegra_ehci_dma_mask = DMA_BIT_MASK(32);
 
 static int tegra_ehci_probe(struct platform_device *pdev)
@@ -633,7 +648,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         if (!pdev->dev.dma_mask)
                 pdev->dev.dma_mask = &tegra_ehci_dma_mask;
 
-        setup_vbus_gpio(pdev);
+        setup_vbus_gpio(pdev, pdata);
 
         tegra = kzalloc(sizeof(struct tegra_ehci_hcd), GFP_KERNEL);
         if (!tegra)
@@ -722,7 +737,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
 
         tegra->host_resumed = 1;
-        tegra->power_down_on_bus_suspend = pdata->power_down_on_bus_suspend;
         tegra->ehci = hcd_to_ehci(hcd);
 
         irq = platform_get_irq(pdev, 0);
@@ -731,7 +745,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                 err = -ENODEV;
                 goto fail;
         }
-        set_irq_flags(irq, IRQF_VALID);
 
 #ifdef CONFIG_USB_OTG_UTILS
         if (pdata->operating_mode == TEGRA_USB_OTG) {
@@ -747,6 +760,14 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                 goto fail;
         }
 
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_get_noresume(&pdev->dev);
+
+        /* Don't skip the pm_runtime_forbid call if wakeup isn't working */
+        /* if (!pdata->power_down_on_bus_suspend) */
+                pm_runtime_forbid(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_put_sync(&pdev->dev);
         return err;
 
 fail:
@@ -773,33 +794,6 @@ fail_hcd:
         return err;
 }
 
-#ifdef CONFIG_PM
-static int tegra_ehci_resume(struct platform_device *pdev)
-{
-        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
-
-        if (tegra->bus_suspended)
-                return 0;
-
-        return tegra_usb_resume(hcd);
-}
-
-static int tegra_ehci_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
-
-        if (tegra->bus_suspended)
-                return 0;
-
-        if (time_before(jiffies, tegra->ehci->next_statechange))
-                msleep(10);
-
-        return tegra_usb_suspend(hcd);
-}
-#endif
-
 static int tegra_ehci_remove(struct platform_device *pdev)
 {
         struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
@@ -808,6 +802,10 @@ static int tegra_ehci_remove(struct platform_device *pdev)
         if (tegra == NULL || hcd == NULL)
                 return -EINVAL;
 
+        pm_runtime_get_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_put_noidle(&pdev->dev);
+
 #ifdef CONFIG_USB_OTG_UTILS
         if (tegra->transceiver) {
                 otg_set_host(tegra->transceiver->otg, NULL);
@@ -848,13 +846,12 @@ static struct of_device_id tegra_ehci_of_match[] __devinitdata = {
 static struct platform_driver tegra_ehci_driver = {
         .probe          = tegra_ehci_probe,
         .remove         = tegra_ehci_remove,
-#ifdef CONFIG_PM
-        .suspend        = tegra_ehci_suspend,
-        .resume         = tegra_ehci_resume,
-#endif
         .shutdown       = tegra_ehci_hcd_shutdown,
         .driver         = {
                 .name   = "tegra-ehci",
                 .of_match_table = tegra_ehci_of_match,
+#ifdef CONFIG_PM
+                .pm     = &tegra_ehci_pm_ops,
+#endif
         }
 };
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 0ea577bfca2..c5ed8819929 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -155,7 +155,7 @@ u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
         struct endpoint *ep;
         struct usb_td __iomem *td;
         unsigned long ep_offset;
-        char *err_for = "enpoint PRAM";
+        char *err_for = "endpoint PRAM";
         int ep_mem_size;
         u32 i;
 
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index ab333ac6071..22ff6b3a676 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -119,6 +119,39 @@ error:
 
 static const struct of_device_id fsl_usb2_mph_dr_of_match[];
 
+static int usb_get_ver_info(struct device_node *np)
+{
+        int ver = -1;
+
+        /*
+         * returns 1 for usb controller version 1.6
+         * returns 2 for usb controller version 2.2
+         * returns 0 otherwise
+         */
+        if (of_device_is_compatible(np, "fsl-usb2-dr")) {
+                if (of_device_is_compatible(np, "fsl-usb2-dr-v1.6"))
+                        ver = FSL_USB_VER_1_6;
+                else if (of_device_is_compatible(np, "fsl-usb2-dr-v2.2"))
+                        ver = FSL_USB_VER_2_2;
+                else /* for previous controller versions */
+                        ver = FSL_USB_VER_OLD;
+
+                if (ver > -1)
+                        return ver;
+        }
+
+        if (of_device_is_compatible(np, "fsl-usb2-mph")) {
+                if (of_device_is_compatible(np, "fsl-usb2-mph-v1.6"))
+                        ver = FSL_USB_VER_1_6;
+                else if (of_device_is_compatible(np, "fsl-usb2-mph-v2.2"))
+                        ver = FSL_USB_VER_2_2;
+                else /* for previous controller versions */
+                        ver = FSL_USB_VER_OLD;
+        }
+
+        return ver;
+}
+
 static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -166,6 +199,14 @@ static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
 
         prop = of_get_property(np, "phy_type", NULL);
         pdata->phy_mode = determine_usb_phy(prop);
+        pdata->controller_ver = usb_get_ver_info(np);
+
+        if (pdata->have_sysif_regs) {
+                if (pdata->controller_ver < 0) {
+                        dev_warn(&ofdev->dev, "Could not get controller version\n");
+                        return -ENODEV;
+                }
+        }
 
         for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
                 if (!dev_data->drivers[i])
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index fc72d44bf78..a35bbddf896 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1562,11 +1562,14 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
 
         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
                 retval = -ESHUTDOWN;
+                qtd_list_free(&new_qtds);
                 goto out;
         }
         retval = usb_hcd_link_urb_to_ep(hcd, urb);
-        if (retval)
+        if (retval) {
+                qtd_list_free(&new_qtds);
                 goto out;
+        }
 
         qh = urb->ep->hcpriv;
         if (qh) {
@@ -1584,6 +1587,7 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 if (!qh) {
                         retval = -ENOMEM;
                         usb_hcd_unlink_urb_from_ep(hcd, urb);
+                        qtd_list_free(&new_qtds);
                         goto out;
                 }
                 list_add_tail(&qh->qh_list, ep_queue);
@@ -1683,6 +1687,7 @@ 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) {
                         dequeue_urb_from_qtd(hcd, qh, qtd);
+                        list_move(&qtd->qtd_list, &qh->qtd_list);
                         break;
                 }
 
@@ -2176,7 +2181,7 @@ static const struct hc_driver isp1760_hc_driver = {
 
 int __init init_kmem_once(void)
 {
-        urb_listitem_cachep = kmem_cache_create("isp1760 urb_listitem",
+        urb_listitem_cachep = kmem_cache_create("isp1760_urb_listitem",
                         sizeof(struct urb_listitem), 0, SLAB_TEMPORARY |
                         SLAB_MEM_SPREAD, NULL);
 
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 4592dc17a9f..fff114fd546 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -398,6 +398,9 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
                                irqflags, -ENOENT,
                                &pdev->dev, dev_name(&pdev->dev), devflags);
+
+        dev_set_drvdata(&pdev->dev, hcd);
+
         if (IS_ERR(hcd)) {
                 pr_warning("isp1760: Failed to register the HCD device\n");
                 ret = -ENODEV;
@@ -417,11 +420,16 @@ static int __devexit isp1760_plat_remove(struct platform_device *pdev)
 {
         struct resource *mem_res;
         resource_size_t mem_size;
+        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
+
+        usb_remove_hcd(hcd);
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         mem_size = resource_size(mem_res);
         release_mem_region(mem_res->start, mem_size);
 
+        usb_put_hcd(hcd);
+
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 09f597ad6e0..a665b3eaa74 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -94,7 +94,7 @@ static void at91_stop_hc(struct platform_device *pdev)
 
 /*-------------------------------------------------------------------------*/
 
-static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
+static void __devexit usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
 
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -108,7 +108,7 @@ static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
  * then invokes the start() method for the HCD associated with it
  * through the hotplug entry's driver_data.
  */
-static int usb_hcd_at91_probe(const struct hc_driver *driver,
+static int __devinit usb_hcd_at91_probe(const struct hc_driver *driver,
                         struct platform_device *pdev)
 {
         int retval;
@@ -129,7 +129,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         if (!hcd)
                 return -ENOMEM;
         hcd->rsrc_start = pdev->resource[0].start;
-        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
+        hcd->rsrc_len = resource_size(&pdev->resource[0]);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 pr_debug("request_mem_region failed\n");
@@ -203,7 +203,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
  * context, "rmmod" or something similar.
  *
  */
-static void usb_hcd_at91_remove(struct usb_hcd *hcd,
+static void __devexit usb_hcd_at91_remove(struct usb_hcd *hcd,
                                 struct platform_device *pdev)
 {
         usb_remove_hcd(hcd);
@@ -223,7 +223,7 @@ static void usb_hcd_at91_remove(struct usb_hcd *hcd,
 /*-------------------------------------------------------------------------*/
 
 static int __devinit
-ohci_at91_start (struct usb_hcd *hcd)
+ohci_at91_reset (struct usb_hcd *hcd)
 {
         struct at91_usbh_data   *board = hcd->self.controller->platform_data;
         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
@@ -233,9 +233,18 @@ ohci_at91_start (struct usb_hcd *hcd)
                 return ret;
 
         ohci->num_ports = board->ports;
+        return 0;
+}
+
+static int __devinit
+ohci_at91_start (struct usb_hcd *hcd)
+{
+        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
+        int                     ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
@@ -418,6 +427,7 @@ static const struct hc_driver ohci_at91_hc_driver = {
         /*
          * basic lifecycle operations
          */
+        .reset =                ohci_at91_reset,
         .start =                ohci_at91_start,
         .stop =                 ohci_stop,
         .shutdown =             ohci_shutdown,
@@ -545,7 +555,7 @@ static int __devinit ohci_at91_of_init(struct platform_device *pdev)
 
 /*-------------------------------------------------------------------------*/
 
-static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
+static int __devinit ohci_hcd_at91_drv_probe(struct platform_device *pdev)
 {
         struct at91_usbh_data   *pdata;
         int                     i;
@@ -620,7 +630,7 @@ static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
         return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
 }
 
-static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
+static int __devexit ohci_hcd_at91_drv_remove(struct platform_device *pdev)
 {
         struct at91_usbh_data   *pdata = pdev->dev.platform_data;
         int                     i;
@@ -696,7 +706,7 @@ MODULE_ALIAS("platform:at91_ohci");
 
 static struct platform_driver ohci_hcd_at91_driver = {
         .probe          = ohci_hcd_at91_drv_probe,
-        .remove         = ohci_hcd_at91_drv_remove,
+        .remove         = __devexit_p(ohci_hcd_at91_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
         .suspend        = ohci_hcd_at91_drv_suspend,
         .resume         = ohci_hcd_at91_drv_resume,
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 4ea63b2cac4..c611699b4aa 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -37,7 +37,8 @@ static int __devinit ohci_au1xxx_start(struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-cns3xxx.c b/drivers/usb/host/ohci-cns3xxx.c
index 5a00a1e1c6c..2c9f233047b 100644
--- a/drivers/usb/host/ohci-cns3xxx.c
+++ b/drivers/usb/host/ohci-cns3xxx.c
@@ -41,7 +41,8 @@ cns3xxx_ohci_start(struct usb_hcd *hcd)
 
         ret = ohci_run(ohci);
         if (ret < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-da8xx.c b/drivers/usb/host/ohci-da8xx.c
index 843509778a3..269b1e0f769 100644
--- a/drivers/usb/host/ohci-da8xx.c
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -454,3 +454,5 @@ static struct platform_driver ohci_hcd_da8xx_driver = {
                 .name   = "ohci",
         },
 };
+
+MODULE_ALIAS("platform:ohci");
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index e4bcb62b930..31b81f9eacd 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -29,14 +29,14 @@ urb_print(struct urb * urb, char * str, int small, int status)
         unsigned int pipe= urb->pipe;
 
         if (!urb->dev || !urb->dev->bus) {
-                dbg("%s URB: no dev", str);
+                printk(KERN_DEBUG "%s URB: no dev\n", str);
                 return;
         }
 
 #ifndef OHCI_VERBOSE_DEBUG
         if (status != 0)
 #endif
-        dbg("%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d",
+        printk(KERN_DEBUG "%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d\n",
                     str,
                     urb,
                     usb_pipedevice (pipe),
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index 3d63574d2c7..dbfbd1dfd2e 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -47,7 +47,7 @@ static int usb_hcd_ep93xx_probe(const struct hc_driver *driver,
         struct usb_hcd *hcd;
 
         if (pdev->resource[1].flags != IORESOURCE_IRQ) {
-                dbg("resource[1] is not IORESOURCE_IRQ");
+                dev_dbg(&pdev->dev, "resource[1] is not IORESOURCE_IRQ\n");
                 return -ENOMEM;
         }
 
@@ -65,14 +65,14 @@ static int usb_hcd_ep93xx_probe(const struct hc_driver *driver,
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (hcd->regs == NULL) {
-                dbg("ioremap failed");
+                dev_dbg(&pdev->dev, "ioremap failed\n");
                 retval = -ENOMEM;
                 goto err2;
         }
 
         usb_host_clock = clk_get(&pdev->dev, NULL);
         if (IS_ERR(usb_host_clock)) {
-                dbg("clk_get failed");
+                dev_dbg(&pdev->dev, "clk_get failed\n");
                 retval = PTR_ERR(usb_host_clock);
                 goto err3;
         }
@@ -116,7 +116,8 @@ static int __devinit ohci_ep93xx_start(struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index 37bb20ebb6f..2909621ea19 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -35,7 +35,8 @@ static int ohci_exynos_start(struct usb_hcd *hcd)
 
         ret = ohci_run(ohci);
         if (ret < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 235171f2946..e0adf5c0cf5 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1080,11 +1080,6 @@ MODULE_LICENSE ("GPL");
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
 #endif
 
-#ifdef CONFIG_USB_OHCI_HCD_SSB
-#include "ohci-ssb.c"
-#define SSB_OHCI_DRIVER         ssb_ohci_driver
-#endif
-
 #ifdef CONFIG_MFD_SM501
 #include "ohci-sm501.c"
 #define SM501_OHCI_DRIVER       ohci_hcd_sm501_driver
@@ -1128,8 +1123,7 @@ MODULE_LICENSE ("GPL");
         !defined(SA1111_DRIVER) &&      \
         !defined(PS3_SYSTEM_BUS_DRIVER) && \
         !defined(SM501_OHCI_DRIVER) && \
-        !defined(TMIO_OHCI_DRIVER) && \
-        !defined(SSB_OHCI_DRIVER)
+        !defined(TMIO_OHCI_DRIVER)
 #error "missing bus glue for ohci-hcd"
 #endif
 
@@ -1195,12 +1189,6 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_pci;
 #endif
 
-#ifdef SSB_OHCI_DRIVER
-        retval = ssb_driver_register(&SSB_OHCI_DRIVER);
-        if (retval)
-                goto error_ssb;
-#endif
-
 #ifdef SM501_OHCI_DRIVER
         retval = platform_driver_register(&SM501_OHCI_DRIVER);
         if (retval < 0)
@@ -1224,10 +1212,6 @@ static int __init ohci_hcd_mod_init(void)
         platform_driver_unregister(&SM501_OHCI_DRIVER);
  error_sm501:
 #endif
-#ifdef SSB_OHCI_DRIVER
-        ssb_driver_unregister(&SSB_OHCI_DRIVER);
- error_ssb:
-#endif
 #ifdef PCI_DRIVER
         pci_unregister_driver(&PCI_DRIVER);
  error_pci:
@@ -1275,9 +1259,6 @@ static void __exit ohci_hcd_mod_exit(void)
 #ifdef SM501_OHCI_DRIVER
         platform_driver_unregister(&SM501_OHCI_DRIVER);
 #endif
-#ifdef SSB_OHCI_DRIVER
-        ssb_driver_unregister(&SSB_OHCI_DRIVER);
-#endif
 #ifdef PCI_DRIVER
         pci_unregister_driver(&PCI_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-nxp.c b/drivers/usb/host/ohci-nxp.c
index 6618de1d881..1e364ec962f 100644
--- a/drivers/usb/host/ohci-nxp.c
+++ b/drivers/usb/host/ohci-nxp.c
@@ -22,6 +22,8 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
+#include <linux/of.h>
+#include <linux/usb/isp1301.h>
 
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
@@ -29,7 +31,6 @@
 
 #include <mach/platform.h>
 #include <mach/irqs.h>
-#include <asm/gpio.h>
 
 #define USB_CONFIG_BASE         0x31020000
 #define PWRMAN_BASE             0x40004000
@@ -38,7 +39,9 @@
 
 /* USB_CTRL bit defines */
 #define USB_SLAVE_HCLK_EN       (1 << 24)
+#define USB_DEV_NEED_CLK_EN     (1 << 22)
 #define USB_HOST_NEED_CLK_EN    (1 << 21)
+#define PAD_CONTROL_LAST_DRIVEN (1 << 19)
 
 #define USB_OTG_CLK_CTRL        IO_ADDRESS(USB_CONFIG_BASE + 0xFF4)
 #define USB_OTG_CLK_STAT        IO_ADDRESS(USB_CONFIG_BASE + 0xFF8)
@@ -56,54 +59,6 @@
 #define TRANSPARENT_I2C_EN      (1 << 7)
 #define HOST_EN                 (1 << 0)
 
-/* ISP1301 USB transceiver I2C registers */
-#define ISP1301_MODE_CONTROL_1          0x04    /* u8 read, set, +1 clear */
-
-#define MC1_SPEED_REG           (1 << 0)
-#define MC1_SUSPEND_REG         (1 << 1)
-#define MC1_DAT_SE0             (1 << 2)
-#define MC1_TRANSPARENT         (1 << 3)
-#define MC1_BDIS_ACON_EN        (1 << 4)
-#define MC1_OE_INT_EN           (1 << 5)
-#define MC1_UART_EN             (1 << 6)
-#define MC1_MASK                0x7f
-
-#define ISP1301_MODE_CONTROL_2          0x12    /* u8 read, set, +1 clear */
-
-#define MC2_GLOBAL_PWR_DN       (1 << 0)
-#define MC2_SPD_SUSP_CTRL       (1 << 1)
-#define MC2_BI_DI               (1 << 2)
-#define MC2_TRANSP_BDIR0        (1 << 3)
-#define MC2_TRANSP_BDIR1        (1 << 4)
-#define MC2_AUDIO_EN            (1 << 5)
-#define MC2_PSW_EN              (1 << 6)
-#define MC2_EN2V7               (1 << 7)
-
-#define ISP1301_OTG_CONTROL_1           0x06    /* u8 read, set, +1 clear */
-#       define  OTG1_DP_PULLUP          (1 << 0)
-#       define  OTG1_DM_PULLUP          (1 << 1)
-#       define  OTG1_DP_PULLDOWN        (1 << 2)
-#       define  OTG1_DM_PULLDOWN        (1 << 3)
-#       define  OTG1_ID_PULLDOWN        (1 << 4)
-#       define  OTG1_VBUS_DRV           (1 << 5)
-#       define  OTG1_VBUS_DISCHRG       (1 << 6)
-#       define  OTG1_VBUS_CHRG          (1 << 7)
-#define ISP1301_OTG_STATUS              0x10    /* u8 readonly */
-#       define  OTG_B_SESS_END          (1 << 6)
-#       define  OTG_B_SESS_VLD          (1 << 7)
-
-#define ISP1301_I2C_ADDR 0x2C
-
-#define ISP1301_I2C_MODE_CONTROL_1 0x4
-#define ISP1301_I2C_MODE_CONTROL_2 0x12
-#define ISP1301_I2C_OTG_CONTROL_1 0x6
-#define ISP1301_I2C_OTG_CONTROL_2 0x10
-#define ISP1301_I2C_INTERRUPT_SOURCE 0x8
-#define ISP1301_I2C_INTERRUPT_LATCH 0xA
-#define ISP1301_I2C_INTERRUPT_FALLING 0xC
-#define ISP1301_I2C_INTERRUPT_RISING 0xE
-#define ISP1301_I2C_REG_CLEAR_ADDR 1
-
 /* On LPC32xx, those are undefined */
 #ifndef start_int_set_falling_edge
 #define start_int_set_falling_edge(irq)
@@ -113,42 +68,12 @@
 #define start_int_umask(irq)
 #endif
 
-static struct i2c_driver isp1301_driver;
 static struct i2c_client *isp1301_i2c_client;
 
 extern int usb_disabled(void);
-extern int ocpi_enable(void);
 
 static struct clk *usb_clk;
 
-static const unsigned short normal_i2c[] =
-    { ISP1301_I2C_ADDR, ISP1301_I2C_ADDR + 1, I2C_CLIENT_END };
-
-static int isp1301_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
-{
-        return 0;
-}
-
-static int isp1301_remove(struct i2c_client *client)
-{
-        return 0;
-}
-
-static const struct i2c_device_id isp1301_id[] = {
-        { "isp1301_nxp", 0 },
-        { }
-};
-
-static struct i2c_driver isp1301_driver = {
-        .driver = {
-                .name = "isp1301_nxp",
-        },
-        .probe = isp1301_probe,
-        .remove = isp1301_remove,
-        .id_table = isp1301_id,
-};
-
 static void isp1301_configure_pnx4008(void)
 {
         /* PNX4008 only supports DAT_SE0 USB mode */
@@ -220,7 +145,7 @@ static void isp1301_configure_lpc32xx(void)
                 ISP1301_I2C_INTERRUPT_RISING | ISP1301_I2C_REG_CLEAR_ADDR, ~0);
 
         /* Enable usb_need_clk clock after transceiver is initialized */
-        __raw_writel((__raw_readl(USB_CTRL) | (1 << 22)), USB_CTRL);
+        __raw_writel(__raw_readl(USB_CTRL) | USB_HOST_NEED_CLK_EN, USB_CTRL);
 
         printk(KERN_INFO "ISP1301 Vendor ID  : 0x%04x\n",
               i2c_smbus_read_word_data(isp1301_i2c_client, 0x00));
@@ -372,65 +297,55 @@ static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev)
         struct usb_hcd *hcd = 0;
         struct ohci_hcd *ohci;
         const struct hc_driver *driver = &ohci_nxp_hc_driver;
-        struct i2c_adapter *i2c_adap;
-        struct i2c_board_info i2c_info;
-
+        struct resource *res;
         int ret = 0, irq;
+        struct device_node *isp1301_node;
 
-        dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (nxp)\n", hcd_name);
-        if (usb_disabled()) {
-                err("USB is disabled");
-                ret = -ENODEV;
-                goto out;
+        if (pdev->dev.of_node) {
+                isp1301_node = of_parse_phandle(pdev->dev.of_node,
+                                                "transceiver", 0);
+        } else {
+                isp1301_node = NULL;
         }
 
-        if (pdev->num_resources != 2
-            || pdev->resource[0].flags != IORESOURCE_MEM
-            || pdev->resource[1].flags != IORESOURCE_IRQ) {
-                err("Invalid resource configuration");
-                ret = -ENODEV;
+        isp1301_i2c_client = isp1301_get_client(isp1301_node);
+        if (!isp1301_i2c_client) {
+                ret = -EPROBE_DEFER;
                 goto out;
         }
 
-        /* Enable AHB slave USB clock, needed for further USB clock control */
-        __raw_writel(USB_SLAVE_HCLK_EN | (1 << 19), USB_CTRL);
+        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
 
-        ret = i2c_add_driver(&isp1301_driver);
-        if (ret < 0) {
-                err("failed to add ISP1301 driver");
-                goto out;
-        }
-        i2c_adap = i2c_get_adapter(2);
-        memset(&i2c_info, 0, sizeof(struct i2c_board_info));
-        strlcpy(i2c_info.type, "isp1301_nxp", I2C_NAME_SIZE);
-        isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
-                                                   normal_i2c, NULL);
-        i2c_put_adapter(i2c_adap);
-        if (!isp1301_i2c_client) {
-                err("failed to connect I2C to ISP1301 USB Transceiver");
+        dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (nxp)\n", hcd_name);
+        if (usb_disabled()) {
+                dev_err(&pdev->dev, "USB is disabled\n");
                 ret = -ENODEV;
-                goto out_i2c_driver;
+                goto out;
         }
 
+        /* Enable AHB slave USB clock, needed for further USB clock control */
+        __raw_writel(USB_SLAVE_HCLK_EN | PAD_CONTROL_LAST_DRIVEN, USB_CTRL);
+
         isp1301_configure();
 
         /* Enable USB PLL */
         usb_clk = clk_get(&pdev->dev, "ck_pll5");
         if (IS_ERR(usb_clk)) {
-                err("failed to acquire USB PLL");
+                dev_err(&pdev->dev, "failed to acquire USB PLL\n");
                 ret = PTR_ERR(usb_clk);
                 goto out1;
         }
 
         ret = clk_enable(usb_clk);
         if (ret < 0) {
-                err("failed to start USB PLL");
+                dev_err(&pdev->dev, "failed to start USB PLL\n");
                 goto out2;
         }
 
         ret = clk_set_rate(usb_clk, 48000);
         if (ret < 0) {
-                err("failed to set USB clock rate");
+                dev_err(&pdev->dev, "failed to set USB clock rate\n");
                 goto out3;
         }
 
@@ -442,9 +357,9 @@ static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev)
         while ((__raw_readl(USB_OTG_CLK_STAT) & USB_CLOCK_MASK) !=
                USB_CLOCK_MASK) ;
 
-        hcd = usb_create_hcd (driver, &pdev->dev, dev_name(&pdev->dev));
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
-                err("Failed to allocate HC buffer");
+                dev_err(&pdev->dev, "Failed to allocate HC buffer\n");
                 ret = -ENOMEM;
                 goto out3;
         }
@@ -452,14 +367,21 @@ static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev)
         /* Set all USB bits in the Start Enable register */
         nxp_set_usb_bits();
 
-        hcd->rsrc_start = pdev->resource[0].start;
-        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                dev_dbg(&pdev->dev, "request_mem_region failed\n");
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Failed to get MEM resource\n");
+                ret =  -ENOMEM;
+                goto out4;
+        }
+
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "Failed to devm_request_and_ioremap\n");
                 ret =  -ENOMEM;
                 goto out4;
         }
-        hcd->regs = (void __iomem *)pdev->resource[0].start;
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -486,10 +408,7 @@ out3:
 out2:
         clk_put(usb_clk);
 out1:
-        i2c_unregister_device(isp1301_i2c_client);
         isp1301_i2c_client = NULL;
-out_i2c_driver:
-        i2c_del_driver(&isp1301_driver);
 out:
         return ret;
 }
@@ -507,7 +426,6 @@ static int usb_hcd_nxp_remove(struct platform_device *pdev)
         clk_put(usb_clk);
         i2c_unregister_device(isp1301_i2c_client);
         isp1301_i2c_client = NULL;
-        i2c_del_driver(&isp1301_driver);
 
         platform_set_drvdata(pdev, NULL);
 
@@ -517,10 +435,19 @@ static int usb_hcd_nxp_remove(struct platform_device *pdev)
 /* work with hotplug and coldplug */
 MODULE_ALIAS("platform:usb-ohci");
 
+#ifdef CONFIG_OF
+static const struct of_device_id usb_hcd_nxp_match[] = {
+        { .compatible = "nxp,ohci-nxp" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, usb_hcd_nxp_match);
+#endif
+
 static struct platform_driver usb_hcd_nxp_driver = {
         .driver = {
                 .name = "usb-ohci",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(usb_hcd_nxp_match),
         },
         .probe = usb_hcd_nxp_probe,
         .remove = usb_hcd_nxp_remove,
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 96451e41ee8..9ce35d0d9d5 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -205,8 +205,9 @@ static int ohci_omap_init(struct usb_hcd *hcd)
         need_transceiver = need_transceiver
                         || machine_is_omap_h2() || machine_is_omap_h3();
 
-        if (cpu_is_omap16xx())
-                ocpi_enable();
+        /* XXX OMAP16xx only */
+        if (config->ocpi_enable)
+                config->ocpi_enable();
 
 #ifdef  CONFIG_USB_OTG
         if (need_transceiver) {
@@ -217,8 +218,7 @@ static int ohci_omap_init(struct usb_hcd *hcd)
                         dev_dbg(hcd->self.controller, "init %s transceiver, status %d\n",
                                         ohci->transceiver->label, status);
                         if (status) {
-                                if (ohci->transceiver)
-                                        put_device(ohci->transceiver->dev);
+                                usb_put_transceiver(ohci->transceiver);
                                 return status;
                         }
                 } else {
@@ -405,7 +405,7 @@ usb_hcd_omap_remove (struct usb_hcd *hcd, struct platform_device *pdev)
         usb_remove_hcd(hcd);
         if (ohci->transceiver) {
                 (void) otg_set_host(ohci->transceiver->otg, 0);
-                put_device(ohci->transceiver->dev);
+                usb_put_transceiver(ohci->transceiver);
         }
         if (machine_is_omap_osk())
                 gpio_free(9);
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index ec5c6791c8b..670c7059c9a 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -93,13 +93,13 @@ static int __devinit ohci_platform_probe(struct platform_device *dev)
 
         irq = platform_get_irq(dev, 0);
         if (irq < 0) {
-                pr_err("no irq provieded");
+                pr_err("no irq provided");
                 return irq;
         }
 
         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!res_mem) {
-                pr_err("no memory recourse provieded");
+                pr_err("no memory recourse provided");
                 return -ENXIO;
         }
 
diff --git a/drivers/usb/host/ohci-pnx8550.c b/drivers/usb/host/ohci-pnx8550.c
index f13d08f94d6..148d27d6a67 100644
--- a/drivers/usb/host/ohci-pnx8550.c
+++ b/drivers/usb/host/ohci-pnx8550.c
@@ -157,7 +157,8 @@ ohci_pnx8550_start (struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run (ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s",
+                        hcd->self.bus_name);
                 ohci_stop (hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index d24cc89de16..e27d5ae2b9e 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -29,7 +29,8 @@ ohci_ppc_of_start(struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err("can't start %s", ohci_to_hcd(ohci)->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
@@ -236,7 +237,7 @@ MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match);
 
 #if     !defined(CONFIG_USB_OHCI_HCD_PPC_OF_BE) && \
         !defined(CONFIG_USB_OHCI_HCD_PPC_OF_LE)
-#error "No endianess selected for ppc-of-ohci"
+#error "No endianness selected for ppc-of-ohci"
 #endif
 
 
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 1514b706747..185c39ed81b 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -130,7 +130,8 @@ ohci_ppc_soc_start(struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err("can't start %s", ohci_to_hcd(ohci)->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-ps3.c b/drivers/usb/host/ohci-ps3.c
index 6fd4fa1f19b..2ee1d8d713d 100644
--- a/drivers/usb/host/ohci-ps3.c
+++ b/drivers/usb/host/ohci-ps3.c
@@ -45,7 +45,8 @@ static int __devinit ps3_ohci_hc_start(struct usb_hcd *hcd)
         result = ohci_run(ohci);
 
         if (result < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
         }
 
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index c31b2815be1..e1a3cc6d28d 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -419,7 +419,8 @@ ohci_pxa27x_start (struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run (ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s",
+                        hcd->self.bus_name);
                 ohci_stop (hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index 56dcf069246..664c869eb09 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -420,7 +420,8 @@ ohci_s3c2410_start(struct usb_hcd *hcd)
 
         ret = ohci_run(ohci);
         if (ret < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index e1004fb37bd..b6cc9252092 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -46,7 +46,7 @@ static void dump_hci_status(struct usb_hcd *hcd, const char *label)
 {
         unsigned long status = sa1111_readl(hcd->regs + USB_STATUS);
 
-        dbg("%s USB_STATUS = { %s%s%s%s%s}", label,
+        printk(KERN_DEBUG "%s USB_STATUS = { %s%s%s%s%s}\n", label,
              ((status & USB_STATUS_IRQHCIRMTWKUP) ? "IRQHCIRMTWKUP " : ""),
              ((status & USB_STATUS_IRQHCIBUFFACC) ? "IRQHCIBUFFACC " : ""),
              ((status & USB_STATUS_NIRQHCIM) ? "" : "IRQHCIM "),
@@ -193,7 +193,7 @@ static int ohci_hcd_sa1111_probe(struct sa1111_dev *dev)
         hcd->rsrc_len = resource_size(&dev->res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                dbg("request_mem_region failed");
+                dev_dbg(&dev->dev, "request_mem_region failed\n");
                 ret = -EBUSY;
                 goto err1;
         }
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index 84686d90805..76a20c27836 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -88,20 +88,20 @@ static int ohci_hcd_sh_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
-                err("platform_get_resource error.");
+                dev_err(&pdev->dev, "platform_get_resource error.\n");
                 return -ENODEV;
         }
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                err("platform_get_irq error.");
+                dev_err(&pdev->dev, "platform_get_irq error.\n");
                 return -ENODEV;
         }
 
         /* initialize hcd */
         hcd = usb_create_hcd(&ohci_sh_hc_driver, &pdev->dev, (char *)hcd_name);
         if (!hcd) {
-                err("Failed to create hcd");
+                dev_err(&pdev->dev, "Failed to create hcd\n");
                 return -ENOMEM;
         }
 
@@ -110,7 +110,7 @@ static int ohci_hcd_sh_probe(struct platform_device *pdev)
         hcd->rsrc_len = resource_size(res);
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret != 0) {
-                err("Failed to add hcd");
+                dev_err(&pdev->dev, "Failed to add hcd\n");
                 usb_put_hcd(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 95c16489e88..fc7305ee3c9 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -14,6 +14,7 @@
 #include <linux/signal.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/of.h>
 
 struct spear_ohci {
         struct ohci_hcd ohci;
@@ -24,12 +25,12 @@ struct spear_ohci {
 
 static void spear_start_ohci(struct spear_ohci *ohci)
 {
-        clk_enable(ohci->clk);
+        clk_prepare_enable(ohci->clk);
 }
 
 static void spear_stop_ohci(struct spear_ohci *ohci)
 {
-        clk_disable(ohci->clk);
+        clk_disable_unprepare(ohci->clk);
 }
 
 static int __devinit ohci_spear_start(struct usb_hcd *hcd)
@@ -90,6 +91,8 @@ static const struct hc_driver ohci_spear_hc_driver = {
         .start_port_reset       = ohci_start_port_reset,
 };
 
+static u64 spear_ohci_dma_mask = DMA_BIT_MASK(32);
+
 static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
 {
         const struct hc_driver *driver = &ohci_spear_hc_driver;
@@ -98,11 +101,8 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
         struct spear_ohci *ohci_p;
         struct resource *res;
         int retval, irq;
-        int *pdata = pdev->dev.platform_data;
         char clk_name[20] = "usbh_clk";
-
-        if (pdata == NULL)
-                return -EFAULT;
+        static int instance = -1;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -110,8 +110,22 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
                 goto fail_irq_get;
         }
 
-        if (*pdata >= 0)
-                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+        /*
+         * Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &spear_ohci_dma_mask;
+
+        /*
+         * Increment the device instance, when probing via device-tree
+         */
+        if (pdev->id < 0)
+                instance++;
+        else
+                instance = pdev->id;
+        sprintf(clk_name, "usbh.%01d_clk", instance);
 
         usbh_clk = clk_get(NULL, clk_name);
         if (IS_ERR(usbh_clk)) {
@@ -222,6 +236,11 @@ static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
 }
 #endif
 
+static struct of_device_id spear_ohci_id_table[] __devinitdata = {
+        { .compatible = "st,spear600-ohci", },
+        { },
+};
+
 /* Driver definition to register with the platform bus */
 static struct platform_driver spear_ohci_hcd_driver = {
         .probe =        spear_ohci_hcd_drv_probe,
@@ -233,6 +252,7 @@ static struct platform_driver spear_ohci_hcd_driver = {
         .driver = {
                 .owner = THIS_MODULE,
                 .name = "spear-ohci",
+                .of_match_table = of_match_ptr(spear_ohci_id_table),
         },
 };
 
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
deleted file mode 100644
index 5ba18595d6f..00000000000
--- a/drivers/usb/host/ohci-ssb.c
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom USB-core OHCI driver
- *
- * Copyright 2007 Michael Buesch <m@bues.ch>
- *
- * Derived from the OHCI-PCI driver
- * Copyright 1999 Roman Weissgaerber
- * Copyright 2000-2002 David Brownell
- * Copyright 1999 Linus Torvalds
- * Copyright 1999 Gregory P. Smith
- *
- * Derived from the USBcore related parts of Broadcom-SB
- * Copyright 2005 Broadcom Corporation
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-#include <linux/ssb/ssb.h>
-
-
-#define SSB_OHCI_TMSLOW_HOSTMODE        (1 << 29)
-
-struct ssb_ohci_device {
-        struct ohci_hcd ohci; /* _must_ be at the beginning. */
-
-        u32 enable_flags;
-};
-
-static inline
-struct ssb_ohci_device *hcd_to_ssb_ohci(struct usb_hcd *hcd)
-{
-        return (struct ssb_ohci_device *)(hcd->hcd_priv);
-}
-
-
-static int ssb_ohci_reset(struct usb_hcd *hcd)
-{
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-        struct ohci_hcd *ohci = &ohcidev->ohci;
-        int err;
-
-        ohci_hcd_init(ohci);
-        err = ohci_init(ohci);
-
-        return err;
-}
-
-static int ssb_ohci_start(struct usb_hcd *hcd)
-{
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-        struct ohci_hcd *ohci = &ohcidev->ohci;
-        int err;
-
-        err = ohci_run(ohci);
-        if (err < 0) {
-                ohci_err(ohci, "can't start\n");
-                ohci_stop(hcd);
-        }
-
-        return err;
-}
-
-static const struct hc_driver ssb_ohci_hc_driver = {
-        .description            = "ssb-usb-ohci",
-        .product_desc           = "SSB OHCI Controller",
-        .hcd_priv_size          = sizeof(struct ssb_ohci_device),
-
-        .irq                    = ohci_irq,
-        .flags                  = HCD_MEMORY | HCD_USB11,
-
-        .reset                  = ssb_ohci_reset,
-        .start                  = ssb_ohci_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 void ssb_ohci_detach(struct ssb_device *dev)
-{
-        struct usb_hcd *hcd = ssb_get_drvdata(dev);
-
-        if (hcd->driver->shutdown)
-                hcd->driver->shutdown(hcd);
-        usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
-        ssb_device_disable(dev, 0);
-}
-
-static int ssb_ohci_attach(struct ssb_device *dev)
-{
-        struct ssb_ohci_device *ohcidev;
-        struct usb_hcd *hcd;
-        int err = -ENOMEM;
-        u32 tmp, flags = 0;
-
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
-                return -EOPNOTSUPP;
-
-        if (dev->id.coreid == SSB_DEV_USB11_HOSTDEV) {
-                /* Put the device into host-mode. */
-                flags |= SSB_OHCI_TMSLOW_HOSTMODE;
-                ssb_device_enable(dev, flags);
-        } else if (dev->id.coreid == SSB_DEV_USB20_HOST) {
-                /*
-                 * USB 2.0 special considerations:
-                 *
-                 * In addition to the standard SSB reset sequence, the Host
-                 * Control Register must be programmed to bring the USB core
-                 * and various phy components out of reset.
-                 */
-                ssb_device_enable(dev, 0);
-                ssb_write32(dev, 0x200, 0x7ff);
-
-                /* Change Flush control reg */
-                tmp = ssb_read32(dev, 0x400);
-                tmp &= ~8;
-                ssb_write32(dev, 0x400, tmp);
-                tmp = ssb_read32(dev, 0x400);
-
-                /* Change Shim control reg */
-                tmp = ssb_read32(dev, 0x304);
-                tmp &= ~0x100;
-                ssb_write32(dev, 0x304, tmp);
-                tmp = ssb_read32(dev, 0x304);
-
-                udelay(1);
-
-                /* Work around for 5354 failures */
-                if (dev->id.revision == 2 && dev->bus->chip_id == 0x5354) {
-                        /* Change syn01 reg */
-                        tmp = 0x00fe00fe;
-                        ssb_write32(dev, 0x894, tmp);
-
-                        /* Change syn03 reg */
-                        tmp = ssb_read32(dev, 0x89c);
-                        tmp |= 0x1;
-                        ssb_write32(dev, 0x89c, tmp);
-                }
-        } else
-                ssb_device_enable(dev, 0);
-
-        hcd = usb_create_hcd(&ssb_ohci_hc_driver, dev->dev,
-                        dev_name(dev->dev));
-        if (!hcd)
-                goto err_dev_disable;
-        ohcidev = hcd_to_ssb_ohci(hcd);
-        ohcidev->enable_flags = flags;
-
-        tmp = ssb_read32(dev, SSB_ADMATCH0);
-        hcd->rsrc_start = ssb_admatch_base(tmp);
-        hcd->rsrc_len = ssb_admatch_size(tmp);
-        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_SHARED);
-        if (err)
-                goto err_iounmap;
-
-        ssb_set_drvdata(dev, hcd);
-
-        return err;
-
-err_iounmap:
-        iounmap(hcd->regs);
-err_put_hcd:
-        usb_put_hcd(hcd);
-err_dev_disable:
-        ssb_device_disable(dev, flags);
-        return err;
-}
-
-static int ssb_ohci_probe(struct ssb_device *dev,
-                const struct ssb_device_id *id)
-{
-        int err;
-        u16 chipid_top;
-
-        /* USBcores are only connected on embedded devices. */
-        chipid_top = (dev->bus->chip_id & 0xFF00);
-        if (chipid_top != 0x4700 && chipid_top != 0x5300)
-                return -ENODEV;
-
-        /* TODO: Probably need checks here; is the core connected? */
-
-        if (usb_disabled())
-                return -ENODEV;
-
-        /* We currently always attach SSB_DEV_USB11_HOSTDEV
-         * as HOST OHCI. If we want to attach it as Client device,
-         * we must branch here and call into the (yet to
-         * be written) Client mode driver. Same for remove(). */
-
-        err = ssb_ohci_attach(dev);
-
-        return err;
-}
-
-static void ssb_ohci_remove(struct ssb_device *dev)
-{
-        ssb_ohci_detach(dev);
-}
-
-#ifdef CONFIG_PM
-
-static int ssb_ohci_suspend(struct ssb_device *dev, pm_message_t state)
-{
-        ssb_device_disable(dev, 0);
-
-        return 0;
-}
-
-static int ssb_ohci_resume(struct ssb_device *dev)
-{
-        struct usb_hcd *hcd = ssb_get_drvdata(dev);
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-
-        ssb_device_enable(dev, ohcidev->enable_flags);
-
-        ohci_finish_controller_resume(hcd);
-        return 0;
-}
-
-#else /* !CONFIG_PM */
-#define ssb_ohci_suspend        NULL
-#define ssb_ohci_resume NULL
-#endif /* CONFIG_PM */
-
-static const struct ssb_device_id ssb_ohci_table[] = {
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOSTDEV, SSB_ANY_REV),
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOST, SSB_ANY_REV),
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB20_HOST, SSB_ANY_REV),
-        SSB_DEVTABLE_END
-};
-MODULE_DEVICE_TABLE(ssb, ssb_ohci_table);
-
-static struct ssb_driver ssb_ohci_driver = {
-        .name           = KBUILD_MODNAME,
-        .id_table       = ssb_ohci_table,
-        .probe          = ssb_ohci_probe,
-        .remove         = ssb_ohci_remove,
-        .suspend        = ssb_ohci_suspend,
-        .resume         = ssb_ohci_resume,
-};
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 120bfe6ede3..60c2b0722f2 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -140,7 +140,8 @@ static int ohci_tmio_start(struct usb_hcd *hcd)
                 return ret;
 
         if ((ret = ohci_run(ohci)) < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/ohci-xls.c b/drivers/usb/host/ohci-xls.c
index a2247867af8..41e378f17c6 100644
--- a/drivers/usb/host/ohci-xls.c
+++ b/drivers/usb/host/ohci-xls.c
@@ -88,7 +88,8 @@ static int __devinit ohci_xls_start(struct usb_hcd *hcd)
         ohci = hcd_to_ohci(hcd);
         ret = ohci_run(ohci);
         if (ret < 0) {
-                err("can't start %s", hcd->self.bus_name);
+                dev_err(hcd->self.controller, "can't start %s\n",
+                        hcd->self.bus_name);
                 ohci_stop(hcd);
                 return ret;
         }
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 3b38030b02a..4f0f0339532 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -1399,8 +1399,8 @@ static struct ehci_qh *qh_make(struct oxu_hcd *oxu,
                                  * But interval 1 scheduling is simpler, and
                                  * includes high bandwidth.
                                  */
-                                dbg("intr period %d uframes, NYET!",
-                                                urb->interval);
+                                oxu_dbg(oxu, "intr period %d uframes, NYET!\n",
+                                        urb->interval);
                                 goto done;
                         }
                 } else {
@@ -1471,7 +1471,7 @@ static struct ehci_qh *qh_make(struct oxu_hcd *oxu,
                 }
                 break;
         default:
-                dbg("bogus dev %p speed %d", urb->dev, urb->dev->speed);
+                oxu_dbg(oxu, "bogus dev %p speed %d\n", urb->dev, urb->dev->speed);
 done:
                 qh_put(qh);
                 return NULL;
@@ -2307,7 +2307,7 @@ restart:
                                 qh_put(temp.qh);
                                 break;
                         default:
-                                dbg("corrupt type %d frame %d shadow %p",
+                                oxu_dbg(oxu, "corrupt type %d frame %d shadow %p\n",
                                         type, frame, q.ptr);
                                 q.ptr = NULL;
                         }
@@ -2991,8 +2991,9 @@ static int oxu_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                                 /* shouldn't happen often, but ...
                                  * FIXME kill those tds' urbs
                                  */
-                                err("can't reschedule qh %p, err %d",
-                                        qh, status);
+                                dev_err(hcd->self.controller,
+                                        "can't reschedule qh %p, err %d\n", qh,
+                                        status);
                         }
                         return status;
                 }
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 32dada8c8b4..df0828cb2aa 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/kconfig.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/init.h>
@@ -712,12 +713,28 @@ static int handshake(void __iomem *ptr, u32 mask, u32 done,
         return -ETIMEDOUT;
 }
 
-bool usb_is_intel_switchable_xhci(struct pci_dev *pdev)
+#define PCI_DEVICE_ID_INTEL_LYNX_POINT_XHCI     0x8C31
+
+bool usb_is_intel_ppt_switchable_xhci(struct pci_dev *pdev)
 {
         return pdev->class == PCI_CLASS_SERIAL_USB_XHCI &&
                 pdev->vendor == PCI_VENDOR_ID_INTEL &&
                 pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI;
 }
+
+/* The Intel Lynx Point chipset also has switchable ports. */
+bool usb_is_intel_lpt_switchable_xhci(struct pci_dev *pdev)
+{
+        return pdev->class == PCI_CLASS_SERIAL_USB_XHCI &&
+                pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == PCI_DEVICE_ID_INTEL_LYNX_POINT_XHCI;
+}
+
+bool usb_is_intel_switchable_xhci(struct pci_dev *pdev)
+{
+        return usb_is_intel_ppt_switchable_xhci(pdev) ||
+                usb_is_intel_lpt_switchable_xhci(pdev);
+}
 EXPORT_SYMBOL_GPL(usb_is_intel_switchable_xhci);
 
 /*
@@ -742,6 +759,19 @@ void usb_enable_xhci_ports(struct pci_dev *xhci_pdev)
 {
         u32             ports_available;
 
+        /* Don't switchover the ports if the user hasn't compiled the xHCI
+         * driver.  Otherwise they will see "dead" USB ports that don't power
+         * the devices.
+         */
+        if (!IS_ENABLED(CONFIG_USB_XHCI_HCD)) {
+                dev_warn(&xhci_pdev->dev,
+                                "CONFIG_USB_XHCI_HCD is turned off, "
+                                "defaulting to EHCI.\n");
+                dev_warn(&xhci_pdev->dev,
+                                "USB 3.0 devices will work at USB 2.0 speeds.\n");
+                return;
+        }
+
         ports_available = 0xffffffff;
         /* Write USB3_PSSEN, the USB 3.0 Port SuperSpeed Enable
          * Register, to turn on SuperSpeed terminations for all
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 2bf1320dc9c..c868be65e76 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -401,7 +401,7 @@ static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
                 if (r8a66597->address_map & (1 << addr))
                         continue;
 
-                dbg("alloc_address: r8a66597_addr=%d", addr);
+                dev_dbg(&urb->dev->dev, "alloc_address: r8a66597_addr=%d\n", addr);
                 r8a66597->address_map |= 1 << addr;
 
                 if (make_r8a66597_device(r8a66597, urb, addr) < 0)
@@ -426,7 +426,7 @@ static void free_usb_address(struct r8a66597 *r8a66597,
         if (!dev)
                 return;
 
-        dbg("free_addr: addr=%d", dev->address);
+        dev_dbg(&dev->udev->dev, "free_addr: addr=%d\n", dev->address);
 
         dev->state = USB_STATE_DEFAULT;
         r8a66597->address_map &= ~(1 << dev->address);
@@ -819,7 +819,7 @@ static void enable_r8a66597_pipe(struct r8a66597 *r8a66597, struct urb *urb,
         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
         struct r8a66597_pipe *pipe = hep->hcpriv;
 
-        dbg("enable_pipe:");
+        dev_dbg(&dev->udev->dev, "enable_pipe:\n");
 
         pipe->info = *info;
         set_pipe_reg_addr(pipe, R8A66597_PIPE_NO_DMA);
@@ -898,7 +898,7 @@ static void disable_r8a66597_pipe_all(struct r8a66597 *r8a66597,
                 force_dequeue(r8a66597, pipenum, dev->address);
         }
 
-        dbg("disable_pipe");
+        dev_dbg(&dev->udev->dev, "disable_pipe\n");
 
         r8a66597->dma_map &= ~(dev->dma_map);
         dev->dma_map = 0;
@@ -2264,7 +2264,7 @@ static int r8a66597_bus_suspend(struct usb_hcd *hcd)
         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
         int port;
 
-        dbg("%s", __func__);
+        dev_dbg(&r8a66597->device0.udev->dev, "%s\n", __func__);
 
         for (port = 0; port < r8a66597->max_root_hub; port++) {
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
@@ -2273,7 +2273,7 @@ static int r8a66597_bus_suspend(struct usb_hcd *hcd)
                 if (!(rh->port & USB_PORT_STAT_ENABLE))
                         continue;
 
-                dbg("suspend port = %d", port);
+                dev_dbg(&rh->dev->udev->dev, "suspend port = %d\n", port);
                 r8a66597_bclr(r8a66597, UACT, dvstctr_reg);     /* suspend */
                 rh->port |= USB_PORT_STAT_SUSPEND;
 
@@ -2295,7 +2295,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
         int port;
 
-        dbg("%s", __func__);
+        dev_dbg(&r8a66597->device0.udev->dev, "%s\n", __func__);
 
         for (port = 0; port < r8a66597->max_root_hub; port++) {
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
@@ -2304,7 +2304,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
                 if (!(rh->port & USB_PORT_STAT_SUSPEND))
                         continue;
 
-                dbg("resume port = %d", port);
+                dev_dbg(&rh->dev->udev->dev, "resume port = %d\n", port);
                 rh->port &= ~USB_PORT_STAT_SUSPEND;
                 rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
@@ -2360,7 +2360,7 @@ static int r8a66597_suspend(struct device *dev)
         struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
         int port;
 
-        dbg("%s", __func__);
+        dev_dbg(dev, "%s\n", __func__);
 
         disable_controller(r8a66597);
 
@@ -2378,7 +2378,7 @@ static int r8a66597_resume(struct device *dev)
         struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
 
-        dbg("%s", __func__);
+        dev_dbg(dev, "%s\n", __func__);
 
         enable_controller(r8a66597);
         usb_root_hub_lost_power(hcd->self.root_hub);
diff --git a/drivers/usb/host/ssb-hcd.c b/drivers/usb/host/ssb-hcd.c
new file mode 100644
index 00000000000..c2a29faba07
--- /dev/null
+++ b/drivers/usb/host/ssb-hcd.c
@@ -0,0 +1,280 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom USB-core driver  (SSB bus glue)
+ *
+ * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de>
+ *
+ * Based on ssb-ohci driver
+ * Copyright 2007 Michael Buesch <m@bues.ch>
+ *
+ * Derived from the OHCI-PCI driver
+ * Copyright 1999 Roman Weissgaerber
+ * Copyright 2000-2002 David Brownell
+ * Copyright 1999 Linus Torvalds
+ * Copyright 1999 Gregory P. Smith
+ *
+ * Derived from the USBcore related parts of Broadcom-SB
+ * Copyright 2005-2011 Broadcom Corporation
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+#include <linux/ssb/ssb.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb/ehci_pdriver.h>
+#include <linux/usb/ohci_pdriver.h>
+
+MODULE_AUTHOR("Hauke Mehrtens");
+MODULE_DESCRIPTION("Common USB driver for SSB Bus");
+MODULE_LICENSE("GPL");
+
+#define SSB_HCD_TMSLOW_HOSTMODE (1 << 29)
+
+struct ssb_hcd_device {
+        struct platform_device *ehci_dev;
+        struct platform_device *ohci_dev;
+
+        u32 enable_flags;
+};
+
+static void __devinit ssb_hcd_5354wa(struct ssb_device *dev)
+{
+#ifdef CONFIG_SSB_DRIVER_MIPS
+        /* Work around for 5354 failures */
+        if (dev->id.revision == 2 && dev->bus->chip_id == 0x5354) {
+                /* Change syn01 reg */
+                ssb_write32(dev, 0x894, 0x00fe00fe);
+
+                /* Change syn03 reg */
+                ssb_write32(dev, 0x89c, ssb_read32(dev, 0x89c) | 0x1);
+        }
+#endif
+}
+
+static void __devinit ssb_hcd_usb20wa(struct ssb_device *dev)
+{
+        if (dev->id.coreid == SSB_DEV_USB20_HOST) {
+                /*
+                 * USB 2.0 special considerations:
+                 *
+                 * In addition to the standard SSB reset sequence, the Host
+                 * Control Register must be programmed to bring the USB core
+                 * and various phy components out of reset.
+                 */
+                ssb_write32(dev, 0x200, 0x7ff);
+
+                /* Change Flush control reg */
+                ssb_write32(dev, 0x400, ssb_read32(dev, 0x400) & ~8);
+                ssb_read32(dev, 0x400);
+
+                /* Change Shim control reg */
+                ssb_write32(dev, 0x304, ssb_read32(dev, 0x304) & ~0x100);
+                ssb_read32(dev, 0x304);
+
+                udelay(1);
+
+                ssb_hcd_5354wa(dev);
+        }
+}
+
+/* based on arch/mips/brcm-boards/bcm947xx/pcibios.c */
+static u32 __devinit ssb_hcd_init_chip(struct ssb_device *dev)
+{
+        u32 flags = 0;
+
+        if (dev->id.coreid == SSB_DEV_USB11_HOSTDEV)
+                /* Put the device into host-mode. */
+                flags |= SSB_HCD_TMSLOW_HOSTMODE;
+
+        ssb_device_enable(dev, flags);
+
+        ssb_hcd_usb20wa(dev);
+
+        return flags;
+}
+
+static const struct usb_ehci_pdata ehci_pdata = {
+};
+
+static const struct usb_ohci_pdata ohci_pdata = {
+};
+
+static struct platform_device * __devinit
+ssb_hcd_create_pdev(struct ssb_device *dev, bool ohci, u32 addr, u32 len)
+{
+        struct platform_device *hci_dev;
+        struct resource hci_res[2];
+        int ret = -ENOMEM;
+
+        memset(hci_res, 0, sizeof(hci_res));
+
+        hci_res[0].start = addr;
+        hci_res[0].end = hci_res[0].start + len - 1;
+        hci_res[0].flags = IORESOURCE_MEM;
+
+        hci_res[1].start = dev->irq;
+        hci_res[1].flags = IORESOURCE_IRQ;
+
+        hci_dev = platform_device_alloc(ohci ? "ohci-platform" :
+                                        "ehci-platform" , 0);
+        if (!hci_dev)
+                return NULL;
+
+        hci_dev->dev.parent = dev->dev;
+        hci_dev->dev.dma_mask = &hci_dev->dev.coherent_dma_mask;
+
+        ret = platform_device_add_resources(hci_dev, hci_res,
+                                            ARRAY_SIZE(hci_res));
+        if (ret)
+                goto err_alloc;
+        if (ohci)
+                ret = platform_device_add_data(hci_dev, &ohci_pdata,
+                                               sizeof(ohci_pdata));
+        else
+                ret = platform_device_add_data(hci_dev, &ehci_pdata,
+                                               sizeof(ehci_pdata));
+        if (ret)
+                goto err_alloc;
+        ret = platform_device_add(hci_dev);
+        if (ret)
+                goto err_alloc;
+
+        return hci_dev;
+
+err_alloc:
+        platform_device_put(hci_dev);
+        return ERR_PTR(ret);
+}
+
+static int __devinit ssb_hcd_probe(struct ssb_device *dev,
+                                   const struct ssb_device_id *id)
+{
+        int err, tmp;
+        int start, len;
+        u16 chipid_top;
+        u16 coreid = dev->id.coreid;
+        struct ssb_hcd_device *usb_dev;
+
+        /* USBcores are only connected on embedded devices. */
+        chipid_top = (dev->bus->chip_id & 0xFF00);
+        if (chipid_top != 0x4700 && chipid_top != 0x5300)
+                return -ENODEV;
+
+        /* TODO: Probably need checks here; is the core connected? */
+
+        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
+            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+                return -EOPNOTSUPP;
+
+        usb_dev = kzalloc(sizeof(struct ssb_hcd_device), GFP_KERNEL);
+        if (!usb_dev)
+                return -ENOMEM;
+
+        /* We currently always attach SSB_DEV_USB11_HOSTDEV
+         * as HOST OHCI. If we want to attach it as Client device,
+         * we must branch here and call into the (yet to
+         * be written) Client mode driver. Same for remove(). */
+        usb_dev->enable_flags = ssb_hcd_init_chip(dev);
+
+        tmp = ssb_read32(dev, SSB_ADMATCH0);
+
+        start = ssb_admatch_base(tmp);
+        len = (coreid == SSB_DEV_USB20_HOST) ? 0x800 : ssb_admatch_size(tmp);
+        usb_dev->ohci_dev = ssb_hcd_create_pdev(dev, true, start, len);
+        if (IS_ERR(usb_dev->ohci_dev)) {
+                err = PTR_ERR(usb_dev->ohci_dev);
+                goto err_free_usb_dev;
+        }
+
+        if (coreid == SSB_DEV_USB20_HOST) {
+                start = ssb_admatch_base(tmp) + 0x800; /* ehci core offset */
+                usb_dev->ehci_dev = ssb_hcd_create_pdev(dev, false, start, len);
+                if (IS_ERR(usb_dev->ehci_dev)) {
+                        err = PTR_ERR(usb_dev->ehci_dev);
+                        goto err_unregister_ohci_dev;
+                }
+        }
+
+        ssb_set_drvdata(dev, usb_dev);
+        return 0;
+
+err_unregister_ohci_dev:
+        platform_device_unregister(usb_dev->ohci_dev);
+err_free_usb_dev:
+        kfree(usb_dev);
+        return err;
+}
+
+static void __devexit ssb_hcd_remove(struct ssb_device *dev)
+{
+        struct ssb_hcd_device *usb_dev = ssb_get_drvdata(dev);
+        struct platform_device *ohci_dev = usb_dev->ohci_dev;
+        struct platform_device *ehci_dev = usb_dev->ehci_dev;
+
+        if (ohci_dev)
+                platform_device_unregister(ohci_dev);
+        if (ehci_dev)
+                platform_device_unregister(ehci_dev);
+
+        ssb_device_disable(dev, 0);
+}
+
+static void __devexit ssb_hcd_shutdown(struct ssb_device *dev)
+{
+        ssb_device_disable(dev, 0);
+}
+
+#ifdef CONFIG_PM
+
+static int ssb_hcd_suspend(struct ssb_device *dev, pm_message_t state)
+{
+        ssb_device_disable(dev, 0);
+
+        return 0;
+}
+
+static int ssb_hcd_resume(struct ssb_device *dev)
+{
+        struct ssb_hcd_device *usb_dev = ssb_get_drvdata(dev);
+
+        ssb_device_enable(dev, usb_dev->enable_flags);
+
+        return 0;
+}
+
+#else /* !CONFIG_PM */
+#define ssb_hcd_suspend NULL
+#define ssb_hcd_resume  NULL
+#endif /* CONFIG_PM */
+
+static const struct ssb_device_id ssb_hcd_table[] __devinitconst = {
+        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOSTDEV, SSB_ANY_REV),
+        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOST, SSB_ANY_REV),
+        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB20_HOST, SSB_ANY_REV),
+        SSB_DEVTABLE_END
+};
+MODULE_DEVICE_TABLE(ssb, ssb_hcd_table);
+
+static struct ssb_driver ssb_hcd_driver = {
+        .name           = KBUILD_MODNAME,
+        .id_table       = ssb_hcd_table,
+        .probe          = ssb_hcd_probe,
+        .remove         = __devexit_p(ssb_hcd_remove),
+        .shutdown       = ssb_hcd_shutdown,
+        .suspend        = ssb_hcd_suspend,
+        .resume         = ssb_hcd_resume,
+};
+
+static int __init ssb_hcd_init(void)
+{
+        return ssb_driver_register(&ssb_hcd_driver);
+}
+module_init(ssb_hcd_init);
+
+static void __exit ssb_hcd_exit(void)
+{
+        ssb_driver_unregister(&ssb_hcd_driver);
+}
+module_exit(ssb_hcd_exit);
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 673ad120c43..2732ef660c5 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -475,6 +475,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         struct xhci_bus_state *bus_state;
         u16 link_state = 0;
         u16 wake_mask = 0;
+        u16 timeout = 0;
 
         max_ports = xhci_get_ports(hcd, &port_array);
         bus_state = &xhci->bus_state[hcd_index(hcd)];
@@ -558,6 +559,7 @@ 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;
+                                clear_bit(wIndex, &bus_state->resuming_ports);
                                 xhci_set_link_state(xhci, port_array, wIndex,
                                                         XDEV_U0);
                                 xhci_dbg(xhci, "set port %d resume\n",
@@ -622,6 +624,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         link_state = (wIndex & 0xff00) >> 3;
                 if (wValue == USB_PORT_FEAT_REMOTE_WAKE_MASK)
                         wake_mask = wIndex & 0xff00;
+                /* The MSB of wIndex is the U1/U2 timeout */
+                timeout = (wIndex & 0xff00) >> 8;
                 wIndex &= 0xff;
                 if (!wIndex || wIndex > max_ports)
                         goto error;
@@ -746,6 +750,22 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                         temp = xhci_readl(xhci, port_array[wIndex]);
                         break;
+                case USB_PORT_FEAT_U1_TIMEOUT:
+                        if (hcd->speed != HCD_USB3)
+                                goto error;
+                        temp = xhci_readl(xhci, port_array[wIndex] + 1);
+                        temp &= ~PORT_U1_TIMEOUT_MASK;
+                        temp |= PORT_U1_TIMEOUT(timeout);
+                        xhci_writel(xhci, temp, port_array[wIndex] + 1);
+                        break;
+                case USB_PORT_FEAT_U2_TIMEOUT:
+                        if (hcd->speed != HCD_USB3)
+                                goto error;
+                        temp = xhci_readl(xhci, port_array[wIndex] + 1);
+                        temp &= ~PORT_U2_TIMEOUT_MASK;
+                        temp |= PORT_U2_TIMEOUT(timeout);
+                        xhci_writel(xhci, temp, port_array[wIndex] + 1);
+                        break;
                 default:
                         goto error;
                 }
@@ -845,7 +865,12 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         /* Initial status is no changes */
         retval = (max_ports + 8) / 8;
         memset(buf, 0, retval);
-        status = 0;
+
+        /*
+         * Inform the usbcore about resume-in-progress by returning
+         * a non-zero value even if there are no status changes.
+         */
+        status = bus_state->resuming_ports;
 
         mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;
 
@@ -885,15 +910,11 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
         spin_lock_irqsave(&xhci->lock, flags);
 
         if (hcd->self.root_hub->do_remote_wakeup) {
-                port_index = max_ports;
-                while (port_index--) {
-                        if (bus_state->resume_done[port_index] != 0) {
-                                spin_unlock_irqrestore(&xhci->lock, flags);
-                                xhci_dbg(xhci, "suspend failed because "
-                                                "port %d is resuming\n",
-                                                port_index + 1);
-                                return -EBUSY;
-                        }
+                if (bus_state->resuming_ports) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_dbg(xhci, "suspend failed because "
+                                                "a port is resuming\n");
+                        return -EBUSY;
                 }
         }
 
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 68eaa908ac8..ec4338eec82 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1791,6 +1791,14 @@ 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;
+        struct list_head *tt_list_head;
+        struct list_head *tt;
+        struct list_head *endpoints;
+        struct list_head *ep, *q;
+        struct xhci_tt_bw_info *tt_info;
+        struct xhci_interval_bw_table *bwt;
+        struct xhci_virt_ep *virt_ep;
+
         unsigned long   flags;
         int size;
         int i;
@@ -1807,6 +1815,9 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->event_ring = NULL;
         xhci_dbg(xhci, "Freed event ring\n");
 
+        if (xhci->lpm_command)
+                xhci_free_command(xhci, xhci->lpm_command);
+        xhci->cmd_ring_reserved_trbs = 0;
         if (xhci->cmd_ring)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
@@ -1849,8 +1860,26 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         }
         spin_unlock_irqrestore(&xhci->lock, flags);
 
+        bwt = &xhci->rh_bw->bw_table;
+        for (i = 0; i < XHCI_MAX_INTERVAL; i++) {
+                endpoints = &bwt->interval_bw[i].endpoints;
+                list_for_each_safe(ep, q, endpoints) {
+                        virt_ep = list_entry(ep, struct xhci_virt_ep, bw_endpoint_list);
+                        list_del(&virt_ep->bw_endpoint_list);
+                        kfree(virt_ep);
+                }
+        }
+
+        tt_list_head = &xhci->rh_bw->tts;
+        list_for_each_safe(tt, q, tt_list_head) {
+                tt_info = list_entry(tt, struct xhci_tt_bw_info, tt_list);
+                list_del(tt);
+                kfree(tt_info);
+        }
+
         xhci->num_usb2_ports = 0;
         xhci->num_usb3_ports = 0;
+        xhci->num_active_eps = 0;
         kfree(xhci->usb2_ports);
         kfree(xhci->usb3_ports);
         kfree(xhci->port_array);
@@ -2350,6 +2379,16 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
         xhci_dbg_cmd_ptrs(xhci);
 
+        xhci->lpm_command = xhci_alloc_command(xhci, true, true, flags);
+        if (!xhci->lpm_command)
+                goto fail;
+
+        /* Reserve one command ring TRB for disabling LPM.
+         * Since the USB core grabs the shared usb_bus bandwidth mutex before
+         * disabling LPM, we only need to reserve one TRB for all devices.
+         */
+        xhci->cmd_ring_reserved_trbs++;
+
         val = xhci_readl(xhci, &xhci->cap_regs->db_off);
         val &= DBOFF_MASK;
         xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x"
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 7a856a767e7..18b231b0c5d 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -72,6 +72,7 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 xhci_dbg(xhci, "QUIRK: Fresco Logic revision %u "
                                 "has broken MSI implementation\n",
                                 pdev->revision);
+                xhci->quirks |= XHCI_TRUST_TX_LENGTH;
         }
 
         if (pdev->vendor == PCI_VENDOR_ID_NEC)
@@ -83,6 +84,10 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
         /* AMD PLL quirk */
         if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
                 xhci->quirks |= XHCI_AMD_PLL_FIX;
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
+                xhci->quirks |= XHCI_LPM_SUPPORT;
+                xhci->quirks |= XHCI_INTEL_HOST;
+        }
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
                         pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI) {
                 xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
@@ -169,6 +174,13 @@ static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         if (retval)
                 goto put_usb3_hcd;
         /* Roothub already marked as USB 3.0 speed */
+
+        /* We know the LPM timeout algorithms for this host, let the USB core
+         * enable and disable LPM for devices under the USB 3.0 roothub.
+         */
+        if (xhci->quirks & XHCI_LPM_SUPPORT)
+                hcd_to_bus(xhci->shared_hcd)->root_hub->lpm_capable = 1;
+
         return 0;
 
 put_usb3_hcd:
@@ -292,6 +304,8 @@ static const struct hc_driver xhci_pci_hc_driver = {
          */
         .update_device =        xhci_update_device,
         .set_usb2_hw_lpm =      xhci_set_usb2_hardware_lpm,
+        .enable_usb3_lpm_timeout =      xhci_enable_usb3_lpm_timeout,
+        .disable_usb3_lpm_timeout =     xhci_disable_usb3_lpm_timeout,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 3d9422f16a2..23b4aefd103 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -1377,6 +1377,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
                         xhci_dbg(xhci, "resume HS port %d\n", port_id);
                         bus_state->resume_done[faked_port_index] = jiffies +
                                 msecs_to_jiffies(20);
+                        set_bit(faked_port_index, &bus_state->resuming_ports);
                         mod_timer(&hcd->rh_timer,
                                   bus_state->resume_done[faked_port_index]);
                         /* Do the rest in GetPortStatus */
@@ -1786,8 +1787,12 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
         /* handle completion code */
         switch (trb_comp_code) {
         case COMP_SUCCESS:
-                frame->status = 0;
-                break;
+                if (TRB_LEN(le32_to_cpu(event->transfer_len)) == 0) {
+                        frame->status = 0;
+                        break;
+                }
+                if ((xhci->quirks & XHCI_TRUST_TX_LENGTH))
+                        trb_comp_code = COMP_SHORT_TX;
         case COMP_SHORT_TX:
                 frame->status = td->urb->transfer_flags & URB_SHORT_NOT_OK ?
                                 -EREMOTEIO : 0;
@@ -1803,6 +1808,7 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 break;
         case COMP_DEV_ERR:
         case COMP_STALL:
+        case COMP_TX_ERR:
                 frame->status = -EPROTO;
                 skip_td = true;
                 break;
@@ -1883,13 +1889,16 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
         switch (trb_comp_code) {
         case COMP_SUCCESS:
                 /* Double check that the HW transferred everything. */
-                if (event_trb != td->last_trb) {
+                if (event_trb != td->last_trb ||
+                                TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
                         xhci_warn(xhci, "WARN Successful completion "
                                         "on short TX\n");
                         if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
                                 *status = -EREMOTEIO;
                         else
                                 *status = 0;
+                        if ((xhci->quirks & XHCI_TRUST_TX_LENGTH))
+                                trb_comp_code = COMP_SHORT_TX;
                 } else {
                         *status = 0;
                 }
@@ -2048,6 +2057,13 @@ static int handle_tx_event(struct xhci_hcd *xhci,
          * transfer type
          */
         case COMP_SUCCESS:
+                if (TRB_LEN(le32_to_cpu(event->transfer_len)) == 0)
+                        break;
+                if (xhci->quirks & XHCI_TRUST_TX_LENGTH)
+                        trb_comp_code = COMP_SHORT_TX;
+                else
+                        xhci_warn(xhci, "WARN Successful completion on short TX: "
+                                        "needs XHCI_TRUST_TX_LENGTH quirk?\n");
         case COMP_SHORT_TX:
                 break;
         case COMP_STOP:
@@ -2270,7 +2286,7 @@ cleanup:
                                         (status != 0 &&
                                          !usb_endpoint_xfer_isoc(&urb->ep->desc)))
                                 xhci_dbg(xhci, "Giveback URB %p, len = %d, "
-                                                "expected = %x, status = %d\n",
+                                                "expected = %d, status = %d\n",
                                                 urb, urb->actual_length,
                                                 urb->transfer_buffer_length,
                                                 status);
@@ -3593,12 +3609,12 @@ int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
 
 /* Queue an evaluate context command TRB */
 int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id)
+                u32 slot_id, bool command_must_succeed)
 {
         return queue_command(xhci, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_EVAL_CONTEXT) | SLOT_ID_FOR_TRB(slot_id),
-                        false);
+                        command_must_succeed);
 }
 
 /*
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 36641a7f237..afdc73ee84a 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -152,7 +152,7 @@ int xhci_reset(struct xhci_hcd *xhci)
 {
         u32 command;
         u32 state;
-        int ret;
+        int ret, i;
 
         state = xhci_readl(xhci, &xhci->op_regs->status);
         if ((state & STS_HALT) == 0) {
@@ -175,7 +175,15 @@ int xhci_reset(struct xhci_hcd *xhci)
          * xHCI cannot write to any doorbells or operational registers other
          * than status until the "Controller Not Ready" flag is cleared.
          */
-        return handshake(xhci, &xhci->op_regs->status, STS_CNR, 0, 250 * 1000);
+        ret = handshake(xhci, &xhci->op_regs->status, STS_CNR, 0, 250 * 1000);
+
+        for (i = 0; i < 2; ++i) {
+                xhci->bus_state[i].port_c_suspend = 0;
+                xhci->bus_state[i].suspended_ports = 0;
+                xhci->bus_state[i].resuming_ports = 0;
+        }
+
+        return ret;
 }
 
 #ifdef CONFIG_PCI
@@ -2438,7 +2446,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                                 udev->slot_id, must_succeed);
         else
                 ret = xhci_queue_evaluate_context(xhci, in_ctx->dma,
-                                udev->slot_id);
+                                udev->slot_id, must_succeed);
         if (ret < 0) {
                 if (command)
                         list_del(&command->cmd_list);
@@ -3863,6 +3871,474 @@ int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
 
 #endif /* CONFIG_USB_SUSPEND */
 
+/*---------------------- USB 3.0 Link PM functions ------------------------*/
+
+#ifdef CONFIG_PM
+/* Service interval in nanoseconds = 2^(bInterval - 1) * 125us * 1000ns / 1us */
+static unsigned long long xhci_service_interval_to_ns(
+                struct usb_endpoint_descriptor *desc)
+{
+        return (1 << (desc->bInterval - 1)) * 125 * 1000;
+}
+
+static u16 xhci_get_timeout_no_hub_lpm(struct usb_device *udev,
+                enum usb3_link_state state)
+{
+        unsigned long long sel;
+        unsigned long long pel;
+        unsigned int max_sel_pel;
+        char *state_name;
+
+        switch (state) {
+        case USB3_LPM_U1:
+                /* Convert SEL and PEL stored in nanoseconds to microseconds */
+                sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
+                pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
+                max_sel_pel = USB3_LPM_MAX_U1_SEL_PEL;
+                state_name = "U1";
+                break;
+        case USB3_LPM_U2:
+                sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
+                pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
+                max_sel_pel = USB3_LPM_MAX_U2_SEL_PEL;
+                state_name = "U2";
+                break;
+        default:
+                dev_warn(&udev->dev, "%s: Can't get timeout for non-U1 or U2 state.\n",
+                                __func__);
+                return -EINVAL;
+        }
+
+        if (sel <= max_sel_pel && pel <= max_sel_pel)
+                return USB3_LPM_DEVICE_INITIATED;
+
+        if (sel > max_sel_pel)
+                dev_dbg(&udev->dev, "Device-initiated %s disabled "
+                                "due to long SEL %llu ms\n",
+                                state_name, sel);
+        else
+                dev_dbg(&udev->dev, "Device-initiated %s disabled "
+                                "due to long PEL %llu\n ms",
+                                state_name, pel);
+        return USB3_LPM_DISABLED;
+}
+
+/* Returns the hub-encoded U1 timeout value.
+ * The U1 timeout should be the maximum of the following values:
+ *  - For control endpoints, U1 system exit latency (SEL) * 3
+ *  - For bulk endpoints, U1 SEL * 5
+ *  - For interrupt endpoints:
+ *    - Notification EPs, U1 SEL * 3
+ *    - Periodic EPs, max(105% of bInterval, U1 SEL * 2)
+ *  - For isochronous endpoints, max(105% of bInterval, U1 SEL * 2)
+ */
+static u16 xhci_calculate_intel_u1_timeout(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc)
+{
+        unsigned long long timeout_ns;
+        int ep_type;
+        int intr_type;
+
+        ep_type = usb_endpoint_type(desc);
+        switch (ep_type) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                timeout_ns = udev->u1_params.sel * 3;
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                timeout_ns = udev->u1_params.sel * 5;
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                intr_type = usb_endpoint_interrupt_type(desc);
+                if (intr_type == USB_ENDPOINT_INTR_NOTIFICATION) {
+                        timeout_ns = udev->u1_params.sel * 3;
+                        break;
+                }
+                /* Otherwise the calculation is the same as isoc eps */
+        case USB_ENDPOINT_XFER_ISOC:
+                timeout_ns = xhci_service_interval_to_ns(desc);
+                timeout_ns = DIV_ROUND_UP_ULL(timeout_ns * 105, 100);
+                if (timeout_ns < udev->u1_params.sel * 2)
+                        timeout_ns = udev->u1_params.sel * 2;
+                break;
+        default:
+                return 0;
+        }
+
+        /* The U1 timeout is encoded in 1us intervals. */
+        timeout_ns = DIV_ROUND_UP_ULL(timeout_ns, 1000);
+        /* Don't return a timeout of zero, because that's USB3_LPM_DISABLED. */
+        if (timeout_ns == USB3_LPM_DISABLED)
+                timeout_ns++;
+
+        /* If the necessary timeout value is bigger than what we can set in the
+         * USB 3.0 hub, we have to disable hub-initiated U1.
+         */
+        if (timeout_ns <= USB3_LPM_U1_MAX_TIMEOUT)
+                return timeout_ns;
+        dev_dbg(&udev->dev, "Hub-initiated U1 disabled "
+                        "due to long timeout %llu ms\n", timeout_ns);
+        return xhci_get_timeout_no_hub_lpm(udev, USB3_LPM_U1);
+}
+
+/* Returns the hub-encoded U2 timeout value.
+ * The U2 timeout should be the maximum of:
+ *  - 10 ms (to avoid the bandwidth impact on the scheduler)
+ *  - largest bInterval of any active periodic endpoint (to avoid going
+ *    into lower power link states between intervals).
+ *  - the U2 Exit Latency of the device
+ */
+static u16 xhci_calculate_intel_u2_timeout(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc)
+{
+        unsigned long long timeout_ns;
+        unsigned long long u2_del_ns;
+
+        timeout_ns = 10 * 1000 * 1000;
+
+        if ((usb_endpoint_xfer_int(desc) || usb_endpoint_xfer_isoc(desc)) &&
+                        (xhci_service_interval_to_ns(desc) > timeout_ns))
+                timeout_ns = xhci_service_interval_to_ns(desc);
+
+        u2_del_ns = udev->bos->ss_cap->bU2DevExitLat * 1000;
+        if (u2_del_ns > timeout_ns)
+                timeout_ns = u2_del_ns;
+
+        /* The U2 timeout is encoded in 256us intervals */
+        timeout_ns = DIV_ROUND_UP_ULL(timeout_ns, 256 * 1000);
+        /* If the necessary timeout value is bigger than what we can set in the
+         * USB 3.0 hub, we have to disable hub-initiated U2.
+         */
+        if (timeout_ns <= USB3_LPM_U2_MAX_TIMEOUT)
+                return timeout_ns;
+        dev_dbg(&udev->dev, "Hub-initiated U2 disabled "
+                        "due to long timeout %llu ms\n", timeout_ns);
+        return xhci_get_timeout_no_hub_lpm(udev, USB3_LPM_U2);
+}
+
+static u16 xhci_call_host_update_timeout_for_endpoint(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc,
+                enum usb3_link_state state,
+                u16 *timeout)
+{
+        if (state == USB3_LPM_U1) {
+                if (xhci->quirks & XHCI_INTEL_HOST)
+                        return xhci_calculate_intel_u1_timeout(udev, desc);
+        } else {
+                if (xhci->quirks & XHCI_INTEL_HOST)
+                        return xhci_calculate_intel_u2_timeout(udev, desc);
+        }
+
+        return USB3_LPM_DISABLED;
+}
+
+static int xhci_update_timeout_for_endpoint(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc,
+                enum usb3_link_state state,
+                u16 *timeout)
+{
+        u16 alt_timeout;
+
+        alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev,
+                desc, state, timeout);
+
+        /* If we found we can't enable hub-initiated LPM, or
+         * the U1 or U2 exit latency was too high to allow
+         * device-initiated LPM as well, just stop searching.
+         */
+        if (alt_timeout == USB3_LPM_DISABLED ||
+                        alt_timeout == USB3_LPM_DEVICE_INITIATED) {
+                *timeout = alt_timeout;
+                return -E2BIG;
+        }
+        if (alt_timeout > *timeout)
+                *timeout = alt_timeout;
+        return 0;
+}
+
+static int xhci_update_timeout_for_interface(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_host_interface *alt,
+                enum usb3_link_state state,
+                u16 *timeout)
+{
+        int j;
+
+        for (j = 0; j < alt->desc.bNumEndpoints; j++) {
+                if (xhci_update_timeout_for_endpoint(xhci, udev,
+                                        &alt->endpoint[j].desc, state, timeout))
+                        return -E2BIG;
+                continue;
+        }
+        return 0;
+}
+
+static int xhci_check_intel_tier_policy(struct usb_device *udev,
+                enum usb3_link_state state)
+{
+        struct usb_device *parent;
+        unsigned int num_hubs;
+
+        if (state == USB3_LPM_U2)
+                return 0;
+
+        /* Don't enable U1 if the device is on a 2nd tier hub or lower. */
+        for (parent = udev->parent, num_hubs = 0; parent->parent;
+                        parent = parent->parent)
+                num_hubs++;
+
+        if (num_hubs < 2)
+                return 0;
+
+        dev_dbg(&udev->dev, "Disabling U1 link state for device"
+                        " below second-tier hub.\n");
+        dev_dbg(&udev->dev, "Plug device into first-tier hub "
+                        "to decrease power consumption.\n");
+        return -E2BIG;
+}
+
+static int xhci_check_tier_policy(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                enum usb3_link_state state)
+{
+        if (xhci->quirks & XHCI_INTEL_HOST)
+                return xhci_check_intel_tier_policy(udev, state);
+        return -EINVAL;
+}
+
+/* Returns the U1 or U2 timeout that should be enabled.
+ * If the tier check or timeout setting functions return with a non-zero exit
+ * code, that means the timeout value has been finalized and we shouldn't look
+ * at any more endpoints.
+ */
+static u16 xhci_calculate_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct usb_host_config *config;
+        char *state_name;
+        int i;
+        u16 timeout = USB3_LPM_DISABLED;
+
+        if (state == USB3_LPM_U1)
+                state_name = "U1";
+        else if (state == USB3_LPM_U2)
+                state_name = "U2";
+        else {
+                dev_warn(&udev->dev, "Can't enable unknown link state %i\n",
+                                state);
+                return timeout;
+        }
+
+        if (xhci_check_tier_policy(xhci, udev, state) < 0)
+                return timeout;
+
+        /* Gather some information about the currently installed configuration
+         * and alternate interface settings.
+         */
+        if (xhci_update_timeout_for_endpoint(xhci, udev, &udev->ep0.desc,
+                        state, &timeout))
+                return timeout;
+
+        config = udev->actconfig;
+        if (!config)
+                return timeout;
+
+        for (i = 0; i < USB_MAXINTERFACES; i++) {
+                struct usb_driver *driver;
+                struct usb_interface *intf = config->interface[i];
+
+                if (!intf)
+                        continue;
+
+                /* Check if any currently bound drivers want hub-initiated LPM
+                 * disabled.
+                 */
+                if (intf->dev.driver) {
+                        driver = to_usb_driver(intf->dev.driver);
+                        if (driver && driver->disable_hub_initiated_lpm) {
+                                dev_dbg(&udev->dev, "Hub-initiated %s disabled "
+                                                "at request of driver %s\n",
+                                                state_name, driver->name);
+                                return xhci_get_timeout_no_hub_lpm(udev, state);
+                        }
+                }
+
+                /* Not sure how this could happen... */
+                if (!intf->cur_altsetting)
+                        continue;
+
+                if (xhci_update_timeout_for_interface(xhci, udev,
+                                        intf->cur_altsetting,
+                                        state, &timeout))
+                        return timeout;
+        }
+        return timeout;
+}
+
+/*
+ * Issue an Evaluate Context command to change the Maximum Exit Latency in the
+ * slot context.  If that succeeds, store the new MEL in the xhci_virt_device.
+ */
+static int xhci_change_max_exit_latency(struct xhci_hcd *xhci,
+                        struct usb_device *udev, u16 max_exit_latency)
+{
+        struct xhci_virt_device *virt_dev;
+        struct xhci_command *command;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        struct xhci_slot_ctx *slot_ctx;
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (max_exit_latency == xhci->devs[udev->slot_id]->current_mel) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return 0;
+        }
+
+        /* Attempt to issue an Evaluate Context command to change the MEL. */
+        virt_dev = xhci->devs[udev->slot_id];
+        command = xhci->lpm_command;
+        xhci_slot_copy(xhci, command->in_ctx, virt_dev->out_ctx);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
+        slot_ctx = xhci_get_slot_ctx(xhci, command->in_ctx);
+        slot_ctx->dev_info2 &= cpu_to_le32(~((u32) MAX_EXIT));
+        slot_ctx->dev_info2 |= cpu_to_le32(max_exit_latency);
+
+        xhci_dbg(xhci, "Set up evaluate context for LPM MEL change.\n");
+        xhci_dbg(xhci, "Slot %u Input Context:\n", udev->slot_id);
+        xhci_dbg_ctx(xhci, command->in_ctx, 0);
+
+        /* Issue and wait for the evaluate context command. */
+        ret = xhci_configure_endpoint(xhci, udev, command,
+                        true, true);
+        xhci_dbg(xhci, "Slot %u Output Context:\n", udev->slot_id);
+        xhci_dbg_ctx(xhci, virt_dev->out_ctx, 0);
+
+        if (!ret) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                virt_dev->current_mel = max_exit_latency;
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+        return ret;
+}
+
+static int calculate_max_exit_latency(struct usb_device *udev,
+                enum usb3_link_state state_changed,
+                u16 hub_encoded_timeout)
+{
+        unsigned long long u1_mel_us = 0;
+        unsigned long long u2_mel_us = 0;
+        unsigned long long mel_us = 0;
+        bool disabling_u1;
+        bool disabling_u2;
+        bool enabling_u1;
+        bool enabling_u2;
+
+        disabling_u1 = (state_changed == USB3_LPM_U1 &&
+                        hub_encoded_timeout == USB3_LPM_DISABLED);
+        disabling_u2 = (state_changed == USB3_LPM_U2 &&
+                        hub_encoded_timeout == USB3_LPM_DISABLED);
+
+        enabling_u1 = (state_changed == USB3_LPM_U1 &&
+                        hub_encoded_timeout != USB3_LPM_DISABLED);
+        enabling_u2 = (state_changed == USB3_LPM_U2 &&
+                        hub_encoded_timeout != USB3_LPM_DISABLED);
+
+        /* If U1 was already enabled and we're not disabling it,
+         * or we're going to enable U1, account for the U1 max exit latency.
+         */
+        if ((udev->u1_params.timeout != USB3_LPM_DISABLED && !disabling_u1) ||
+                        enabling_u1)
+                u1_mel_us = DIV_ROUND_UP(udev->u1_params.mel, 1000);
+        if ((udev->u2_params.timeout != USB3_LPM_DISABLED && !disabling_u2) ||
+                        enabling_u2)
+                u2_mel_us = DIV_ROUND_UP(udev->u2_params.mel, 1000);
+
+        if (u1_mel_us > u2_mel_us)
+                mel_us = u1_mel_us;
+        else
+                mel_us = u2_mel_us;
+        /* xHCI host controller max exit latency field is only 16 bits wide. */
+        if (mel_us > MAX_EXIT) {
+                dev_warn(&udev->dev, "Link PM max exit latency of %lluus "
+                                "is too big.\n", mel_us);
+                return -E2BIG;
+        }
+        return mel_us;
+}
+
+/* Returns the USB3 hub-encoded value for the U1/U2 timeout. */
+int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state)
+{
+        struct xhci_hcd *xhci;
+        u16 hub_encoded_timeout;
+        int mel;
+        int ret;
+
+        xhci = hcd_to_xhci(hcd);
+        /* The LPM timeout values are pretty host-controller specific, so don't
+         * enable hub-initiated timeouts unless the vendor has provided
+         * information about their timeout algorithm.
+         */
+        if (!xhci || !(xhci->quirks & XHCI_LPM_SUPPORT) ||
+                        !xhci->devs[udev->slot_id])
+                return USB3_LPM_DISABLED;
+
+        hub_encoded_timeout = xhci_calculate_lpm_timeout(hcd, udev, state);
+        mel = calculate_max_exit_latency(udev, state, hub_encoded_timeout);
+        if (mel < 0) {
+                /* Max Exit Latency is too big, disable LPM. */
+                hub_encoded_timeout = USB3_LPM_DISABLED;
+                mel = 0;
+        }
+
+        ret = xhci_change_max_exit_latency(xhci, udev, mel);
+        if (ret)
+                return ret;
+        return hub_encoded_timeout;
+}
+
+int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state)
+{
+        struct xhci_hcd *xhci;
+        u16 mel;
+        int ret;
+
+        xhci = hcd_to_xhci(hcd);
+        if (!xhci || !(xhci->quirks & XHCI_LPM_SUPPORT) ||
+                        !xhci->devs[udev->slot_id])
+                return 0;
+
+        mel = calculate_max_exit_latency(udev, state, USB3_LPM_DISABLED);
+        ret = xhci_change_max_exit_latency(xhci, udev, mel);
+        if (ret)
+                return ret;
+        return 0;
+}
+#else /* CONFIG_PM */
+
+int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state)
+{
+        return USB3_LPM_DISABLED;
+}
+
+int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state)
+{
+        return 0;
+}
+#endif  /* CONFIG_PM */
+
+/*-------------------------------------------------------------------------*/
+
 /* Once a hub descriptor is fetched for a device, we need to update the xHC's
  * internal data structures for the device.
  */
@@ -4090,7 +4566,6 @@ static int __init xhci_hcd_init(void)
         BUILD_BUG_ON(sizeof(struct xhci_intr_reg) != 8*32/8);
         /* xhci_run_regs has eight fields and embeds 128 xhci_intr_regs */
         BUILD_BUG_ON(sizeof(struct xhci_run_regs) != (8+8*128)*32/8);
-        BUILD_BUG_ON(sizeof(struct xhci_doorbell_array) != 256*32/8);
         return 0;
 unreg_pci:
         xhci_unregister_pci();
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 3d69c4b2b54..de3d6e3e57b 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -362,8 +362,10 @@ struct xhci_op_regs {
  * Timeout can be up to 127us.  0xFF means an infinite timeout.
  */
 #define PORT_U1_TIMEOUT(p)      ((p) & 0xff)
+#define PORT_U1_TIMEOUT_MASK    0xff
 /* Inactivity timer value for transitions into U2 */
 #define PORT_U2_TIMEOUT(p)      (((p) & 0xff) << 8)
+#define PORT_U2_TIMEOUT_MASK    (0xff << 8)
 /* Bits 24:31 for port testing */
 
 /* USB2 Protocol PORTSPMSC */
@@ -914,6 +916,8 @@ struct xhci_virt_device {
         u8                              real_port;
         struct xhci_interval_bw_table   *bw_table;
         struct xhci_tt_bw_info          *tt_info;
+        /* The current max exit latency for the enabled USB3 link states. */
+        u16                             current_mel;
 };
 
 /*
@@ -1362,6 +1366,8 @@ struct xhci_bus_state {
         u32                     suspended_ports;
         u32                     port_remote_wakeup;
         unsigned long           resume_done[USB_MAXCHILDREN];
+        /* which ports have started to resume */
+        unsigned long           resuming_ports;
 };
 
 static inline unsigned int hcd_index(struct usb_hcd *hcd)
@@ -1422,6 +1428,8 @@ struct xhci_hcd {
         /* slot enabling and address device helpers */
         struct completion       addr_dev;
         int slot_id;
+        /* For USB 3.0 LPM enable/disable. */
+        struct xhci_command             *lpm_command;
         /* Internal mirror of the HW's dcbaa */
         struct xhci_virt_device *devs[MAX_HC_SLOTS];
         /* For keeping track of bandwidth domains per roothub. */
@@ -1479,6 +1487,9 @@ struct xhci_hcd {
 #define XHCI_RESET_ON_RESUME    (1 << 7)
 #define XHCI_SW_BW_CHECKING     (1 << 8)
 #define XHCI_AMD_0x96_HOST      (1 << 9)
+#define XHCI_TRUST_TX_LENGTH    (1 << 10)
+#define XHCI_LPM_SUPPORT        (1 << 11)
+#define XHCI_INTEL_HOST         (1 << 12)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
@@ -1752,7 +1763,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
 int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id, bool command_must_succeed);
 int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id);
+                u32 slot_id, bool command_must_succeed);
 int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
                 unsigned int ep_index);
 int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id);
@@ -1776,6 +1787,10 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
 /* xHCI roothub code */
 void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
                                 int port_id, u32 link_state);
+int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state state);
+int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd,
+                        struct usb_device *udev, enum usb3_link_state 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,