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

Pull USB 3.5-rc1 changes from Greg Kroah-Hartman:
 "Here is the big USB 3.5-rc1 pull request for the 3.5-rc1 merge window.

  It's touches a lot of different parts of the kernel, all USB drivers,
  due to some API cleanups (getting rid of the ancient err() macro) and
  some changes that are needed for USB 3.0 power management updates.

  There are also lots of new drivers, pimarily gadget, but others as
  well.  We deleted a staging driver, which was nice, and finally
  dropped the obsolete usbfs code, which will make Al happy to never
  have to touch that again.

  There were some build errors in the tree that linux-next found a few
  days ago, but those were fixed by the most recent changes (all were
  due to us not building with CONFIG_PM disabled.)

  Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>"

* tag 'usb-3.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (477 commits)
  xhci: Fix DIV_ROUND_UP compile error.
  xhci: Fix compile with CONFIG_USB_SUSPEND=n
  USB: Fix core compile with CONFIG_USB_SUSPEND=n
  brcm80211: Fix compile error for .disable_hub_initiated_lpm.
  Revert "USB: EHCI: work around bug in the Philips ISP1562 controller"
  MAINTAINERS: Add myself as maintainer to the USB PHY Layer
  USB: EHCI: fix command register configuration lost problem
  USB: Remove races in devio.c
  USB: ehci-platform: remove update_device
  USB: Disable hub-initiated LPM for comms devices.
  xhci: Add Intel U1/U2 timeout policy.
  xhci: Add infrastructure for host-specific LPM policies.
  USB: Add macros for interrupt endpoint types.
  xhci: Reserve one command for USB3 LPM disable.
  xhci: Some Evaluate Context commands must succeed.
  USB: Disable USB 3.0 LPM in critical sections.
  USB: Add support to enable/disable USB3 link states.
  USB: Allow drivers to disable hub-initiated LPM.
  USB: Calculate USB 3.0 exit latencies for LPM.
  USB: Refactor code to set LPM support flag.
  ...

Conflicts:
	arch/arm/mach-exynos/mach-nuri.c
	arch/arm/mach-exynos/mach-universal_c210.c
	drivers/net/wireless/ath/ath6kl/usb.c

55 files changed, 1953 insertions, 636 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f788eb86707c..74a14f6ed34c 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 0982bcc140bd..9e0a89ced15c 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 000000000000..443da21d73ca
--- /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 680e1a31fb87..7561966fbdc4 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 d0a84bd3f3eb..43362577b54a 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,22 +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 fsl_usb2_platform_data *pdata;
+        struct device *dev = hcd->self.controller;
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
 
-        pdata = hcd->self.controller->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:
@@ -236,6 +245,14 @@ 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 */
                 if (pdata->have_sysif_regs)
                         setbits32(non_ehci + FSL_SOC_USB_CTRL,
@@ -276,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;
@@ -290,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 863fb0c080d7..88403684d10b 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 4a3bc5b7a06f..b100f5f9f4b6 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
@@ -894,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);
@@ -1248,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);
@@ -1378,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
@@ -1501,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 38fe07623152..fc9e7cc6ac9b 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 5c78f9e71466..a44294d13494 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -242,15 +242,6 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
 
         ehci_reset(omap_ehci);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
-        if (ret) {
-                dev_err(dev, "failed to add hcd with err %d\n", ret);
-                goto err_add_hcd;
-        }
-
-        /* root ports should always stay powered */
-        ehci_port_power(omap_ehci, 1);
-
         if (pdata->phy_reset) {
                 /* Hold the PHY in RESET for enough time till
                  * PHY is settled and ready
@@ -258,12 +249,21 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 udelay(10);
 
                 if (gpio_is_valid(pdata->reset_gpio_port[0]))
-                        gpio_set_value(pdata->reset_gpio_port[0], 1);
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 1);
 
                 if (gpio_is_valid(pdata->reset_gpio_port[1]))
-                        gpio_set_value(pdata->reset_gpio_port[1], 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);
+                goto err_add_hcd;
+        }
+
+        /* root ports should always stay powered */
+        ehci_port_power(omap_ehci, 1);
+
         return 0;
 
 err_add_hcd:
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index fe8dc069164e..bc94d7bf072d 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -368,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 d238b4e24bb6..dfe881a34ae2 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 36ca5077cdf7..4378bf72bbac 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 f098e2a291a0..c474cec064e4 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 a60679cbbf85..33182c6d1ff9 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 000000000000..cc199e87a7a9
--- /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 9d9cf47d80da..ca819cdd0c5e 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 6e928559169c..37ba8c8d2fd0 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 87e271b9c157..4a44bf833611 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -147,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 */
@@ -174,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);
 
@@ -319,26 +308,23 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
         return retval;
 }
 
-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 temp_buffer,
-                            data);
+        temp = container_of(urb->transfer_buffer,
+                struct dma_aligned_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;
@@ -347,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 ||
@@ -358,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;
@@ -388,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;
 }
@@ -402,38 +384,39 @@ 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,
+        .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
-        .relinquish_port        = ehci_relinquish_port,
-        .port_handed_over       = ehci_port_handed_over,
 };
 
 static int setup_vbus_gpio(struct platform_device *pdev,
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 0ea577bfca2a..c5ed88199292 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 ab333ac6071d..22ff6b3a676f 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 fc72d44bf787..a35bbddf8968 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 4592dc17a9f9..fff114fd5461 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 13ebeca8e73e..a665b3eaa746 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -129,7 +129,7 @@ static int __devinit 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");
@@ -223,7 +223,7 @@ static void __devexit 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,
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 4ea63b2cac42..c611699b4aa6 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 5a00a1e1c6ca..2c9f233047be 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 843509778a33..269b1e0f7691 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 e4bcb62b930a..31b81f9eacdc 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 3d63574d2c7e..dbfbd1dfd2e2 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 37bb20ebb6fc..2909621ea196 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 235171f29460..e0adf5c0cf55 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 6618de1d881d..1e364ec962fb 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 71229cb97e3e..9ce35d0d9d5d 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -218,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 {
@@ -406,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 ec5c6791c8b4..670c7059c9ae 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 f13d08f94d6b..148d27d6a67c 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 d24cc89de16f..e27d5ae2b9eb 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 1514b7067470..185c39ed81b7 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 6fd4fa1f19bb..2ee1d8d713d2 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 c31b2815be1c..e1a3cc6d28dc 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 56dcf069246d..664c869eb096 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 e1004fb37bd9..b6cc92520924 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 84686d90805b..76a20c278362 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 95c16489e883..fc7305ee3c9c 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 5ba18595d6f7..000000000000
--- 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 120bfe6ede38..60c2b0722f2e 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 a2247867af86..41e378f17c66 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 3b38030b02a8..4f0f0339532f 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 32dada8c8b4f..df0828cb2aa3 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 2bf1320dc9c3..c868be65e763 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 000000000000..c2a29faba076
--- /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 673ad120c43e..2732ef660c5c 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 68eaa908ac8e..ec4338eec826 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 7a856a767e77..18b231b0c5d3 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 3d9422f16a20..23b4aefd1036 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 36641a7f2371..afdc73ee84a6 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 3d69c4b2b542..de3d6e3e57be 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,