Merge 3.4-rc4 into usb-next.

This resolves the conflict in:
	drivers/usb/host/ehci-fsl.c
And picks up loads of xhci bugfixes to make it easier for others to test
with.

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

24 files changed, 1127 insertions, 379 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f788eb86707..896fc91c54a 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -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
@@ -373,10 +374,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 +644,27 @@ config USB_OCTEON_OHCI
 config USB_OCTEON2_COMMON
         bool
         default y if USB_OCTEON_EHCI || USB_OCTEON_OHCI
+
+config USB_HCD_BCMA
+        tristate "BCMA usb host driver"
+        depends on BCMA && EXPERIMENTAL
+        select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
+        select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
+        help
+          Enbale support for the EHCI and OCHI host controller on an bcma bus.
+          It converts the bcma driver into two platform device drivers
+          for ehci and ohci.
+
+          If unsure, say N.
+
+config USB_HCD_SSB
+        tristate "SSB usb host driver"
+        depends on SSB && EXPERIMENTAL
+        select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
+        select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
+        help
+          Enbale support for the EHCI and OCHI host controller on an bcma bus.
+          It converts the bcma driver into two platform device drivers
+          for ehci and ohci.
+
+          If unsure, say N.
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 0982bcc140b..9e0a89ced15 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -41,3 +41,5 @@ obj-$(CONFIG_USB_IMX21_HCD)	+= imx21-hcd.o
 obj-$(CONFIG_USB_FSL_MPH_DR_OF) += fsl-mph-dr-of.o
 obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_MIPS_ALCHEMY)      += alchemy-common.o
+obj-$(CONFIG_USB_HCD_BCMA)      += bcma-hcd.o
+obj-$(CONFIG_USB_HCD_SSB)       += ssb-hcd.o
diff --git a/drivers/usb/host/bcma-hcd.c b/drivers/usb/host/bcma-hcd.c
new file mode 100644
index 00000000000..0b35d422fa4
--- /dev/null
+++ b/drivers/usb/host/bcma-hcd.c
@@ -0,0 +1,334 @@
+/*
+ * 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/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-fsl.c b/drivers/usb/host/ehci-fsl.c
index d0a84bd3f3e..34acfcee740 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
@@ -211,22 +211,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 +246,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 +294,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 +308,9 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
                         ehci->has_fsl_port_bug = 1;
 
                 if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
-                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
+                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0);
                 if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
-                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 1);
+                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 1);
         }
 
         if (pdata->have_sysif_regs) {
diff --git a/drivers/usb/host/ehci-fsl.h b/drivers/usb/host/ehci-fsl.h
index 863fb0c080d..88403684d10 100644
--- a/drivers/usb/host/ehci-fsl.h
+++ b/drivers/usb/host/ehci-fsl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2010 Freescale Semiconductor, Inc.
+/* Copyright (C) 2005-2010,2012 Freescale Semiconductor, Inc.
  * Copyright (c) 2005 MontaVista Software
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -50,4 +50,15 @@
 #define CTRL_UTMI_PHY_EN        (1<<9)
 #define CTRL_PHY_CLK_VALID      (1 << 17)
 #define SNOOP_SIZE_2GB          0x1e
+
+/* control Register Bit Masks */
+#define ULPI_INT_EN             (1<<0)
+#define WU_INT_EN               (1<<1)
+#define USB_CTRL_USB_EN         (1<<2)
+#define LINE_STATE_FILTER__EN   (1<<3)
+#define KEEP_OTG_ON             (1<<4)
+#define OTG_PORT                (1<<5)
+#define PLL_RESET               (1<<8)
+#define UTMI_PHY_EN             (1<<9)
+#define ULPI_PHY_CLK_SEL        (1<<10)
 #endif                          /* _EHCI_FSL_H */
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 4a3bc5b7a06..a87c0573c86 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -417,9 +417,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 +891,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);
@@ -1378,6 +1372,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
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 38fe0762315..402e766df2f 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -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-platform.c b/drivers/usb/host/ehci-platform.c
index d238b4e24bb..23c530ae5aa 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -94,12 +94,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-s5p.c b/drivers/usb/host/ehci-s5p.c
index f098e2a291a..c474cec064e 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -232,6 +232,8 @@ static int s5p_ehci_suspend(struct device *dev)
         if (pdata && pdata->phy_exit)
                 pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
 
+        clk_disable(s5p_ehci->clk);
+
         return rc;
 }
 
@@ -243,6 +245,8 @@ static int s5p_ehci_resume(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
 
+        clk_enable(s5p_ehci->clk);
+
         if (pdata && pdata->phy_init)
                 pdata->phy_init(pdev, S5P_USB_PHY_HOST);
 
diff --git a/drivers/usb/host/ehci-sead3.c b/drivers/usb/host/ehci-sead3.c
new file mode 100644
index 00000000000..4c164308ed2
--- /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;
+
+        ret = ehci_setup(hcd);
+        if (ret)
+                return ret;
+
+        ehci->need_io_watchdog = 0;
+
+#ifdef __BIG_ENDIAN
+        ehci->big_endian_mmio = 1;
+        ehci->big_endian_desc = 1;
+#endif
+
+        /* Set burst length to 16 words. */
+        ehci_writel(ehci, 0x1010, &ehci->regs->reserved[1]);
+
+        return ret;
+}
+
+const struct hc_driver ehci_sead3_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "SEAD-3 EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         *
+         */
+        .reset                  = ehci_sead3_setup,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_hcd_sead3_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
+                pr_debug("resource[1] is not IORESOURCE_IRQ");
+                return -ENOMEM;
+        }
+        hcd = usb_create_hcd(&ehci_sead3_hc_driver, &pdev->dev, "SEAD-3");
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_debug("request_mem_region failed");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        /* Root hub has integrated TT. */
+        hcd->has_tt = 1;
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ehci_hcd_sead3_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ehci_hcd_sead3_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        unsigned long flags;
+        int rc = 0;
+
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(20);
+
+        /* Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible.  The PM and USB cores make sure that
+         * the root hub is either suspended or stopped.
+         */
+        ehci_prepare_ports_for_controller_suspend(ehci, device_may_wakeup(dev));
+        spin_lock_irqsave(&ehci->lock, flags);
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        (void)ehci_readl(ehci, &ehci->regs->intr_enable);
+
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        /* could save FLADJ in case of Vaux power loss
+         * ... we'd only use it to handle clock skew
+         */
+
+        return rc;
+}
+
+static int ehci_hcd_sead3_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        /* maybe restore FLADJ. */
+
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(100);
+
+        /* Mark hardware accessible again as we are out of D3 state by now */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* If CF is still set, we maintained PCI Vaux power.
+         * Just undo the effect of ehci_pci_suspend().
+         */
+        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
+                int     mask = INTR_MASK;
+
+                ehci_prepare_ports_for_controller_resume(ehci);
+                if (!hcd->self.root_hub->do_remote_wakeup)
+                        mask &= ~STS_PCD;
+                ehci_writel(ehci, mask, &ehci->regs->intr_enable);
+                ehci_readl(ehci, &ehci->regs->intr_enable);
+                return 0;
+        }
+
+        ehci_dbg(ehci, "lost power, restarting\n");
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
+        /* Else reset, to cope with power loss or flush-to-storage
+         * style "resume" having let BIOS kick in during reboot.
+         */
+        (void) ehci_halt(ehci);
+        (void) ehci_reset(ehci);
+
+        /* emptying the schedule aborts any urbs */
+        spin_lock_irq(&ehci->lock);
+        if (ehci->reclaim)
+                end_unlink_async(ehci);
+        ehci_work(ehci);
+        spin_unlock_irq(&ehci->lock);
+
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+
+        /* here we "know" root ports should always stay powered */
+        ehci_port_power(ehci, 1);
+
+        ehci->rh_state = EHCI_RH_SUSPENDED;
+
+        return 0;
+}
+
+static const struct dev_pm_ops sead3_ehci_pmops = {
+        .suspend        = ehci_hcd_sead3_drv_suspend,
+        .resume         = ehci_hcd_sead3_drv_resume,
+};
+
+#define SEAD3_EHCI_PMOPS (&sead3_ehci_pmops)
+
+#else
+#define SEAD3_EHCI_PMOPS NULL
+#endif
+
+static struct platform_driver ehci_hcd_sead3_driver = {
+        .probe          = ehci_hcd_sead3_drv_probe,
+        .remove         = ehci_hcd_sead3_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = "sead3-ehci",
+                .owner  = THIS_MODULE,
+                .pm     = SEAD3_EHCI_PMOPS,
+        }
+};
+
+MODULE_ALIAS("platform:sead3-ehci");
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index 9d9cf47d80d..ca819cdd0c5 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -11,6 +11,7 @@
  */
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/platform_data/ehci-sh.h>
 
 struct ehci_sh_priv {
         struct clk *iclk, *fclk;
@@ -100,6 +101,7 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         const struct hc_driver *driver = &ehci_sh_hc_driver;
         struct resource *res;
         struct ehci_sh_priv *priv;
+        struct ehci_sh_platdata *pdata;
         struct usb_hcd *hcd;
         int irq, ret;
 
@@ -124,6 +126,9 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
                 goto fail_create_hcd;
         }
 
+        if (pdev->dev.platform_data != NULL)
+                pdata = pdev->dev.platform_data;
+
         /* initialize hcd */
         hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
                              dev_name(&pdev->dev));
@@ -168,6 +173,9 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         clk_enable(priv->fclk);
         clk_enable(priv->iclk);
 
+        if (pdata && pdata->phy_init)
+                pdata->phy_init();
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to add hcd");
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 6e928559169..37ba8c8d2fd 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -13,6 +13,7 @@
 
 #include <linux/clk.h>
 #include <linux/jiffies.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 
@@ -25,12 +26,12 @@ struct spear_ehci {
 
 static void spear_start_ehci(struct spear_ehci *ehci)
 {
-        clk_enable(ehci->clk);
+        clk_prepare_enable(ehci->clk);
 }
 
 static void spear_stop_ehci(struct spear_ehci *ehci)
 {
-        clk_disable(ehci->clk);
+        clk_disable_unprepare(ehci->clk);
 }
 
 static int ehci_spear_setup(struct usb_hcd *hcd)
@@ -168,6 +169,8 @@ static int ehci_spear_drv_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(ehci_spear_pm_ops, ehci_spear_drv_suspend,
                 ehci_spear_drv_resume);
 
+static u64 spear_ehci_dma_mask = DMA_BIT_MASK(32);
+
 static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd ;
@@ -175,12 +178,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
         struct resource *res;
         struct clk *usbh_clk;
         const struct hc_driver *driver = &ehci_spear_hc_driver;
-        int *pdata = pdev->dev.platform_data;
         int irq, retval;
         char clk_name[20] = "usbh_clk";
-
-        if (pdata == NULL)
-                return -EFAULT;
+        static int instance = -1;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -191,8 +191,22 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
                 goto fail_irq_get;
         }
 
-        if (*pdata >= 0)
-                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+        /*
+         * Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &spear_ehci_dma_mask;
+
+        /*
+         * Increment the device instance, when probing via device-tree
+         */
+        if (pdev->id < 0)
+                instance++;
+        else
+                instance = pdev->id;
+        sprintf(clk_name, "usbh.%01d_clk", instance);
 
         usbh_clk = clk_get(NULL, clk_name);
         if (IS_ERR(usbh_clk)) {
@@ -277,6 +291,11 @@ static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)
         return 0;
 }
 
+static struct of_device_id spear_ehci_id_table[] __devinitdata = {
+        { .compatible = "st,spear600-ehci", },
+        { },
+};
+
 static struct platform_driver spear_ehci_hcd_driver = {
         .probe          = spear_ehci_hcd_drv_probe,
         .remove         = spear_ehci_hcd_drv_remove,
@@ -285,6 +304,7 @@ static struct platform_driver spear_ehci_hcd_driver = {
                 .name = "spear-ehci",
                 .bus = &platform_bus_type,
                 .pm = &ehci_spear_pm_ops,
+                .of_match_table = of_match_ptr(spear_ehci_id_table),
         }
 };
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 86183366647..43bb0a9f1f7 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -148,18 +148,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 */
@@ -464,26 +453,23 @@ static int tegra_ehci_bus_resume(struct usb_hcd *hcd)
 }
 #endif
 
-struct temp_buffer {
+struct dma_aligned_buffer {
         void *kmalloc_ptr;
         void *old_xfer_buffer;
         u8 data[0];
 };
 
-static void free_temp_buffer(struct urb *urb)
+static void free_dma_aligned_buffer(struct urb *urb)
 {
-        enum dma_data_direction dir;
-        struct temp_buffer *temp;
+        struct dma_aligned_buffer *temp;
 
         if (!(urb->transfer_flags & URB_ALIGNED_TEMP_BUFFER))
                 return;
 
-        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
-        temp = container_of(urb->transfer_buffer, struct 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;
@@ -492,10 +478,9 @@ static void free_temp_buffer(struct urb *urb)
         urb->transfer_flags &= ~URB_ALIGNED_TEMP_BUFFER;
 }
 
-static int alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
+static int alloc_dma_aligned_buffer(struct urb *urb, gfp_t mem_flags)
 {
-        enum dma_data_direction dir;
-        struct temp_buffer *temp, *kmalloc_ptr;
+        struct dma_aligned_buffer *temp, *kmalloc_ptr;
         size_t kmalloc_size;
 
         if (urb->num_sgs || urb->sg ||
@@ -503,22 +488,19 @@ static int alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
             !((uintptr_t)urb->transfer_buffer & (TEGRA_USB_DMA_ALIGN - 1)))
                 return 0;
 
-        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
         /* Allocate a buffer with enough padding for alignment */
         kmalloc_size = urb->transfer_buffer_length +
-                sizeof(struct temp_buffer) + TEGRA_USB_DMA_ALIGN - 1;
+                sizeof(struct dma_aligned_buffer) + TEGRA_USB_DMA_ALIGN - 1;
 
         kmalloc_ptr = kmalloc(kmalloc_size, mem_flags);
         if (!kmalloc_ptr)
                 return -ENOMEM;
 
-        /* Position our struct temp_buffer such that data is aligned */
+        /* Position our struct dma_aligned_buffer such that data is aligned */
         temp = PTR_ALIGN(kmalloc_ptr + 1, TEGRA_USB_DMA_ALIGN) - 1;
-
         temp->kmalloc_ptr = kmalloc_ptr;
         temp->old_xfer_buffer = urb->transfer_buffer;
-        if (dir == DMA_TO_DEVICE)
+        if (usb_urb_dir_out(urb))
                 memcpy(temp->data, urb->transfer_buffer,
                        urb->transfer_buffer_length);
         urb->transfer_buffer = temp->data;
@@ -533,13 +515,13 @@ static int tegra_ehci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
 {
         int ret;
 
-        ret = alloc_temp_buffer(urb, mem_flags);
+        ret = alloc_dma_aligned_buffer(urb, mem_flags);
         if (ret)
                 return ret;
 
         ret = usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
         if (ret)
-                free_temp_buffer(urb);
+                free_dma_aligned_buffer(urb);
 
         return ret;
 }
@@ -547,38 +529,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            = tegra_ehci_bus_suspend,
         .bus_resume             = tegra_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 0ea577bfca2..c5ed8819929 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -155,7 +155,7 @@ u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
         struct endpoint *ep;
         struct usb_td __iomem *td;
         unsigned long ep_offset;
-        char *err_for = "enpoint PRAM";
+        char *err_for = "endpoint PRAM";
         int ep_mem_size;
         u32 i;
 
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index ab333ac6071..22ff6b3a676 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -119,6 +119,39 @@ error:
 
 static const struct of_device_id fsl_usb2_mph_dr_of_match[];
 
+static int usb_get_ver_info(struct device_node *np)
+{
+        int ver = -1;
+
+        /*
+         * returns 1 for usb controller version 1.6
+         * returns 2 for usb controller version 2.2
+         * returns 0 otherwise
+         */
+        if (of_device_is_compatible(np, "fsl-usb2-dr")) {
+                if (of_device_is_compatible(np, "fsl-usb2-dr-v1.6"))
+                        ver = FSL_USB_VER_1_6;
+                else if (of_device_is_compatible(np, "fsl-usb2-dr-v2.2"))
+                        ver = FSL_USB_VER_2_2;
+                else /* for previous controller versions */
+                        ver = FSL_USB_VER_OLD;
+
+                if (ver > -1)
+                        return ver;
+        }
+
+        if (of_device_is_compatible(np, "fsl-usb2-mph")) {
+                if (of_device_is_compatible(np, "fsl-usb2-mph-v1.6"))
+                        ver = FSL_USB_VER_1_6;
+                else if (of_device_is_compatible(np, "fsl-usb2-mph-v2.2"))
+                        ver = FSL_USB_VER_2_2;
+                else /* for previous controller versions */
+                        ver = FSL_USB_VER_OLD;
+        }
+
+        return ver;
+}
+
 static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -166,6 +199,14 @@ static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
 
         prop = of_get_property(np, "phy_type", NULL);
         pdata->phy_mode = determine_usb_phy(prop);
+        pdata->controller_ver = usb_get_ver_info(np);
+
+        if (pdata->have_sysif_regs) {
+                if (pdata->controller_ver < 0) {
+                        dev_warn(&ofdev->dev, "Could not get controller version\n");
+                        return -ENODEV;
+                }
+        }
 
         for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
                 if (!dev_data->drivers[i])
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index fc72d44bf78..a35bbddf896 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1562,11 +1562,14 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
 
         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
                 retval = -ESHUTDOWN;
+                qtd_list_free(&new_qtds);
                 goto out;
         }
         retval = usb_hcd_link_urb_to_ep(hcd, urb);
-        if (retval)
+        if (retval) {
+                qtd_list_free(&new_qtds);
                 goto out;
+        }
 
         qh = urb->ep->hcpriv;
         if (qh) {
@@ -1584,6 +1587,7 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 if (!qh) {
                         retval = -ENOMEM;
                         usb_hcd_unlink_urb_from_ep(hcd, urb);
+                        qtd_list_free(&new_qtds);
                         goto out;
                 }
                 list_add_tail(&qh->qh_list, ep_queue);
@@ -1683,6 +1687,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
         list_for_each_entry(qtd, &qh->qtd_list, qtd_list)
                 if (qtd->urb == urb) {
                         dequeue_urb_from_qtd(hcd, qh, qtd);
+                        list_move(&qtd->qtd_list, &qh->qtd_list);
                         break;
                 }
 
@@ -2176,7 +2181,7 @@ static const struct hc_driver isp1760_hc_driver = {
 
 int __init init_kmem_once(void)
 {
-        urb_listitem_cachep = kmem_cache_create("isp1760 urb_listitem",
+        urb_listitem_cachep = kmem_cache_create("isp1760_urb_listitem",
                         sizeof(struct urb_listitem), 0, SLAB_TEMPORARY |
                         SLAB_MEM_SPREAD, NULL);
 
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 4592dc17a9f..fff114fd546 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -398,6 +398,9 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
                                irqflags, -ENOENT,
                                &pdev->dev, dev_name(&pdev->dev), devflags);
+
+        dev_set_drvdata(&pdev->dev, hcd);
+
         if (IS_ERR(hcd)) {
                 pr_warning("isp1760: Failed to register the HCD device\n");
                 ret = -ENODEV;
@@ -417,11 +420,16 @@ static int __devexit isp1760_plat_remove(struct platform_device *pdev)
 {
         struct resource *mem_res;
         resource_size_t mem_size;
+        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
+
+        usb_remove_hcd(hcd);
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         mem_size = resource_size(mem_res);
         release_mem_region(mem_res->start, mem_size);
 
+        usb_put_hcd(hcd);
+
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 235171f2946..e0adf5c0cf5 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1080,11 +1080,6 @@ MODULE_LICENSE ("GPL");
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
 #endif
 
-#ifdef CONFIG_USB_OHCI_HCD_SSB
-#include "ohci-ssb.c"
-#define SSB_OHCI_DRIVER         ssb_ohci_driver
-#endif
-
 #ifdef CONFIG_MFD_SM501
 #include "ohci-sm501.c"
 #define SM501_OHCI_DRIVER       ohci_hcd_sm501_driver
@@ -1128,8 +1123,7 @@ MODULE_LICENSE ("GPL");
         !defined(SA1111_DRIVER) &&      \
         !defined(PS3_SYSTEM_BUS_DRIVER) && \
         !defined(SM501_OHCI_DRIVER) && \
-        !defined(TMIO_OHCI_DRIVER) && \
-        !defined(SSB_OHCI_DRIVER)
+        !defined(TMIO_OHCI_DRIVER)
 #error "missing bus glue for ohci-hcd"
 #endif
 
@@ -1195,12 +1189,6 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_pci;
 #endif
 
-#ifdef SSB_OHCI_DRIVER
-        retval = ssb_driver_register(&SSB_OHCI_DRIVER);
-        if (retval)
-                goto error_ssb;
-#endif
-
 #ifdef SM501_OHCI_DRIVER
         retval = platform_driver_register(&SM501_OHCI_DRIVER);
         if (retval < 0)
@@ -1224,10 +1212,6 @@ static int __init ohci_hcd_mod_init(void)
         platform_driver_unregister(&SM501_OHCI_DRIVER);
  error_sm501:
 #endif
-#ifdef SSB_OHCI_DRIVER
-        ssb_driver_unregister(&SSB_OHCI_DRIVER);
- error_ssb:
-#endif
 #ifdef PCI_DRIVER
         pci_unregister_driver(&PCI_DRIVER);
  error_pci:
@@ -1275,9 +1259,6 @@ static void __exit ohci_hcd_mod_exit(void)
 #ifdef SM501_OHCI_DRIVER
         platform_driver_unregister(&SM501_OHCI_DRIVER);
 #endif
-#ifdef SSB_OHCI_DRIVER
-        ssb_driver_unregister(&SSB_OHCI_DRIVER);
-#endif
 #ifdef PCI_DRIVER
         pci_unregister_driver(&PCI_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index ec5c6791c8b..670c7059c9a 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -93,13 +93,13 @@ static int __devinit ohci_platform_probe(struct platform_device *dev)
 
         irq = platform_get_irq(dev, 0);
         if (irq < 0) {
-                pr_err("no irq provieded");
+                pr_err("no irq provided");
                 return irq;
         }
 
         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!res_mem) {
-                pr_err("no memory recourse provieded");
+                pr_err("no memory recourse provided");
                 return -ENXIO;
         }
 
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index d24cc89de16..b2b5767cb37 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -236,7 +236,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-spear.c b/drivers/usb/host/ohci-spear.c
index 95c16489e88..fc7305ee3c9 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -14,6 +14,7 @@
 #include <linux/signal.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/of.h>
 
 struct spear_ohci {
         struct ohci_hcd ohci;
@@ -24,12 +25,12 @@ struct spear_ohci {
 
 static void spear_start_ohci(struct spear_ohci *ohci)
 {
-        clk_enable(ohci->clk);
+        clk_prepare_enable(ohci->clk);
 }
 
 static void spear_stop_ohci(struct spear_ohci *ohci)
 {
-        clk_disable(ohci->clk);
+        clk_disable_unprepare(ohci->clk);
 }
 
 static int __devinit ohci_spear_start(struct usb_hcd *hcd)
@@ -90,6 +91,8 @@ static const struct hc_driver ohci_spear_hc_driver = {
         .start_port_reset       = ohci_start_port_reset,
 };
 
+static u64 spear_ohci_dma_mask = DMA_BIT_MASK(32);
+
 static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
 {
         const struct hc_driver *driver = &ohci_spear_hc_driver;
@@ -98,11 +101,8 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
         struct spear_ohci *ohci_p;
         struct resource *res;
         int retval, irq;
-        int *pdata = pdev->dev.platform_data;
         char clk_name[20] = "usbh_clk";
-
-        if (pdata == NULL)
-                return -EFAULT;
+        static int instance = -1;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -110,8 +110,22 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
                 goto fail_irq_get;
         }
 
-        if (*pdata >= 0)
-                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+        /*
+         * Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &spear_ohci_dma_mask;
+
+        /*
+         * Increment the device instance, when probing via device-tree
+         */
+        if (pdev->id < 0)
+                instance++;
+        else
+                instance = pdev->id;
+        sprintf(clk_name, "usbh.%01d_clk", instance);
 
         usbh_clk = clk_get(NULL, clk_name);
         if (IS_ERR(usbh_clk)) {
@@ -222,6 +236,11 @@ static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
 }
 #endif
 
+static struct of_device_id spear_ohci_id_table[] __devinitdata = {
+        { .compatible = "st,spear600-ohci", },
+        { },
+};
+
 /* Driver definition to register with the platform bus */
 static struct platform_driver spear_ohci_hcd_driver = {
         .probe =        spear_ohci_hcd_drv_probe,
@@ -233,6 +252,7 @@ static struct platform_driver spear_ohci_hcd_driver = {
         .driver = {
                 .owner = THIS_MODULE,
                 .name = "spear-ohci",
+                .of_match_table = of_match_ptr(spear_ohci_id_table),
         },
 };
 
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
deleted file mode 100644
index 5ba18595d6f..00000000000
--- a/drivers/usb/host/ohci-ssb.c
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom USB-core OHCI driver
- *
- * Copyright 2007 Michael Buesch <m@bues.ch>
- *
- * Derived from the OHCI-PCI driver
- * Copyright 1999 Roman Weissgaerber
- * Copyright 2000-2002 David Brownell
- * Copyright 1999 Linus Torvalds
- * Copyright 1999 Gregory P. Smith
- *
- * Derived from the USBcore related parts of Broadcom-SB
- * Copyright 2005 Broadcom Corporation
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-#include <linux/ssb/ssb.h>
-
-
-#define SSB_OHCI_TMSLOW_HOSTMODE        (1 << 29)
-
-struct ssb_ohci_device {
-        struct ohci_hcd ohci; /* _must_ be at the beginning. */
-
-        u32 enable_flags;
-};
-
-static inline
-struct ssb_ohci_device *hcd_to_ssb_ohci(struct usb_hcd *hcd)
-{
-        return (struct ssb_ohci_device *)(hcd->hcd_priv);
-}
-
-
-static int ssb_ohci_reset(struct usb_hcd *hcd)
-{
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-        struct ohci_hcd *ohci = &ohcidev->ohci;
-        int err;
-
-        ohci_hcd_init(ohci);
-        err = ohci_init(ohci);
-
-        return err;
-}
-
-static int ssb_ohci_start(struct usb_hcd *hcd)
-{
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-        struct ohci_hcd *ohci = &ohcidev->ohci;
-        int err;
-
-        err = ohci_run(ohci);
-        if (err < 0) {
-                ohci_err(ohci, "can't start\n");
-                ohci_stop(hcd);
-        }
-
-        return err;
-}
-
-static const struct hc_driver ssb_ohci_hc_driver = {
-        .description            = "ssb-usb-ohci",
-        .product_desc           = "SSB OHCI Controller",
-        .hcd_priv_size          = sizeof(struct ssb_ohci_device),
-
-        .irq                    = ohci_irq,
-        .flags                  = HCD_MEMORY | HCD_USB11,
-
-        .reset                  = ssb_ohci_reset,
-        .start                  = ssb_ohci_start,
-        .stop                   = ohci_stop,
-        .shutdown               = ohci_shutdown,
-
-        .urb_enqueue            = ohci_urb_enqueue,
-        .urb_dequeue            = ohci_urb_dequeue,
-        .endpoint_disable       = ohci_endpoint_disable,
-
-        .get_frame_number       = ohci_get_frame,
-
-        .hub_status_data        = ohci_hub_status_data,
-        .hub_control            = ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend            = ohci_bus_suspend,
-        .bus_resume             = ohci_bus_resume,
-#endif
-
-        .start_port_reset       = ohci_start_port_reset,
-};
-
-static void ssb_ohci_detach(struct ssb_device *dev)
-{
-        struct usb_hcd *hcd = ssb_get_drvdata(dev);
-
-        if (hcd->driver->shutdown)
-                hcd->driver->shutdown(hcd);
-        usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
-        ssb_device_disable(dev, 0);
-}
-
-static int ssb_ohci_attach(struct ssb_device *dev)
-{
-        struct ssb_ohci_device *ohcidev;
-        struct usb_hcd *hcd;
-        int err = -ENOMEM;
-        u32 tmp, flags = 0;
-
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
-                return -EOPNOTSUPP;
-
-        if (dev->id.coreid == SSB_DEV_USB11_HOSTDEV) {
-                /* Put the device into host-mode. */
-                flags |= SSB_OHCI_TMSLOW_HOSTMODE;
-                ssb_device_enable(dev, flags);
-        } else if (dev->id.coreid == SSB_DEV_USB20_HOST) {
-                /*
-                 * USB 2.0 special considerations:
-                 *
-                 * In addition to the standard SSB reset sequence, the Host
-                 * Control Register must be programmed to bring the USB core
-                 * and various phy components out of reset.
-                 */
-                ssb_device_enable(dev, 0);
-                ssb_write32(dev, 0x200, 0x7ff);
-
-                /* Change Flush control reg */
-                tmp = ssb_read32(dev, 0x400);
-                tmp &= ~8;
-                ssb_write32(dev, 0x400, tmp);
-                tmp = ssb_read32(dev, 0x400);
-
-                /* Change Shim control reg */
-                tmp = ssb_read32(dev, 0x304);
-                tmp &= ~0x100;
-                ssb_write32(dev, 0x304, tmp);
-                tmp = ssb_read32(dev, 0x304);
-
-                udelay(1);
-
-                /* Work around for 5354 failures */
-                if (dev->id.revision == 2 && dev->bus->chip_id == 0x5354) {
-                        /* Change syn01 reg */
-                        tmp = 0x00fe00fe;
-                        ssb_write32(dev, 0x894, tmp);
-
-                        /* Change syn03 reg */
-                        tmp = ssb_read32(dev, 0x89c);
-                        tmp |= 0x1;
-                        ssb_write32(dev, 0x89c, tmp);
-                }
-        } else
-                ssb_device_enable(dev, 0);
-
-        hcd = usb_create_hcd(&ssb_ohci_hc_driver, dev->dev,
-                        dev_name(dev->dev));
-        if (!hcd)
-                goto err_dev_disable;
-        ohcidev = hcd_to_ssb_ohci(hcd);
-        ohcidev->enable_flags = flags;
-
-        tmp = ssb_read32(dev, SSB_ADMATCH0);
-        hcd->rsrc_start = ssb_admatch_base(tmp);
-        hcd->rsrc_len = ssb_admatch_size(tmp);
-        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs)
-                goto err_put_hcd;
-        err = usb_add_hcd(hcd, dev->irq, IRQF_SHARED);
-        if (err)
-                goto err_iounmap;
-
-        ssb_set_drvdata(dev, hcd);
-
-        return err;
-
-err_iounmap:
-        iounmap(hcd->regs);
-err_put_hcd:
-        usb_put_hcd(hcd);
-err_dev_disable:
-        ssb_device_disable(dev, flags);
-        return err;
-}
-
-static int ssb_ohci_probe(struct ssb_device *dev,
-                const struct ssb_device_id *id)
-{
-        int err;
-        u16 chipid_top;
-
-        /* USBcores are only connected on embedded devices. */
-        chipid_top = (dev->bus->chip_id & 0xFF00);
-        if (chipid_top != 0x4700 && chipid_top != 0x5300)
-                return -ENODEV;
-
-        /* TODO: Probably need checks here; is the core connected? */
-
-        if (usb_disabled())
-                return -ENODEV;
-
-        /* We currently always attach SSB_DEV_USB11_HOSTDEV
-         * as HOST OHCI. If we want to attach it as Client device,
-         * we must branch here and call into the (yet to
-         * be written) Client mode driver. Same for remove(). */
-
-        err = ssb_ohci_attach(dev);
-
-        return err;
-}
-
-static void ssb_ohci_remove(struct ssb_device *dev)
-{
-        ssb_ohci_detach(dev);
-}
-
-#ifdef CONFIG_PM
-
-static int ssb_ohci_suspend(struct ssb_device *dev, pm_message_t state)
-{
-        ssb_device_disable(dev, 0);
-
-        return 0;
-}
-
-static int ssb_ohci_resume(struct ssb_device *dev)
-{
-        struct usb_hcd *hcd = ssb_get_drvdata(dev);
-        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
-
-        ssb_device_enable(dev, ohcidev->enable_flags);
-
-        ohci_finish_controller_resume(hcd);
-        return 0;
-}
-
-#else /* !CONFIG_PM */
-#define ssb_ohci_suspend        NULL
-#define ssb_ohci_resume NULL
-#endif /* CONFIG_PM */
-
-static const struct ssb_device_id ssb_ohci_table[] = {
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOSTDEV, SSB_ANY_REV),
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOST, SSB_ANY_REV),
-        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB20_HOST, SSB_ANY_REV),
-        SSB_DEVTABLE_END
-};
-MODULE_DEVICE_TABLE(ssb, ssb_ohci_table);
-
-static struct ssb_driver ssb_ohci_driver = {
-        .name           = KBUILD_MODNAME,
-        .id_table       = ssb_ohci_table,
-        .probe          = ssb_ohci_probe,
-        .remove         = ssb_ohci_remove,
-        .suspend        = ssb_ohci_suspend,
-        .resume         = ssb_ohci_resume,
-};
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 3b38030b02a..77a52256eb3 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -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/ssb-hcd.c b/drivers/usb/host/ssb-hcd.c
new file mode 100644
index 00000000000..c2e73433b30
--- /dev/null
+++ b/drivers/usb/host/ssb-hcd.c
@@ -0,0 +1,279 @@
+/*
+ * 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/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);