43 files changed, 721 insertions, 296 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 060e0e2b1ae6..a52769b5c904 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -194,6 +194,15 @@ config USB_EHCI_S5P
        help
          Enable support for the S5P SOC's on-chip EHCI controller.
 
+config USB_EHCI_MV
+        bool "EHCI support for Marvell on-chip controller"
+        depends on USB_EHCI_HCD
+        select USB_EHCI_ROOT_HUB_TT
+        ---help---
+          Enables support for Marvell (including PXA and MMP series) on-chip
+          USB SPH and OTG controller. SPH is a single port host, and it can
+          only be EHCI host. OTG is controller that can switch to host mode.
+
 config USB_W90X900_EHCI
         bool "W90X900(W90P910) EHCI support"
         depends on USB_EHCI_HCD && ARCH_W90X900
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 18bafa99fe57..bf7441afed16 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -23,6 +23,7 @@ static int au1xxx_ehci_setup(struct usb_hcd *hcd)
         int ret = ehci_init(hcd);
 
         ehci->need_io_watchdog = 0;
+        ehci_reset(ehci);
         return ret;
 }
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 3ff9f82f7263..e311a511529b 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -48,6 +48,10 @@
 #include <asm/system.h>
 #include <asm/unaligned.h>
 
+#if defined(CONFIG_PPC_PS3)
+#include <asm/firmware.h>
+#endif
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -230,12 +234,58 @@ static int ehci_halt (struct ehci_hcd *ehci)
                           STS_HALT, STS_HALT, 16 * 125);
 }
 
+#if defined(CONFIG_USB_SUSPEND) && defined(CONFIG_PPC_PS3)
+
+/*
+ * The EHCI controller of the Cell Super Companion Chip used in the
+ * PS3 will stop the root hub after all root hub ports are suspended.
+ * When in this condition handshake will return -ETIMEDOUT.  The
+ * STS_HLT bit will not be set, so inspection of the frame index is
+ * used here to test for the condition.  If the condition is found
+ * return success to allow the USB suspend to complete.
+ */
+
+static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
+                                         void __iomem *ptr, u32 mask, u32 done,
+                                         int usec)
+{
+        unsigned int old_index;
+        int error;
+
+        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
+                return -ETIMEDOUT;
+
+        old_index = ehci_read_frame_index(ehci);
+
+        error = handshake(ehci, ptr, mask, done, usec);
+
+        if (error == -ETIMEDOUT && ehci_read_frame_index(ehci) == old_index)
+                return 0;
+
+        return error;
+}
+
+#else
+
+static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
+                                         void __iomem *ptr, u32 mask, u32 done,
+                                         int usec)
+{
+        return -ETIMEDOUT;
+}
+
+#endif
+
 static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
                                        u32 mask, u32 done, int usec)
 {
         int error;
 
         error = handshake(ehci, ptr, mask, done, usec);
+        if (error == -ETIMEDOUT)
+                error = handshake_for_broken_root_hub(ehci, ptr, mask, done,
+                                                      usec);
+
         if (error) {
                 ehci_halt(ehci);
                 ehci->rh_state = EHCI_RH_HALTED;
@@ -620,6 +670,7 @@ static int ehci_init(struct usb_hcd *hcd)
         hw = ehci->async->hw;
         hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
         hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
+        hw->hw_info1 |= cpu_to_hc32(ehci, (1 << 7));    /* I = 1 */
         hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
         hw->hw_qtd_next = EHCI_LIST_END(ehci);
         ehci->async->qh_state = QH_STATE_LINKED;
@@ -677,22 +728,13 @@ static int ehci_init(struct usb_hcd *hcd)
 static int ehci_run (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        int                     retval;
         u32                     temp;
         u32                     hcc_params;
 
         hcd->uses_new_polling = 1;
 
         /* EHCI spec section 4.1 */
-        /*
-         * TDI driver does the ehci_reset in their reset callback.
-         * Don't reset here, because configuration settings will
-         * vanish.
-         */
-        if (!ehci_is_TDI(ehci) && (retval = ehci_reset(ehci)) != 0) {
-                ehci_mem_cleanup(ehci);
-                return retval;
-        }
+
         ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
         ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
 
@@ -1324,11 +1366,16 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_pxa168_driver
 #endif
 
-#ifdef CONFIG_NLM_XLR
+#ifdef CONFIG_CPU_XLR
 #include "ehci-xls.c"
 #define PLATFORM_DRIVER         ehci_xls_driver
 #endif
 
+#ifdef CONFIG_USB_EHCI_MV
+#include "ehci-mv.c"
+#define        PLATFORM_DRIVER         ehci_mv_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
new file mode 100644
index 000000000000..52a604fb9321
--- /dev/null
+++ b/drivers/usb/host/ehci-mv.c
@@ -0,0 +1,391 @@
+/*
+ * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
+ * Author: Chao Xie <chao.xie@marvell.com>
+ *        Neil Zhang <zhangwm@marvell.com>
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/usb/otg.h>
+#include <linux/platform_data/mv_usb.h>
+
+#define CAPLENGTH_MASK         (0xff)
+
+struct ehci_hcd_mv {
+        struct usb_hcd *hcd;
+
+        /* Which mode does this ehci running OTG/Host ? */
+        int mode;
+
+        void __iomem *phy_regs;
+        void __iomem *cap_regs;
+        void __iomem *op_regs;
+
+        struct otg_transceiver *otg;
+
+        struct mv_usb_platform_data *pdata;
+
+        /* clock source and total clock number */
+        unsigned int clknum;
+        struct clk *clk[0];
+};
+
+static void ehci_clock_enable(struct ehci_hcd_mv *ehci_mv)
+{
+        unsigned int i;
+
+        for (i = 0; i < ehci_mv->clknum; i++)
+                clk_enable(ehci_mv->clk[i]);
+}
+
+static void ehci_clock_disable(struct ehci_hcd_mv *ehci_mv)
+{
+        unsigned int i;
+
+        for (i = 0; i < ehci_mv->clknum; i++)
+                clk_disable(ehci_mv->clk[i]);
+}
+
+static int mv_ehci_enable(struct ehci_hcd_mv *ehci_mv)
+{
+        int retval;
+
+        ehci_clock_enable(ehci_mv);
+        if (ehci_mv->pdata->phy_init) {
+                retval = ehci_mv->pdata->phy_init(ehci_mv->phy_regs);
+                if (retval)
+                        return retval;
+        }
+
+        return 0;
+}
+
+static void mv_ehci_disable(struct ehci_hcd_mv *ehci_mv)
+{
+        if (ehci_mv->pdata->phy_deinit)
+                ehci_mv->pdata->phy_deinit(ehci_mv->phy_regs);
+        ehci_clock_disable(ehci_mv);
+}
+
+static int mv_ehci_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct device *dev = hcd->self.controller;
+        struct ehci_hcd_mv *ehci_mv = dev_get_drvdata(dev);
+        int retval;
+
+        if (ehci_mv == NULL) {
+                dev_err(dev, "Can not find private ehci data\n");
+                return -ENODEV;
+        }
+
+        /*
+         * data structure init
+         */
+        retval = ehci_init(hcd);
+        if (retval) {
+                dev_err(dev, "ehci_init failed %d\n", retval);
+                return retval;
+        }
+
+        hcd->has_tt = 1;
+        ehci->sbrn = 0x20;
+
+        retval = ehci_reset(ehci);
+        if (retval) {
+                dev_err(dev, "ehci_reset failed %d\n", retval);
+                return retval;
+        }
+
+        return 0;
+}
+
+static const struct hc_driver mv_ehci_hc_driver = {
+        .description = hcd_name,
+        .product_desc = "Marvell EHCI",
+        .hcd_priv_size = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq = ehci_irq,
+        .flags = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset = mv_ehci_reset,
+        .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,
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+
+        /*
+         * 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,
+};
+
+static int mv_ehci_probe(struct platform_device *pdev)
+{
+        struct mv_usb_platform_data *pdata = pdev->dev.platform_data;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct ehci_hcd_mv *ehci_mv;
+        struct resource *r;
+        int clk_i, retval = -ENODEV;
+        u32 offset;
+        size_t size;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "missing platform_data\n");
+                return -ENODEV;
+        }
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        hcd = usb_create_hcd(&mv_ehci_hc_driver, &pdev->dev, "mv ehci");
+        if (!hcd)
+                return -ENOMEM;
+
+        size = sizeof(*ehci_mv) + sizeof(struct clk *) * pdata->clknum;
+        ehci_mv = kzalloc(size, GFP_KERNEL);
+        if (ehci_mv == NULL) {
+                dev_err(&pdev->dev, "cannot allocate ehci_hcd_mv\n");
+                retval = -ENOMEM;
+                goto err_put_hcd;
+        }
+
+        platform_set_drvdata(pdev, ehci_mv);
+        ehci_mv->pdata = pdata;
+        ehci_mv->hcd = hcd;
+
+        ehci_mv->clknum = pdata->clknum;
+        for (clk_i = 0; clk_i < ehci_mv->clknum; clk_i++) {
+                ehci_mv->clk[clk_i] =
+                    clk_get(&pdev->dev, pdata->clkname[clk_i]);
+                if (IS_ERR(ehci_mv->clk[clk_i])) {
+                        dev_err(&pdev->dev, "error get clck \"%s\"\n",
+                                pdata->clkname[clk_i]);
+                        retval = PTR_ERR(ehci_mv->clk[clk_i]);
+                        goto err_put_clk;
+                }
+        }
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phyregs");
+        if (r == NULL) {
+                dev_err(&pdev->dev, "no phy I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto err_put_clk;
+        }
+
+        ehci_mv->phy_regs = ioremap(r->start, resource_size(r));
+        if (ehci_mv->phy_regs == 0) {
+                dev_err(&pdev->dev, "failed to map phy I/O memory\n");
+                retval = -EFAULT;
+                goto err_put_clk;
+        }
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "capregs");
+        if (!r) {
+                dev_err(&pdev->dev, "no I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto err_iounmap_phyreg;
+        }
+
+        ehci_mv->cap_regs = ioremap(r->start, resource_size(r));
+        if (ehci_mv->cap_regs == NULL) {
+                dev_err(&pdev->dev, "failed to map I/O memory\n");
+                retval = -EFAULT;
+                goto err_iounmap_phyreg;
+        }
+
+        retval = mv_ehci_enable(ehci_mv);
+        if (retval) {
+                dev_err(&pdev->dev, "init phy error %d\n", retval);
+                goto err_iounmap_capreg;
+        }
+
+        offset = readl(ehci_mv->cap_regs) & CAPLENGTH_MASK;
+        ehci_mv->op_regs =
+                (void __iomem *) ((unsigned long) ehci_mv->cap_regs + offset);
+
+        hcd->rsrc_start = r->start;
+        hcd->rsrc_len = r->end - r->start + 1;
+        hcd->regs = ehci_mv->op_regs;
+
+        hcd->irq = platform_get_irq(pdev, 0);
+        if (!hcd->irq) {
+                dev_err(&pdev->dev, "Cannot get irq.");
+                retval = -ENODEV;
+                goto err_disable_clk;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = (struct ehci_caps *) ehci_mv->cap_regs;
+        ehci->regs = (struct ehci_regs *) ehci_mv->op_regs;
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        ehci_mv->mode = pdata->mode;
+        if (ehci_mv->mode == MV_USB_MODE_OTG) {
+#ifdef CONFIG_USB_OTG_UTILS
+                ehci_mv->otg = otg_get_transceiver();
+                if (!ehci_mv->otg) {
+                        dev_err(&pdev->dev,
+                                "unable to find transceiver\n");
+                        retval = -ENODEV;
+                        goto err_disable_clk;
+                }
+
+                retval = otg_set_host(ehci_mv->otg, &hcd->self);
+                if (retval < 0) {
+                        dev_err(&pdev->dev,
+                                "unable to register with transceiver\n");
+                        retval = -ENODEV;
+                        goto err_put_transceiver;
+                }
+                /* otg will enable clock before use as host */
+                mv_ehci_disable(ehci_mv);
+#else
+                dev_info(&pdev->dev, "MV_USB_MODE_OTG "
+                         "must have CONFIG_USB_OTG_UTILS enabled\n");
+                goto err_disable_clk;
+#endif
+        } else {
+                if (pdata->set_vbus)
+                        pdata->set_vbus(1);
+
+                retval = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
+                if (retval) {
+                        dev_err(&pdev->dev,
+                                "failed to add hcd with err %d\n", retval);
+                        goto err_set_vbus;
+                }
+        }
+
+        if (pdata->private_init)
+                pdata->private_init(ehci_mv->op_regs, ehci_mv->phy_regs);
+
+        dev_info(&pdev->dev,
+                 "successful find EHCI device with regs 0x%p irq %d"
+                 " working in %s mode\n", hcd->regs, hcd->irq,
+                 ehci_mv->mode == MV_USB_MODE_OTG ? "OTG" : "Host");
+
+        return 0;
+
+err_set_vbus:
+        if (pdata->set_vbus)
+                pdata->set_vbus(0);
+#ifdef CONFIG_USB_OTG_UTILS
+err_put_transceiver:
+        if (ehci_mv->otg)
+                otg_put_transceiver(ehci_mv->otg);
+#endif
+err_disable_clk:
+        mv_ehci_disable(ehci_mv);
+err_iounmap_capreg:
+        iounmap(ehci_mv->cap_regs);
+err_iounmap_phyreg:
+        iounmap(ehci_mv->phy_regs);
+err_put_clk:
+        for (clk_i--; clk_i >= 0; clk_i--)
+                clk_put(ehci_mv->clk[clk_i]);
+        platform_set_drvdata(pdev, NULL);
+        kfree(ehci_mv);
+err_put_hcd:
+        usb_put_hcd(hcd);
+
+        return retval;
+}
+
+static int mv_ehci_remove(struct platform_device *pdev)
+{
+        struct ehci_hcd_mv *ehci_mv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_mv->hcd;
+        int clk_i;
+
+        if (hcd->rh_registered)
+                usb_remove_hcd(hcd);
+
+        if (ehci_mv->otg) {
+                otg_set_host(ehci_mv->otg, NULL);
+                otg_put_transceiver(ehci_mv->otg);
+        }
+
+        if (ehci_mv->mode == MV_USB_MODE_HOST) {
+                if (ehci_mv->pdata->set_vbus)
+                        ehci_mv->pdata->set_vbus(0);
+
+                mv_ehci_disable(ehci_mv);
+        }
+
+        iounmap(ehci_mv->cap_regs);
+        iounmap(ehci_mv->phy_regs);
+
+        for (clk_i = 0; clk_i < ehci_mv->clknum; clk_i++)
+                clk_put(ehci_mv->clk[clk_i]);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(ehci_mv);
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+MODULE_ALIAS("mv-ehci");
+
+static const struct platform_device_id ehci_id_table[] = {
+        {"pxa-u2oehci", PXA_U2OEHCI},
+        {"pxa-sph", PXA_SPH},
+        {"mmp3-hsic", MMP3_HSIC},
+        {"mmp3-fsic", MMP3_FSIC},
+        {},
+};
+
+static void mv_ehci_shutdown(struct platform_device *pdev)
+{
+        struct ehci_hcd_mv *ehci_mv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_mv->hcd;
+
+        if (!hcd->rh_registered)
+                return;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver ehci_mv_driver = {
+        .probe = mv_ehci_probe,
+        .remove = mv_ehci_remove,
+        .shutdown = mv_ehci_shutdown,
+        .driver = {
+                   .name = "mv-ehci",
+                   .bus = &platform_bus_type,
+                   },
+        .id_table = ehci_id_table,
+};
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index ba1f51361134..c0104882c72d 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -155,6 +155,8 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
+        ehci_reset(ehci);
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret) {
                 dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index e39b0297bad1..e33baf9052cb 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -228,6 +228,8 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
+        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);
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 2dc32da75cfc..a20e496eb479 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -21,6 +21,34 @@
 #include <asm/firmware.h>
 #include <asm/ps3.h>
 
+static void ps3_ehci_setup_insnreg(struct ehci_hcd *ehci)
+{
+        /* PS3 HC internal setup register offsets. */
+
+        enum ps3_ehci_hc_insnreg {
+                ps3_ehci_hc_insnreg01 = 0x084,
+                ps3_ehci_hc_insnreg02 = 0x088,
+                ps3_ehci_hc_insnreg03 = 0x08c,
+        };
+
+        /* PS3 EHCI HC errata fix 316 - The PS3 EHCI HC will reset its
+         * internal INSNREGXX setup regs back to the chip default values
+         * on Host Controller Reset (CMD_RESET) or Light Host Controller
+         * Reset (CMD_LRESET).  The work-around for this is for the HC
+         * driver to re-initialise these regs when ever the HC is reset.
+         */
+
+        /* Set burst transfer counts to 256 out, 32 in. */
+
+        writel_be(0x01000020, (void __iomem *)ehci->regs +
+                ps3_ehci_hc_insnreg01);
+
+        /* Enable burst transfer counts. */
+
+        writel_be(0x00000001, (void __iomem *)ehci->regs +
+                ps3_ehci_hc_insnreg03);
+}
+
 static int ps3_ehci_hc_reset(struct usb_hcd *hcd)
 {
         int result;
@@ -49,6 +77,8 @@ static int ps3_ehci_hc_reset(struct usb_hcd *hcd)
 
         ehci_reset(ehci);
 
+        ps3_ehci_setup_insnreg(ehci);
+
         return result;
 }
 
diff --git a/drivers/usb/host/ehci-pxa168.c b/drivers/usb/host/ehci-pxa168.c
index ac0c16e8f539..8d0e7a22e711 100644
--- a/drivers/usb/host/ehci-pxa168.c
+++ b/drivers/usb/host/ehci-pxa168.c
@@ -299,7 +299,7 @@ static int __devinit ehci_pxa168_drv_probe(struct platform_device *pdev)
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
         hcd->has_tt = 1;
         ehci->sbrn = 0x20;
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 4e4066c35a09..36ca5077cdf7 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -373,6 +373,17 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
  retry_xacterr:
                 if ((token & QTD_STS_ACTIVE) == 0) {
 
+                        /* Report Data Buffer Error: non-fatal but useful */
+                        if (token & QTD_STS_DBE)
+                                ehci_dbg(ehci,
+                                        "detected DataBufferErr for urb %p ep%d%s len %d, qtd %p [qh %p]\n",
+                                        urb,
+                                        usb_endpoint_num(&urb->ep->desc),
+                                        usb_endpoint_dir_in(&urb->ep->desc) ? "in" : "out",
+                                        urb->transfer_buffer_length,
+                                        qtd,
+                                        qh);
+
                         /* on STALL, error, and short reads this urb must
                          * complete and all its qtds must be recycled.
                          */
@@ -647,7 +658,7 @@ qh_urb_transaction (
         /*
          * data transfer stage:  buffer setup
          */
-        i = urb->num_sgs;
+        i = urb->num_mapped_sgs;
         if (len > 0 && i > 0) {
                 sg = urb->sg;
                 buf = sg_dma_address(sg);
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index 024b65c4990d..293f7412992e 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -14,8 +14,6 @@
 
 #include <linux/clk.h>
 #include <linux/platform_device.h>
-#include <mach/regs-pmu.h>
-#include <plat/cpu.h>
 #include <plat/ehci.h>
 #include <plat/usb-phy.h>
 
@@ -136,6 +134,8 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
+        ehci_reset(ehci);
+
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
index 54d1ab8aec49..c1eda73916cd 100644
--- a/drivers/usb/host/ehci-vt8500.c
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -132,6 +132,8 @@ static int vt8500_ehci_drv_probe(struct platform_device *pdev)
 
         ehci_port_power(ehci, 1);
 
+        ehci_reset(ehci);
+
         ret = usb_add_hcd(hcd, pdev->resource[1].start,
                           IRQF_SHARED);
         if (ret == 0) {
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index d661cf7de140..3d2e26cbb34c 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -78,6 +78,8 @@ static int __devinit usb_w90x900_probe(const struct hc_driver *driver,
         if (irq < 0)
                 goto err4;
 
+        ehci_reset(ehci);
+
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval != 0)
                 goto err4;
diff --git a/drivers/usb/host/ehci-xls.c b/drivers/usb/host/ehci-xls.c
index b4fb511d24bc..72f08196f8cd 100644
--- a/drivers/usb/host/ehci-xls.c
+++ b/drivers/usb/host/ehci-xls.c
@@ -69,7 +69,7 @@ int ehci_xls_probe_internal(const struct hc_driver *driver,
         }
 
         hcd->rsrc_start = res->start;
-        hcd->rsrc_len = res->end - res->start + 1;
+        hcd->rsrc_len = resource_size(res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
                                 driver->description)) {
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 4ed6d19f2a54..d2623747b489 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -824,17 +824,7 @@ static struct platform_driver of_fhci_driver = {
         .remove         = __devexit_p(of_fhci_remove),
 };
 
-static int __init fhci_module_init(void)
-{
-        return platform_driver_register(&of_fhci_driver);
-}
-module_init(fhci_module_init);
-
-static void __exit fhci_module_exit(void)
-{
-        platform_driver_unregister(&of_fhci_driver);
-}
-module_exit(fhci_module_exit);
+module_platform_driver(of_fhci_driver);
 
 MODULE_DESCRIPTION("USB Freescale Host Controller Interface Driver");
 MODULE_AUTHOR("Shlomi Gridish <gridish@freescale.com>, "
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index 9037035ad1e4..7916e56a725e 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -297,17 +297,7 @@ static struct platform_driver fsl_usb2_mph_dr_driver = {
         .remove = __devexit_p(fsl_usb2_mph_dr_of_remove),
 };
 
-static int __init fsl_usb2_mph_dr_init(void)
-{
-        return platform_driver_register(&fsl_usb2_mph_dr_driver);
-}
-module_init(fsl_usb2_mph_dr_init);
-
-static void __exit fsl_usb2_mph_dr_exit(void)
-{
-        platform_driver_unregister(&fsl_usb2_mph_dr_driver);
-}
-module_exit(fsl_usb2_mph_dr_exit);
+module_platform_driver(fsl_usb2_mph_dr_driver);
 
 MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index 43b3ca48d753..104730dabd2d 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -776,7 +776,6 @@ static int hwahc_probe(struct usb_interface *usb_iface,
                 goto error_alloc;
         }
         usb_hcd->wireless = 1;
-        set_bit(HCD_FLAG_SAW_IRQ, &usb_hcd->flags);
         wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         hwahc = container_of(wusbhc, struct hwahc, wusbhc);
         hwahc_init(hwahc);
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index dbf0f156ed9e..ff471c1c165e 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -1924,18 +1924,7 @@ static struct platform_driver imx21_hcd_driver = {
         .resume = NULL,
 };
 
-static int __init imx21_hcd_init(void)
-{
-        return platform_driver_register(&imx21_hcd_driver);
-}
-
-static void __exit imx21_hcd_cleanup(void)
-{
-        platform_driver_unregister(&imx21_hcd_driver);
-}
-
-module_init(imx21_hcd_init);
-module_exit(imx21_hcd_cleanup);
+module_platform_driver(imx21_hcd_driver);
 
 MODULE_DESCRIPTION("i.MX21 USB Host controller");
 MODULE_AUTHOR("Martin Fuzzey");
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 27dfab80ed8f..fc72d44bf787 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -32,6 +32,13 @@ static struct kmem_cache *qtd_cachep;
 static struct kmem_cache *qh_cachep;
 static struct kmem_cache *urb_listitem_cachep;
 
+enum queue_head_types {
+        QH_CONTROL,
+        QH_BULK,
+        QH_INTERRUPT,
+        QH_END
+};
+
 struct isp1760_hcd {
         u32 hcs_params;
         spinlock_t              lock;
@@ -40,7 +47,7 @@ struct isp1760_hcd {
         struct slotinfo         int_slots[32];
         int                     int_done_map;
         struct memory_chunk memory_pool[BLOCKS];
-        struct list_head        controlqhs, bulkqhs, interruptqhs;
+        struct list_head        qh_list[QH_END];
 
         /* periodic schedule support */
 #define DEFAULT_I_TDPS          1024
@@ -406,12 +413,12 @@ static int priv_init(struct usb_hcd *hcd)
 {
         struct isp1760_hcd              *priv = hcd_to_priv(hcd);
         u32                     hcc_params;
+        int i;
 
         spin_lock_init(&priv->lock);
 
-        INIT_LIST_HEAD(&priv->interruptqhs);
-        INIT_LIST_HEAD(&priv->controlqhs);
-        INIT_LIST_HEAD(&priv->bulkqhs);
+        for (i = 0; i < QH_END; i++)
+                INIT_LIST_HEAD(&priv->qh_list[i]);
 
         /*
          * hw default: 1K periodic list heads, one per frame.
@@ -930,9 +937,9 @@ void schedule_ptds(struct usb_hcd *hcd)
         struct isp1760_hcd *priv;
         struct isp1760_qh *qh, *qh_next;
         struct list_head *ep_queue;
-        struct usb_host_endpoint *ep;
         LIST_HEAD(urb_list);
         struct urb_listitem *urb_listitem, *urb_listitem_next;
+        int i;
 
         if (!hcd) {
                 WARN_ON(1);
@@ -944,28 +951,13 @@ void schedule_ptds(struct usb_hcd *hcd)
         /*
          * check finished/retired xfers, transfer payloads, call urb_done()
          */
-        ep_queue = &priv->interruptqhs;
-        while (ep_queue) {
+        for (i = 0; i < QH_END; i++) {
+                ep_queue = &priv->qh_list[i];
                 list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list) {
-                        ep = list_entry(qh->qtd_list.next, struct isp1760_qtd,
-                                                        qtd_list)->urb->ep;
                         collect_qtds(hcd, qh, &urb_list);
-                        if (list_empty(&qh->qtd_list)) {
+                        if (list_empty(&qh->qtd_list))
                                 list_del(&qh->qh_list);
-                                if (ep->hcpriv == NULL) {
-                                        /* Endpoint has been disabled, so we
-                                        can free the associated queue head. */
-                                        qh_free(qh);
-                                }
-                        }
                 }
-
-                if (ep_queue == &priv->interruptqhs)
-                        ep_queue = &priv->controlqhs;
-                else if (ep_queue == &priv->controlqhs)
-                        ep_queue = &priv->bulkqhs;
-                else
-                        ep_queue = NULL;
         }
 
         list_for_each_entry_safe(urb_listitem, urb_listitem_next, &urb_list,
@@ -998,17 +990,10 @@ void schedule_ptds(struct usb_hcd *hcd)
          *
          * I'm sure this scheme could be improved upon!
          */
-        ep_queue = &priv->controlqhs;
-        while (ep_queue) {
+        for (i = 0; i < QH_END; i++) {
+                ep_queue = &priv->qh_list[i];
                 list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list)
                         enqueue_qtds(hcd, qh);
-
-                if (ep_queue == &priv->controlqhs)
-                        ep_queue = &priv->interruptqhs;
-                else if (ep_queue == &priv->interruptqhs)
-                        ep_queue = &priv->bulkqhs;
-                else
-                        ep_queue = NULL;
         }
 }
 
@@ -1543,16 +1528,16 @@ static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
 
         switch (usb_pipetype(urb->pipe)) {
         case PIPE_CONTROL:
-                ep_queue = &priv->controlqhs;
+                ep_queue = &priv->qh_list[QH_CONTROL];
                 break;
         case PIPE_BULK:
-                ep_queue = &priv->bulkqhs;
+                ep_queue = &priv->qh_list[QH_BULK];
                 break;
         case PIPE_INTERRUPT:
                 if (urb->interval < 0)
                         return -EINVAL;
                 /* FIXME: Check bandwidth  */
-                ep_queue = &priv->interruptqhs;
+                ep_queue = &priv->qh_list[QH_INTERRUPT];
                 break;
         case PIPE_ISOCHRONOUS:
                 dev_err(hcd->self.controller, "%s: isochronous USB packets "
@@ -1714,8 +1699,8 @@ static void isp1760_endpoint_disable(struct usb_hcd *hcd,
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         unsigned long spinflags;
-        struct isp1760_qh *qh;
-        struct isp1760_qtd *qtd;
+        struct isp1760_qh *qh, *qh_iter;
+        int i;
 
         spin_lock_irqsave(&priv->lock, spinflags);
 
@@ -1723,14 +1708,17 @@ static void isp1760_endpoint_disable(struct usb_hcd *hcd,
         if (!qh)
                 goto out;
 
-        list_for_each_entry(qtd, &qh->qtd_list, qtd_list)
-                if (qtd->status != QTD_RETIRE) {
-                        dequeue_urb_from_qtd(hcd, qh, qtd);
-                        qtd->urb->status = -ECONNRESET;
-                }
+        WARN_ON(!list_empty(&qh->qtd_list));
 
+        for (i = 0; i < QH_END; i++)
+                list_for_each_entry(qh_iter, &priv->qh_list[i], qh_list)
+                        if (qh_iter == qh) {
+                                list_del(&qh_iter->qh_list);
+                                i = QH_END;
+                                break;
+                        }
+        qh_free(qh);
         ep->hcpriv = NULL;
-        /* Cannot free qh here since it will be parsed by schedule_ptds() */
 
         schedule_ptds(hcd);
 
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 2ac4ac2e4ef9..4592dc17a9f9 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -47,23 +47,27 @@ static int of_isp1760_probe(struct platform_device *dev)
         int virq;
         resource_size_t res_len;
         int ret;
-        const unsigned int *prop;
         unsigned int devflags = 0;
         enum of_gpio_flags gpio_flags;
+        u32 bus_width = 0;
 
         drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
         if (!drvdata)
                 return -ENOMEM;
 
         ret = of_address_to_resource(dp, 0, &memory);
-        if (ret)
-                return -ENXIO;
+        if (ret) {
+                ret = -ENXIO;
+                goto free_data;
+        }
 
         res_len = resource_size(&memory);
 
         res = request_mem_region(memory.start, res_len, dev_name(&dev->dev));
-        if (!res)
-                return -EBUSY;
+        if (!res) {
+                ret = -EBUSY;
+                goto free_data;
+        }
 
         if (of_irq_map_one(dp, 0, &oirq)) {
                 ret = -ENODEV;
@@ -77,8 +81,8 @@ static int of_isp1760_probe(struct platform_device *dev)
                 devflags |= ISP1760_FLAG_ISP1761;
 
         /* Some systems wire up only 16 of the 32 data lines */
-        prop = of_get_property(dp, "bus-width", NULL);
-        if (prop && *prop == 16)
+        of_property_read_u32(dp, "bus-width", &bus_width);
+        if (bus_width == 16)
                 devflags |= ISP1760_FLAG_BUS_WIDTH_16;
 
         if (of_get_property(dp, "port1-otg", NULL) != NULL)
@@ -125,6 +129,7 @@ free_gpio:
                 gpio_free(drvdata->rst_gpio);
 release_reg:
         release_mem_region(memory.start, res_len);
+free_data:
         kfree(drvdata);
         return ret;
 }
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 9b66df8278f3..40d886adff53 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -173,12 +173,9 @@ static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
          * mark HW unaccessible, bail out if RH has been resumed. Use
          * the spinlock to properly synchronize with possible pending
          * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
          */
         spin_lock_irqsave(&ohci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
+        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
                 rc = -EINVAL;
                 goto bail;
         }
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index d7d34492934a..5179fcd73d8a 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -127,6 +127,19 @@ static char *hcfs2string (int state)
         return "?";
 }
 
+static const char *rh_state_string(struct ohci_hcd *ohci)
+{
+        switch (ohci->rh_state) {
+        case OHCI_RH_HALTED:
+                return "halted";
+        case OHCI_RH_SUSPENDED:
+                return "suspended";
+        case OHCI_RH_RUNNING:
+                return "running";
+        }
+        return "?";
+}
+
 // dump control and status registers
 static void
 ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size)
@@ -136,9 +149,10 @@ ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size)
 
         temp = ohci_readl (controller, &regs->revision) & 0xff;
         ohci_dbg_sw (controller, next, size,
-                "OHCI %d.%d, %s legacy support registers\n",
+                "OHCI %d.%d, %s legacy support registers, rh state %s\n",
                 0x03 & (temp >> 4), (temp & 0x0f),
-                (temp & 0x0100) ? "with" : "NO");
+                (temp & 0x0100) ? "with" : "NO",
+                rh_state_string(controller));
 
         temp = ohci_readl (controller, &regs->control);
         ohci_dbg_sw (controller, next, size,
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index dc45d489d00e..3d63574d2c7e 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -179,8 +179,6 @@ static int ohci_hcd_ep93xx_drv_suspend(struct platform_device *pdev, pm_message_
         ohci->next_statechange = jiffies;
 
         ep93xx_stop_hc(&pdev->dev);
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index b2639191549e..4fa5d8c4d239 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -209,7 +209,7 @@ static int ohci_urb_enqueue (
                 retval = -ENODEV;
                 goto fail;
         }
-        if (!HC_IS_RUNNING(hcd->state)) {
+        if (ohci->rh_state != OHCI_RH_RUNNING) {
                 retval = -ENODEV;
                 goto fail;
         }
@@ -274,7 +274,7 @@ static int ohci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
         if (rc) {
                 ;       /* Do nothing */
-        } else if (HC_IS_RUNNING(hcd->state)) {
+        } else if (ohci->rh_state == OHCI_RH_RUNNING) {
                 urb_priv_t  *urb_priv;
 
                 /* Unless an IRQ completed the unlink while it was being
@@ -321,7 +321,7 @@ ohci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
 rescan:
         spin_lock_irqsave (&ohci->lock, flags);
 
-        if (!HC_IS_RUNNING (hcd->state)) {
+        if (ohci->rh_state != OHCI_RH_RUNNING) {
 sanitize:
                 ed->state = ED_IDLE;
                 if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT)
@@ -377,6 +377,7 @@ static void ohci_usb_reset (struct ohci_hcd *ohci)
         ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
         ohci->hc_control &= OHCI_CTRL_RWC;
         ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
+        ohci->rh_state = OHCI_RH_HALTED;
 }
 
 /* ohci_shutdown forcibly disables IRQs and DMA, helping kexec and
@@ -500,7 +501,7 @@ static int ohci_init (struct ohci_hcd *ohci)
         if (distrust_firmware)
                 ohci->flags |= OHCI_QUIRK_HUB_POWER;
 
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
         ohci->regs = hcd->regs;
 
         /* REVISIT this BIOS handshake is now moved into PCI "quirks", and
@@ -575,7 +576,7 @@ static int ohci_run (struct ohci_hcd *ohci)
         int                     first = ohci->fminterval == 0;
         struct usb_hcd          *hcd = ohci_to_hcd(ohci);
 
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
 
         /* boot firmware should have set this up (5.1.1.3.1) */
         if (first) {
@@ -688,7 +689,7 @@ retry:
         ohci->hc_control &= OHCI_CTRL_RWC;
         ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
         ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
-        hcd->state = HC_STATE_RUNNING;
+        ohci->rh_state = OHCI_RH_RUNNING;
 
         /* wake on ConnectStatusChange, matching external hubs */
         ohci_writel (ohci, RH_HS_DRWE, &ohci->regs->roothub.status);
@@ -725,7 +726,6 @@ retry:
 
         // POTPGT delay is bits 24-31, in 2 ms units.
         mdelay ((val >> 23) & 0x1fe);
-        hcd->state = HC_STATE_RUNNING;
 
         if (quirk_zfmicro(ohci)) {
                 /* Create timer to watch for bad queue state on ZF Micro */
@@ -761,7 +761,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
          * of dead, unclocked, or unplugged (CardBus...) devices
          */
         if (ints == ~(u32)0) {
-                disable (ohci);
+                ohci->rh_state = OHCI_RH_HALTED;
                 ohci_dbg (ohci, "device removed!\n");
                 usb_hc_died(hcd);
                 return IRQ_HANDLED;
@@ -771,7 +771,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         ints &= ohci_readl(ohci, &regs->intrenable);
 
         /* interrupt for some other device? */
-        if (ints == 0 || unlikely(hcd->state == HC_STATE_HALT))
+        if (ints == 0 || unlikely(ohci->rh_state == OHCI_RH_HALTED))
                 return IRQ_NOTMINE;
 
         if (ints & OHCI_INTR_UE) {
@@ -786,8 +786,8 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
 
                         schedule_work (&ohci->nec_work);
                 } else {
-                        disable (ohci);
                         ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");
+                        ohci->rh_state = OHCI_RH_HALTED;
                         usb_hc_died(hcd);
                 }
 
@@ -871,11 +871,11 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         if ((ints & OHCI_INTR_SF) != 0
                         && !ohci->ed_rm_list
                         && !ohci->ed_to_check
-                        && HC_IS_RUNNING(hcd->state))
+                        && ohci->rh_state == OHCI_RH_RUNNING)
                 ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable);
         spin_unlock (&ohci->lock);
 
-        if (HC_IS_RUNNING(hcd->state)) {
+        if (ohci->rh_state == OHCI_RH_RUNNING) {
                 ohci_writel (ohci, ints, &regs->intrstatus);
                 ohci_writel (ohci, OHCI_INTR_MIE, &regs->intrenable);
                 // flush those writes
@@ -929,7 +929,7 @@ static int ohci_restart (struct ohci_hcd *ohci)
         struct urb_priv *priv;
 
         spin_lock_irq(&ohci->lock);
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
 
         /* Recycle any "live" eds/tds (and urbs). */
         if (!list_empty (&ohci->pending))
@@ -1111,7 +1111,7 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_ath79_driver
 #endif
 
-#ifdef CONFIG_NLM_XLR
+#ifdef CONFIG_CPU_XLR
 #include "ohci-xls.c"
 #define PLATFORM_DRIVER         ohci_xls_driver
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 2f00040fc408..836772dfabd3 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -111,6 +111,7 @@ __acquires(ohci->lock)
         if (!autostop) {
                 ohci->next_statechange = jiffies + msecs_to_jiffies (5);
                 ohci->autostop = 0;
+                ohci->rh_state = OHCI_RH_SUSPENDED;
         }
 
 done:
@@ -140,7 +141,7 @@ __acquires(ohci->lock)
 
         if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
                 /* this can happen after resuming a swsusp snapshot */
-                if (hcd->state == HC_STATE_RESUMING) {
+                if (ohci->rh_state != OHCI_RH_RUNNING) {
                         ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
                                         ohci->hc_control);
                         status = -EBUSY;
@@ -274,6 +275,7 @@ skip_resume:
                 (void) ohci_readl (ohci, &ohci->regs->control);
         }
 
+        ohci->rh_state = OHCI_RH_RUNNING;
         return 0;
 }
 
@@ -336,11 +338,8 @@ static void ohci_finish_controller_resume(struct usb_hcd *hcd)
         /* If needed, reinitialize and suspend the root hub */
         if (need_reinit) {
                 spin_lock_irq(&ohci->lock);
-                hcd->state = HC_STATE_RESUMING;
                 ohci_rh_resume(ohci);
-                hcd->state = HC_STATE_QUIESCING;
                 ohci_rh_suspend(ohci, 0);
-                hcd->state = HC_STATE_SUSPENDED;
                 spin_unlock_irq(&ohci->lock);
         }
 
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index e4b8782cc6e2..db3968656d21 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -516,7 +516,6 @@ static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
         ohci->next_statechange = jiffies;
 
         omap_ohci_clock_power(0);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index bc01b064585a..6109810cc2d3 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -308,12 +308,9 @@ static int ohci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
          * mark HW unaccessible, bail out if RH has been resumed. Use
          * the spinlock to properly synchronize with possible pending
          * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
          */
         spin_lock_irqsave (&ohci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
+        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
                 rc = -EINVAL;
                 goto bail;
         }
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 29dfefe1c726..6313e4439f37 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -502,8 +502,6 @@ static int ohci_hcd_pxa27x_drv_suspend(struct device *dev)
         ohci->ohci.next_statechange = jiffies;
 
         pxa27x_stop_hc(ohci, dev);
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 15dc51ded61a..c5a1ea9145fa 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -912,7 +912,7 @@ rescan_all:
                 /* only take off EDs that the HC isn't using, accounting for
                  * frame counter wraps and EDs with partially retired TDs
                  */
-                if (likely (HC_IS_RUNNING(ohci_to_hcd(ohci)->state))) {
+                if (likely(ohci->rh_state == OHCI_RH_RUNNING)) {
                         if (tick_before (tick, ed->tick)) {
 skip_ed:
                                 last = &ed->ed_next;
@@ -1012,7 +1012,7 @@ rescan_this:
 
                 /* but if there's work queued, reschedule */
                 if (!list_empty (&ed->td_list)) {
-                        if (HC_IS_RUNNING(ohci_to_hcd(ohci)->state))
+                        if (ohci->rh_state == OHCI_RH_RUNNING)
                                 ed_schedule (ohci, ed);
                 }
 
@@ -1021,9 +1021,7 @@ rescan_this:
         }
 
         /* maybe reenable control and bulk lists */
-        if (HC_IS_RUNNING(ohci_to_hcd(ohci)->state)
-                        && ohci_to_hcd(ohci)->state != HC_STATE_QUIESCING
-                        && !ohci->ed_rm_list) {
+        if (ohci->rh_state == OHCI_RH_RUNNING && !ohci->ed_rm_list) {
                 u32     command = 0, control = 0;
 
                 if (ohci->ed_controltail) {
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index a1877c47601e..56dcf069246d 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -486,15 +486,66 @@ static int __devexit ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int ohci_hcd_s3c2410_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct platform_device *pdev = to_platform_device(dev);
+        unsigned long flags;
+        int rc = 0;
+
+        /*
+         * Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible, bail out if RH has been resumed. Use
+         * the spinlock to properly synchronize with possible pending
+         * RH suspend or resume activity.
+         */
+        spin_lock_irqsave(&ohci->lock, flags);
+        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
+                rc = -EINVAL;
+                goto bail;
+        }
+
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        s3c2410_stop_hc(pdev);
+bail:
+        spin_unlock_irqrestore(&ohci->lock, flags);
+
+        return rc;
+}
+
+static int ohci_hcd_s3c2410_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct platform_device *pdev = to_platform_device(dev);
+
+        s3c2410_start_hc(pdev, hcd);
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        ohci_finish_controller_resume(hcd);
+
+        return 0;
+}
+#else
+#define ohci_hcd_s3c2410_drv_suspend    NULL
+#define ohci_hcd_s3c2410_drv_resume     NULL
+#endif
+
+static const struct dev_pm_ops ohci_hcd_s3c2410_pm_ops = {
+        .suspend        = ohci_hcd_s3c2410_drv_suspend,
+        .resume         = ohci_hcd_s3c2410_drv_resume,
+};
+
 static struct platform_driver ohci_hcd_s3c2410_driver = {
         .probe          = ohci_hcd_s3c2410_drv_probe,
         .remove         = __devexit_p(ohci_hcd_s3c2410_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
-        /*.suspend      = ohci_hcd_s3c2410_drv_suspend, */
-        /*.resume       = ohci_hcd_s3c2410_drv_resume, */
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = "s3c2410-ohci",
+                .pm     = &ohci_hcd_s3c2410_pm_ops,
         },
 };
 
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index afc4eb6bb9d0..84686d90805b 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -29,7 +29,6 @@ static int ohci_sh_start(struct usb_hcd *hcd)
         ohci_hcd_init(ohci);
         ohci_init(ohci);
         ohci_run(ohci);
-        hcd->state = HC_STATE_RUNNING;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 968cea2b6d4e..5596ac2ba1ca 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -224,7 +224,6 @@ static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
         ohci->next_statechange = jiffies;
 
         sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 69874654f3b5..95c16489e883 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -203,7 +203,6 @@ static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
         ohci->next_statechange = jiffies;
 
         spear_stop_ohci(ohci_p);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 06331d931171..120bfe6ede38 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -318,9 +318,6 @@ static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t s
                 if (ret)
                         return ret;
         }
-
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-xls.c b/drivers/usb/host/ohci-xls.c
index a3a9c6f45b91..a2247867af86 100644
--- a/drivers/usb/host/ohci-xls.c
+++ b/drivers/usb/host/ohci-xls.c
@@ -40,7 +40,7 @@ static int ohci_xls_probe_internal(const struct hc_driver *driver,
                 goto err1;
         }
         hcd->rsrc_start = res->start;
-        hcd->rsrc_len = res->end - res->start + 1;
+        hcd->rsrc_len = resource_size(res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
                         driver->description)) {
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 0795b934d00c..8ff6f7ea96fd 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -344,6 +344,12 @@ typedef struct urb_priv {
  * a subset of what the full implementation needs. (Linus)
  */
 
+enum ohci_rh_state {
+        OHCI_RH_HALTED,
+        OHCI_RH_SUSPENDED,
+        OHCI_RH_RUNNING
+};
+
 struct ohci_hcd {
         spinlock_t              lock;
 
@@ -384,6 +390,7 @@ struct ohci_hcd {
         /*
          * driver state
          */
+        enum ohci_rh_state      rh_state;
         int                     num_ports;
         int                     load [NUM_INTS];
         u32                     hc_control;     /* copy of hc control reg */
@@ -679,11 +686,6 @@ static inline u16 ohci_hwPSW(const struct ohci_hcd *ohci,
 
 /*-------------------------------------------------------------------------*/
 
-static inline void disable (struct ohci_hcd *ohci)
-{
-        ohci_to_hcd(ohci)->state = HC_STATE_HALT;
-}
-
 #define FI                      0x2edf          /* 12000 bits per frame (-1) */
 #define FSMP(fi)                (0x7fff & ((6 * ((fi) - 210)) / 7))
 #define FIT                     (1 << 31)
@@ -707,7 +709,7 @@ static inline void periodic_reinit (struct ohci_hcd *ohci)
 #define read_roothub(hc, register, mask) ({ \
         u32 temp = ohci_readl (hc, &hc->regs->roothub.register); \
         if (temp == -1) \
-                disable (hc); \
+                hc->rh_state = OHCI_RH_HALTED; \
         else if (hc->flags & OHCI_QUIRK_AMD756) \
                 while (temp & mask) \
                         temp = ohci_readl (hc, &hc->regs->roothub.register); \
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index dcd889803f0f..6f62de5c6e35 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -3951,24 +3951,7 @@ static struct platform_driver oxu_driver = {
         }
 };
 
-static int __init oxu_module_init(void)
-{
-        int retval = 0;
-
-        retval = platform_driver_register(&oxu_driver);
-        if (retval < 0)
-                return retval;
-
-        return retval;
-}
-
-static void __exit oxu_module_cleanup(void)
-{
-        platform_driver_unregister(&oxu_driver);
-}
-
-module_init(oxu_module_init);
-module_exit(oxu_module_cleanup);
+module_platform_driver(oxu_driver);
 
 MODULE_DESCRIPTION("Oxford OXU210HP HCD driver - ver. " DRIVER_VERSION);
 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index f6ca80ee4cec..d2c6f5ac4626 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -943,7 +943,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
         if (usb_pipein(urb->pipe))
                 status |= TD_CTRL_SPD;
 
-        i = urb->num_sgs;
+        i = urb->num_mapped_sgs;
         if (len > 0 && i > 0) {
                 sg = urb->sg;
                 data = sg_dma_address(sg);
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index a403b53e86b9..76083ae92138 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -443,7 +443,7 @@ static int qset_add_urb_sg(struct whc *whc, struct whc_qset *qset, struct urb *u
 
         remaining = urb->transfer_buffer_length;
 
-        for_each_sg(urb->sg, sg, urb->num_sgs, i) {
+        for_each_sg(urb->sg, sg, urb->num_mapped_sgs, i) {
                 dma_addr_t dma_addr;
                 size_t dma_remaining;
                 dma_addr_t sp, ep;
@@ -561,7 +561,7 @@ static int qset_add_urb_sg_linearize(struct whc *whc, struct whc_qset *qset,
 
         remaining = urb->transfer_buffer_length;
 
-        for_each_sg(urb->sg, sg, urb->num_sgs, i) {
+        for_each_sg(urb->sg, sg, urb->num_mapped_sgs, i) {
                 size_t len;
                 size_t sg_remaining;
                 void *orig;
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 430e88fd3f6c..35e257f79c7b 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -57,17 +57,15 @@ static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
         desc->bHubContrCurrent = 0;
 
         desc->bNbrPorts = ports;
-        /* Ugh, these should be #defines, FIXME */
-        /* Using table 11-13 in USB 2.0 spec. */
         temp = 0;
-        /* Bits 1:0 - support port power switching, or power always on */
+        /* Bits 1:0 - support per-port power switching, or power always on */
         if (HCC_PPC(xhci->hcc_params))
-                temp |= 0x0001;
+                temp |= HUB_CHAR_INDV_PORT_LPSM;
         else
-                temp |= 0x0002;
+                temp |= HUB_CHAR_NO_LPSM;
         /* Bit  2 - root hubs are not part of a compound device */
         /* Bits 4:3 - individual port over current protection */
-        temp |= 0x0008;
+        temp |= HUB_CHAR_INDV_PORT_OCPM;
         /* Bits 6:5 - no TTs in root ports */
         /* Bit  7 - no port indicators */
         desc->wHubCharacteristics = cpu_to_le16(temp);
@@ -86,9 +84,9 @@ static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
         ports = xhci->num_usb2_ports;
 
         xhci_common_hub_descriptor(xhci, desc, ports);
-        desc->bDescriptorType = 0x29;
+        desc->bDescriptorType = USB_DT_HUB;
         temp = 1 + (ports / 8);
-        desc->bDescLength = 7 + 2 * temp;
+        desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * temp;
 
         /* The Device Removable bits are reported on a byte granularity.
          * If the port doesn't exist within that byte, the bit is set to 0.
@@ -137,8 +135,8 @@ static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
 
         ports = xhci->num_usb3_ports;
         xhci_common_hub_descriptor(xhci, desc, ports);
-        desc->bDescriptorType = 0x2a;
-        desc->bDescLength = 12;
+        desc->bDescriptorType = USB_DT_SS_HUB;
+        desc->bDescLength = USB_DT_SS_HUB_SIZE;
 
         /* header decode latency should be zero for roothubs,
          * see section 4.23.5.2.
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 0e4b25fa3bcd..36cbe2226a44 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -42,15 +42,12 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flag
         seg = kzalloc(sizeof *seg, flags);
         if (!seg)
                 return NULL;
-        xhci_dbg(xhci, "Allocating priv segment structure at %p\n", seg);
 
         seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma);
         if (!seg->trbs) {
                 kfree(seg);
                 return NULL;
         }
-        xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n",
-                        seg->trbs, (unsigned long long)dma);
 
         memset(seg->trbs, 0, SEGMENT_SIZE);
         seg->dma = dma;
@@ -62,12 +59,9 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flag
 static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
 {
         if (seg->trbs) {
-                xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n",
-                                seg->trbs, (unsigned long long)seg->dma);
                 dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma);
                 seg->trbs = NULL;
         }
-        xhci_dbg(xhci, "Freeing priv segment structure at %p\n", seg);
         kfree(seg);
 }
 
@@ -101,9 +95,6 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                         val |= TRB_CHAIN;
                 prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
         }
-        xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n",
-                        (unsigned long long)prev->dma,
-                        (unsigned long long)next->dma);
 }
 
 /* XXX: Do we need the hcd structure in all these functions? */
@@ -117,7 +108,6 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
         if (ring->first_seg) {
                 first_seg = ring->first_seg;
                 seg = first_seg->next;
-                xhci_dbg(xhci, "Freeing ring at %p\n", ring);
                 while (seg != first_seg) {
                         struct xhci_segment *next = seg->next;
                         xhci_segment_free(xhci, seg);
@@ -160,7 +150,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
         struct xhci_segment     *prev;
 
         ring = kzalloc(sizeof *(ring), flags);
-        xhci_dbg(xhci, "Allocating ring at %p\n", ring);
         if (!ring)
                 return NULL;
 
@@ -191,9 +180,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                 /* See section 4.9.2.1 and 6.4.4.1 */
                 prev->trbs[TRBS_PER_SEGMENT-1].link.control |=
                         cpu_to_le32(LINK_TOGGLE);
-                xhci_dbg(xhci, "Wrote link toggle flag to"
-                                " segment %p (virtual), 0x%llx (DMA)\n",
-                                prev, (unsigned long long)prev->dma);
         }
         xhci_initialize_ring_info(ring);
         return ring;
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 9f1d4b15d818..b90e1386418b 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -155,10 +155,6 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
         while (last_trb(xhci, ring, ring->deq_seg, next)) {
                 if (consumer && last_trb_on_last_seg(xhci, ring, ring->deq_seg, next)) {
                         ring->cycle_state = (ring->cycle_state ? 0 : 1);
-                        if (!in_interrupt())
-                                xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n",
-                                                ring,
-                                                (unsigned int) ring->cycle_state);
                 }
                 ring->deq_seg = ring->deq_seg->next;
                 ring->dequeue = ring->deq_seg->trbs;
@@ -231,10 +227,6 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
                                 ring->cycle_state = (ring->cycle_state ? 0 : 1);
-                                if (!in_interrupt())
-                                        xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n",
-                                                        ring,
-                                                        (unsigned int) ring->cycle_state);
                         }
                 }
                 ring->enq_seg = ring->enq_seg->next;
@@ -560,12 +552,9 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                                         cpu_to_le32(TRB_CYCLE);
                         cur_trb->generic.field[3] |= cpu_to_le32(
                                 TRB_TYPE(TRB_TR_NOOP));
-                        xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
-                                        "in seg %p (0x%llx dma)\n",
-                                        cur_trb,
-                                        (unsigned long long)xhci_trb_virt_to_dma(cur_seg, cur_trb),
-                                        cur_seg,
-                                        (unsigned long long)cur_seg->dma);
+                        xhci_dbg(xhci, "TRB to noop at offset 0x%llx\n",
+                                        (unsigned long long)
+                                        xhci_trb_virt_to_dma(cur_seg, cur_trb));
                 }
                 if (cur_trb == cur_td->last_trb)
                         break;
@@ -705,9 +694,9 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
          */
         list_for_each(entry, &ep->cancelled_td_list) {
                 cur_td = list_entry(entry, struct xhci_td, cancelled_td_list);
-                xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n",
-                                cur_td->first_trb,
-                                (unsigned long long)xhci_trb_virt_to_dma(cur_td->start_seg, cur_td->first_trb));
+                xhci_dbg(xhci, "Removing canceled TD starting at 0x%llx (dma).\n",
+                                (unsigned long long)xhci_trb_virt_to_dma(
+                                        cur_td->start_seg, cur_td->first_trb));
                 ep_ring = xhci_urb_to_transfer_ring(xhci, cur_td->urb);
                 if (!ep_ring) {
                         /* This shouldn't happen unless a driver is mucking
@@ -1627,7 +1616,6 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
         trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
-        xhci_debug_trb(xhci, xhci->event_ring->dequeue);
         switch (trb_comp_code) {
         case COMP_SUCCESS:
                 if (event_trb == ep_ring->dequeue) {
@@ -1643,7 +1631,6 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 }
                 break;
         case COMP_SHORT_TX:
-                xhci_warn(xhci, "WARN: short transfer on control ep\n");
                 if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
                         *status = -EREMOTEIO;
                 else
@@ -1946,6 +1933,16 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         xdev = xhci->devs[slot_id];
         if (!xdev) {
                 xhci_err(xhci, "ERROR Transfer event pointed to bad slot\n");
+                xhci_err(xhci, "@%016llx %08x %08x %08x %08x\n",
+                         (unsigned long long) xhci_trb_virt_to_dma(
+                                 xhci->event_ring->deq_seg,
+                                 xhci->event_ring->dequeue),
+                         lower_32_bits(le64_to_cpu(event->buffer)),
+                         upper_32_bits(le64_to_cpu(event->buffer)),
+                         le32_to_cpu(event->transfer_len),
+                         le32_to_cpu(event->flags));
+                xhci_dbg(xhci, "Event ring:\n");
+                xhci_debug_segment(xhci, xhci->event_ring->deq_seg);
                 return -ENODEV;
         }
 
@@ -1959,6 +1956,16 @@ static int handle_tx_event(struct xhci_hcd *xhci,
             EP_STATE_DISABLED) {
                 xhci_err(xhci, "ERROR Transfer event for disabled endpoint "
                                 "or incorrect stream ring\n");
+                xhci_err(xhci, "@%016llx %08x %08x %08x %08x\n",
+                         (unsigned long long) xhci_trb_virt_to_dma(
+                                 xhci->event_ring->deq_seg,
+                                 xhci->event_ring->dequeue),
+                         lower_32_bits(le64_to_cpu(event->buffer)),
+                         upper_32_bits(le64_to_cpu(event->buffer)),
+                         le32_to_cpu(event->transfer_len),
+                         le32_to_cpu(event->flags));
+                xhci_dbg(xhci, "Event ring:\n");
+                xhci_debug_segment(xhci, xhci->event_ring->deq_seg);
                 return -ENODEV;
         }
 
@@ -1985,7 +1992,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 xhci_dbg(xhci, "Stopped on No-op or Link TRB\n");
                 break;
         case COMP_STALL:
-                xhci_warn(xhci, "WARN: Stalled endpoint\n");
+                xhci_dbg(xhci, "Stalled endpoint\n");
                 ep->ep_state |= EP_HALTED;
                 status = -EPIPE;
                 break;
@@ -1995,11 +2002,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 break;
         case COMP_SPLIT_ERR:
         case COMP_TX_ERR:
-                xhci_warn(xhci, "WARN: transfer error on endpoint\n");
+                xhci_dbg(xhci, "Transfer error on endpoint\n");
                 status = -EPROTO;
                 break;
         case COMP_BABBLE:
-                xhci_warn(xhci, "WARN: babble error on endpoint\n");
+                xhci_dbg(xhci, "Babble error on endpoint\n");
                 status = -EOVERFLOW;
                 break;
         case COMP_DB_ERR:
@@ -2390,17 +2397,7 @@ hw_died:
 
 irqreturn_t xhci_msi_irq(int irq, struct usb_hcd *hcd)
 {
-        irqreturn_t ret;
-        struct xhci_hcd *xhci;
-
-        xhci = hcd_to_xhci(hcd);
-        set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
-        if (xhci->shared_hcd)
-                set_bit(HCD_FLAG_SAW_IRQ, &xhci->shared_hcd->flags);
-
-        ret = xhci_irq(hcd);
-
-        return ret;
+        return xhci_irq(hcd);
 }
 
 /****           Endpoint Ring Operations        ****/
@@ -2488,11 +2485,6 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
                                 ring->cycle_state = (ring->cycle_state ? 0 : 1);
-                                if (!in_interrupt()) {
-                                        xhci_dbg(xhci, "queue_trb: Toggle cycle "
-                                                "state for ring %p = %i\n",
-                                                ring, (unsigned int)ring->cycle_state);
-                                }
                         }
                         ring->enq_seg = ring->enq_seg->next;
                         ring->enqueue = ring->enq_seg->trbs;
@@ -2561,13 +2553,11 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
         struct scatterlist *sg;
 
         sg = NULL;
-        num_sgs = urb->num_sgs;
+        num_sgs = urb->num_mapped_sgs;
         temp = urb->transfer_buffer_length;
 
-        xhci_dbg(xhci, "count sg list trbs: \n");
         num_trbs = 0;
         for_each_sg(urb->sg, sg, num_sgs, i) {
-                unsigned int previous_total_trbs = num_trbs;
                 unsigned int len = sg_dma_len(sg);
 
                 /* Scatter gather list entries may cross 64KB boundaries */
@@ -2582,22 +2572,11 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
                         num_trbs++;
                         running_total += TRB_MAX_BUFF_SIZE;
                 }
-                xhci_dbg(xhci, " sg #%d: dma = %#llx, len = %#x (%d), num_trbs = %d\n",
-                                i, (unsigned long long)sg_dma_address(sg),
-                                len, len, num_trbs - previous_total_trbs);
-
                 len = min_t(int, len, temp);
                 temp -= len;
                 if (temp == 0)
                         break;
         }
-        xhci_dbg(xhci, "\n");
-        if (!in_interrupt())
-                xhci_dbg(xhci, "ep %#x - urb len = %d, sglist used, "
-                                "num_trbs = %d\n",
-                                urb->ep->desc.bEndpointAddress,
-                                urb->transfer_buffer_length,
-                                num_trbs);
         return num_trbs;
 }
 
@@ -2745,7 +2724,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 return -EINVAL;
 
         num_trbs = count_sg_trbs_needed(xhci, urb);
-        num_sgs = urb->num_sgs;
+        num_sgs = urb->num_mapped_sgs;
         total_packet_count = roundup(urb->transfer_buffer_length,
                         usb_endpoint_maxp(&urb->ep->desc));
 
@@ -2783,8 +2762,6 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         trb_buff_len = min_t(int, trb_buff_len, this_sg_len);
         if (trb_buff_len > urb->transfer_buffer_length)
                 trb_buff_len = urb->transfer_buffer_length;
-        xhci_dbg(xhci, "First length to xfer from 1st sglist entry = %u\n",
-                        trb_buff_len);
 
         first_trb = true;
         /* Queue the first TRB, even if it's zero-length */
@@ -2816,11 +2793,6 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 if (usb_urb_dir_in(urb))
                         field |= TRB_ISP;
 
-                xhci_dbg(xhci, " sg entry: dma = %#x, len = %#x (%d), "
-                                "64KB boundary at %#x, end dma = %#x\n",
-                                (unsigned int) addr, trb_buff_len, trb_buff_len,
-                                (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
-                                (unsigned int) addr + trb_buff_len);
                 if (TRB_MAX_BUFF_SIZE -
                                 (addr & (TRB_MAX_BUFF_SIZE - 1)) < trb_buff_len) {
                         xhci_warn(xhci, "WARN: sg dma xfer crosses 64KB boundaries!\n");
@@ -2926,15 +2898,6 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         }
         /* FIXME: this doesn't deal with URB_ZERO_PACKET - need one more */
 
-        if (!in_interrupt())
-                xhci_dbg(xhci, "ep %#x - urb len = %#x (%d), "
-                                "addr = %#llx, num_trbs = %d\n",
-                                urb->ep->desc.bEndpointAddress,
-                                urb->transfer_buffer_length,
-                                urb->transfer_buffer_length,
-                                (unsigned long long)urb->transfer_dma,
-                                num_trbs);
-
         ret = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
                         num_trbs, urb, 0, false, mem_flags);
@@ -3055,9 +3018,6 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         if (!urb->setup_packet)
                 return -EINVAL;
 
-        if (!in_interrupt())
-                xhci_dbg(xhci, "Queueing ctrl tx for slot id %d, ep %d\n",
-                                slot_id, ep_index);
         /* 1 TRB for setup, 1 for status */
         num_trbs = 2;
         /*
@@ -3249,15 +3209,6 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 return -EINVAL;
         }
 
-        if (!in_interrupt())
-                xhci_dbg(xhci, "ep %#x - urb len = %#x (%d),"
-                                " addr = %#llx, num_tds = %d\n",
-                                urb->ep->desc.bEndpointAddress,
-                                urb->transfer_buffer_length,
-                                urb->transfer_buffer_length,
-                                (unsigned long long)urb->transfer_dma,
-                                num_tds);
-
         start_addr = (u64) urb->transfer_dma;
         start_trb = &ep_ring->enqueue->generic;
         start_cycle = ep_ring->cycle_state;
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index a1afb7c39f7e..6bbe3c3a7111 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -200,14 +200,14 @@ static int xhci_setup_msi(struct xhci_hcd *xhci)
 
         ret = pci_enable_msi(pdev);
         if (ret) {
-                xhci_err(xhci, "failed to allocate MSI entry\n");
+                xhci_dbg(xhci, "failed to allocate MSI entry\n");
                 return ret;
         }
 
         ret = request_irq(pdev->irq, (irq_handler_t)xhci_msi_irq,
                                 0, "xhci_hcd", xhci_to_hcd(xhci));
         if (ret) {
-                xhci_err(xhci, "disable MSI interrupt\n");
+                xhci_dbg(xhci, "disable MSI interrupt\n");
                 pci_disable_msi(pdev);
         }
 
@@ -270,7 +270,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
 
         ret = pci_enable_msix(pdev, xhci->msix_entries, xhci->msix_count);
         if (ret) {
-                xhci_err(xhci, "Failed to enable MSI-X\n");
+                xhci_dbg(xhci, "Failed to enable MSI-X\n");
                 goto free_entries;
         }
 
@@ -286,7 +286,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
         return ret;
 
 disable_msix:
-        xhci_err(xhci, "disable MSI-X interrupt\n");
+        xhci_dbg(xhci, "disable MSI-X interrupt\n");
         xhci_free_irq(xhci);
         pci_disable_msix(pdev);
 free_entries:
@@ -1333,9 +1333,6 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 goto done;
         }
 
-        xhci_dbg(xhci, "Cancel URB %p\n", urb);
-        xhci_dbg(xhci, "Event ring:\n");
-        xhci_debug_ring(xhci, xhci->event_ring);
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
         ep = &xhci->devs[urb->dev->slot_id]->eps[ep_index];
         ep_ring = xhci_urb_to_transfer_ring(xhci, urb);
@@ -1344,12 +1341,18 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 goto done;
         }
 
-        xhci_dbg(xhci, "Endpoint ring:\n");
-        xhci_debug_ring(xhci, ep_ring);
-
         urb_priv = urb->hcpriv;
-
-        for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
+        i = urb_priv->td_cnt;
+        if (i < urb_priv->length)
+                xhci_dbg(xhci, "Cancel URB %p, dev %s, ep 0x%x, "
+                                "starting at offset 0x%llx\n",
+                                urb, urb->dev->devpath,
+                                urb->ep->desc.bEndpointAddress,
+                                (unsigned long long) xhci_trb_virt_to_dma(
+                                        urb_priv->td[i]->start_seg,
+                                        urb_priv->td[i]->first_trb));
+
+        for (; i < urb_priv->length; i++) {
                 td = urb_priv->td[i];
                 list_add_tail(&td->cancelled_td_list, &ep->cancelled_td_list);
         }
@@ -1620,6 +1623,7 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
                 /* FIXME: can we allocate more resources for the HC? */
                 break;
         case COMP_BW_ERR:
+        case COMP_2ND_BW_ERR:
                 dev_warn(&udev->dev, "Not enough bandwidth "
                                 "for new device state.\n");
                 ret = -ENOSPC;
@@ -2796,8 +2800,7 @@ static int xhci_calculate_streams_and_bitmask(struct xhci_hcd *xhci,
                 if (ret < 0)
                         return ret;
 
-                max_streams = USB_SS_MAX_STREAMS(
-                                eps[i]->ss_ep_comp.bmAttributes);
+                max_streams = usb_ss_max_streams(&eps[i]->ss_ep_comp);
                 if (max_streams < (*num_streams - 1)) {
                         xhci_dbg(xhci, "Ep 0x%x only supports %u stream IDs.\n",
                                         eps[i]->desc.bEndpointAddress,
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 3c8fbd2772ea..fb99c8379142 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1033,7 +1033,6 @@ struct xhci_transfer_event {
 /* Invalid Stream ID Error */
 #define COMP_STRID_ERR  34
 /* Secondary Bandwidth Error - may be returned by a Configure Endpoint cmd */
-/* FIXME - check for this */
 #define COMP_2ND_BW_ERR 35
 /* Split Transaction Error */
 #define COMP_SPLIT_ERR  36
@@ -1356,7 +1355,7 @@ static inline unsigned int hcd_index(struct usb_hcd *hcd)
                 return 1;
 }
 
-/* There is one ehci_hci structure per controller */
+/* There is one xhci_hcd structure per controller */
 struct xhci_hcd {
         struct usb_hcd *main_hcd;
         struct usb_hcd *shared_hcd;