58 files changed, 1665 insertions, 669 deletions
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index ab085f12d57..9179076801c 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -578,3 +578,9 @@ config USB_OCTEON_OHCI
 config USB_OCTEON2_COMMON
        bool
        default y if USB_OCTEON_EHCI || USB_OCTEON_OHCI
+config USB_EHCI_ONOFF_FEATURE
+        boolean "EHCI ON/OFF Feature"
+        depends on USB && USB_EHCI_HCD
+        help
+          Enable support for turning EHCI Off and On
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 624a362f2fe..ea6d2e8f659 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -1,6 +1,7 @@
 #
 # Makefile for USB Host Controller Drivers
 #
+GCOV_PROFILE := y
 ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
diff --git a/drivers/usb/host/ehci-ath79.c b/drivers/usb/host/ehci-ath79.c
index aa248c2f2c6..4d2e88d04da 100644
--- a/drivers/usb/host/ehci-ath79.c
+++ b/drivers/usb/host/ehci-ath79.c
@@ -148,7 +148,7 @@ static int ehci_ath79_probe(struct platform_device *pdev)
                return -ENOMEM;
        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, hcd_name)) {
                dev_dbg(&pdev->dev, "controller already in use\n");
diff --git a/drivers/usb/host/ehci-cns3xxx.c b/drivers/usb/host/ehci-cns3xxx.c
index d41745c6f0c..6536abdea6e 100644
--- a/drivers/usb/host/ehci-cns3xxx.c
+++ b/drivers/usb/host/ehci-cns3xxx.c
@@ -107,7 +107,7 @@ static int cns3xxx_ehci_probe(struct platform_device *pdev)
        }
        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/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 40a844c1dbb..3e2ccb0dd25 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -808,7 +808,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
        next += temp;
        temp = scnprintf (next, size, "uframe %04x\n",
-                        ehci_readl(ehci, &ehci->regs->frame_index));
+                        ehci_read_frame_index(ehci));
        size -= temp;
        next += temp;
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index f380bf97e5a..53ca216657d 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -100,7 +100,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
                goto err2;
        }
        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)) {
                dev_dbg(&pdev->dev, "controller already in use\n");
@@ -117,15 +117,12 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
        pdata->regs = hcd->regs;
-        if (pdata->power_budget)
-                hcd->power_budget = pdata->power_budget;
        /*
         * do platform specific init: check the clock, grab/config pins, etc.
         */
        if (pdata->init && pdata->init(pdev)) {
                retval = -ENODEV;
-                goto err3;
+                goto err4;
        }
        /* Enable USB controller, 83xx or 8536 */
@@ -137,30 +134,6 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
        if (retval != 0)
                goto err4;
-#ifdef CONFIG_USB_OTG
-        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
-                struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-                ehci->transceiver = otg_get_transceiver();
-                dev_dbg(&pdev->dev, "hcd=0x%p  ehci=0x%p, transceiver=0x%p\n",
-                        hcd, ehci, ehci->transceiver);
-                if (ehci->transceiver) {
-                        retval = otg_set_host(ehci->transceiver,
-                                              &ehci_to_hcd(ehci)->self);
-                        if (retval) {
-                                if (ehci->transceiver)
-                                        put_device(ehci->transceiver->dev);
-                                goto err4;
-                        }
-                } else {
-                        dev_err(&pdev->dev, "can't find transceiver\n");
-                        retval = -ENODEV;
-                        goto err4;
-                }
-        }
-#endif
        return retval;
      err4:
@@ -191,12 +164,6 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
                               struct platform_device *pdev)
 {
        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        if (ehci->transceiver) {
-                otg_set_host(ehci->transceiver, NULL);
-                put_device(ehci->transceiver->dev);
-        }
        usb_remove_hcd(hcd);
@@ -577,38 +544,6 @@ static struct dev_pm_ops ehci_fsl_pm_ops = {
 #define EHCI_FSL_PM_OPS         NULL
 #endif /* CONFIG_PM */
-#ifdef CONFIG_USB_OTG
-static int ehci_start_port_reset(struct usb_hcd *hcd, unsigned port)
-{
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        u32 status;
-        if (!port)
-                return -EINVAL;
-        port--;
-        /* start port reset before HNP protocol time out */
-        status = readl(&ehci->regs->port_status[port]);
-        if (!(status & PORT_CONNECT))
-                return -ENODEV;
-        /* khubd will finish the reset later */
-        if (ehci_is_TDI(ehci)) {
-                writel(PORT_RESET |
-                       (status & ~(PORT_CSC | PORT_PEC | PORT_OCC)),
-                       &ehci->regs->port_status[port]);
-        } else {
-                writel(PORT_RESET, &ehci->regs->port_status[port]);
-        }
-        return 0;
-}
-#else
-#define ehci_start_port_reset   NULL
-#endif /* CONFIG_USB_OTG */
 static const struct hc_driver ehci_fsl_hc_driver = {
        .description = hcd_name,
        .product_desc = "Freescale On-Chip EHCI Host Controller",
@@ -648,7 +583,6 @@ static const struct hc_driver ehci_fsl_hc_driver = {
        .hub_control = ehci_hub_control,
        .bus_suspend = ehci_bus_suspend,
        .bus_resume = ehci_bus_resume,
-        .start_port_reset = ehci_start_port_reset,
        .relinquish_port = ehci_relinquish_port,
        .port_handed_over = ehci_port_handed_over,
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
index 93b230dc51a..fdfd8c5b639 100644
--- a/drivers/usb/host/ehci-grlib.c
+++ b/drivers/usb/host/ehci-grlib.c
@@ -130,7 +130,7 @@ static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
                return -ENOMEM;
        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, hcd_name)) {
                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index f8030ee928e..1a534c70ea6 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -94,7 +94,8 @@ static const char	hcd_name [] = "ehci_hcd";
 #define EHCI_IAA_MSECS          10              /* arbitrary */
 #define EHCI_IO_JIFFIES         (HZ/10)         /* io watchdog > irq_thresh */
 #define EHCI_ASYNC_JIFFIES      (HZ/20)         /* async idle timeout */
-#define EHCI_SHRINK_FRAMES      5               /* async qh unlink delay */
+#define EHCI_SHRINK_JIFFIES     (DIV_ROUND_UP(HZ, 200) + 1)
+                                                /* 200-ms async qh unlink delay */
 /* Initial IRQ latency:  faster than hw default */
 static int log2_irq_thresh = 0;         // 0 to 6
@@ -114,7 +115,7 @@ MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
 /* for link power management(LPM) feature */
 static unsigned int hird;
 module_param(hird, int, S_IRUGO);
-MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us\n");
+MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
 #define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
@@ -152,10 +153,7 @@ timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
                        break;
                /* case TIMER_ASYNC_SHRINK: */
                default:
-                        /* add a jiffie since we synch against the
+                        t = EHCI_SHRINK_JIFFIES;
-                         * 8 KHz uframe counter.
-                         */
-                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
                        break;
                }
                mod_timer(&ehci->watchdog, t + jiffies);
@@ -205,7 +203,10 @@ static int tdi_in_host_mode (struct ehci_hcd *ehci)
        u32 __iomem     *reg_ptr;
        u32             tmp;
-        reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
+        if (ehci->has_hostpc)
+                reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE_EX);
+        else
+                reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
        tmp = ehci_readl(ehci, reg_ptr);
        return (tmp & 3) == USBMODE_CM_HC;
 }
@@ -279,7 +280,10 @@ static int ehci_reset (struct ehci_hcd *ehci)
        command |= CMD_RESET;
        dbg_cmd (ehci, "reset", command);
-        ehci_writel(ehci, command, &ehci->regs->command);
+#ifdef CONFIG_USB_EHCI_TEGRA
+        if (!ehci->controller_resets_phy)
+#endif
+                ehci_writel(ehci, command, &ehci->regs->command);
        ehci_to_hcd(ehci)->state = HC_STATE_HALT;
        ehci->next_statechange = jiffies;
        retval = handshake (ehci, &ehci->regs->command,
@@ -340,6 +344,7 @@ static void ehci_work(struct ehci_hcd *ehci);
 #include "ehci-mem.c"
 #include "ehci-q.c"
 #include "ehci-sched.c"
+#include "ehci-sysfs.c"
 /*-------------------------------------------------------------------------*/
@@ -524,7 +529,7 @@ static void ehci_stop (struct usb_hcd *hcd)
        ehci_reset (ehci);
        spin_unlock_irq(&ehci->lock);
-        remove_companion_file(ehci);
+        remove_sysfs_files(ehci);
        remove_debug_files (ehci);
        /* root hub is shut down separately (first, when possible) */
@@ -575,6 +580,12 @@ static int ehci_init(struct usb_hcd *hcd)
        hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
        /*
+         * by default set standard 80% (== 100 usec/uframe) max periodic
+         * bandwidth as required by USB 2.0
+         */
+        ehci->uframe_periodic_max = 100;
+        /*
         * hw default: 1K periodic list heads, one per frame.
         * periodic_size can shrink by USBCMD update if hcc_params allows.
         */
@@ -758,7 +769,36 @@ static int ehci_run (struct usb_hcd *hcd)
         * since the class device isn't created that early.
         */
        create_debug_files(ehci);
-        create_companion_file(ehci);
+        create_sysfs_files(ehci);
+        return 0;
+}
+static int __maybe_unused ehci_setup (struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+        ehci->regs = (void __iomem *)ehci->caps +
+            HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        ehci->sbrn = HCD_USB2;
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+        ehci_reset(ehci);
        return 0;
 }
@@ -866,6 +906,9 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                        ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
                        ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
                        mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
+#ifdef CONFIG_USB_EHCI_TEGRA
+                        ehci->controller_remote_wakeup = true;
+#endif
                }
        }
@@ -1161,8 +1204,7 @@ ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
 static int ehci_get_frame (struct usb_hcd *hcd)
 {
        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
+        return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
-                ehci->periodic_size;
 }
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index ea6184bf48d..25ed607aab9 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -27,7 +27,6 @@
 */
 /*-------------------------------------------------------------------------*/
-#include <linux/usb/otg.h>
 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
@@ -285,7 +284,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                        changed = 1;
                }
        }
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
        if (changed && ehci->has_hostpc) {
                spin_unlock_irq(&ehci->lock);
                msleep(5);      /* 5 ms for HCD to enter low-power mode */
@@ -306,7 +305,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                                        "succeeded" : "failed");
                }
        }
+#endif
        /* Apparently some devices need a >= 1-uframe delay here */
        if (ehci->bus_suspended)
                udelay(150);
@@ -343,7 +342,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
        u32                     temp;
        u32                     power_okay;
        int                     i;
-        u8                      resume_needed = 0;
+        unsigned long           resume_needed = 0;
        if (time_before (jiffies, ehci->next_statechange))
                msleep(5);
@@ -416,7 +415,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                if (test_bit(i, &ehci->bus_suspended) &&
                                (temp & PORT_SUSPEND)) {
                        temp |= PORT_RESUME;
-                        resume_needed = 1;
+                        set_bit(i, &resume_needed);
                }
                ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
        }
@@ -431,8 +430,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
        i = HCS_N_PORTS (ehci->hcs_params);
        while (i--) {
                temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
-                if (test_bit(i, &ehci->bus_suspended) &&
+                if (test_bit(i, &resume_needed)) {
-                                (temp & PORT_SUSPEND)) {
                        temp &= ~(PORT_RWC_BITS | PORT_RESUME);
                        ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
                        ehci_vdbg (ehci, "resumed port %d\n", i + 1);
@@ -471,29 +469,6 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 /*-------------------------------------------------------------------------*/
-/* Display the ports dedicated to the companion controller */
-static ssize_t show_companion(struct device *dev,
-                              struct device_attribute *attr,
-                              char *buf)
-{
-        struct ehci_hcd         *ehci;
-        int                     nports, index, n;
-        int                     count = PAGE_SIZE;
-        char                    *ptr = buf;
-        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
-        nports = HCS_N_PORTS(ehci->hcs_params);
-        for (index = 0; index < nports; ++index) {
-                if (test_bit(index, &ehci->companion_ports)) {
-                        n = scnprintf(ptr, count, "%d\n", index + 1);
-                        ptr += n;
-                        count -= n;
-                }
-        }
-        return ptr - buf;
-}
 /*
 * Sets the owner of a port
 */
@@ -528,58 +503,6 @@ static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
        }
 }
-/*
- * Dedicate or undedicate a port to the companion controller.
- * Syntax is "[-]portnum", where a leading '-' sign means
- * return control of the port to the EHCI controller.
- */
-static ssize_t store_companion(struct device *dev,
-                               struct device_attribute *attr,
-                               const char *buf, size_t count)
-{
-        struct ehci_hcd         *ehci;
-        int                     portnum, new_owner;
-        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
-        new_owner = PORT_OWNER;         /* Owned by companion */
-        if (sscanf(buf, "%d", &portnum) != 1)
-                return -EINVAL;
-        if (portnum < 0) {
-                portnum = - portnum;
-                new_owner = 0;          /* Owned by EHCI */
-        }
-        if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
-                return -ENOENT;
-        portnum--;
-        if (new_owner)
-                set_bit(portnum, &ehci->companion_ports);
-        else
-                clear_bit(portnum, &ehci->companion_ports);
-        set_owner(ehci, portnum, new_owner);
-        return count;
-}
-static DEVICE_ATTR(companion, 0644, show_companion, store_companion);
-static inline int create_companion_file(struct ehci_hcd *ehci)
-{
-        int     i = 0;
-        /* with integrated TT there is no companion! */
-        if (!ehci_is_TDI(ehci))
-                i = device_create_file(ehci_to_hcd(ehci)->self.controller,
-                                       &dev_attr_companion);
-        return i;
-}
-static inline void remove_companion_file(struct ehci_hcd *ehci)
-{
-        /* with integrated TT there is no companion! */
-        if (!ehci_is_TDI(ehci))
-                device_remove_file(ehci_to_hcd(ehci)->self.controller,
-                                   &dev_attr_companion);
-}
 /*-------------------------------------------------------------------------*/
 static int check_reset_complete (
@@ -802,13 +725,6 @@ static int ehci_hub_control (
                                goto error;
                        if (ehci->no_selective_suspend)
                                break;
-#ifdef CONFIG_USB_OTG
-                        if ((hcd->self.otg_port == (wIndex + 1))
-                            && hcd->self.b_hnp_enable) {
-                                otg_start_hnp(ehci->transceiver);
-                                break;
-                        }
-#endif
                        if (!(temp & PORT_SUSPEND))
                                break;
                        if ((temp & PORT_PE) == 0)
@@ -891,10 +807,11 @@ static int ehci_hub_control (
                         * power switching; they're allowed to just limit the
                         * current.  khubd will turn the power back on.
                         */
-                        if (HCS_PPC (ehci->hcs_params)){
+                        if ((temp & PORT_OC) && HCS_PPC(ehci->hcs_params)) {
                                ehci_writel(ehci,
                                        temp & ~(PORT_RWC_BITS | PORT_POWER),
                                        status_reg);
+                                temp = ehci_readl(ehci, status_reg);
                        }
                }
@@ -1120,7 +1037,19 @@ static int ehci_hub_control (
                        if (!selector || selector > 5)
                                goto error;
                        ehci_quiesce(ehci);
+                        /* Put all enabled ports into suspend */
+                        while (ports--) {
+                                u32 __iomem *sreg =
+                                                &ehci->regs->port_status[ports];
+                                temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
+                                if (temp & PORT_PE)
+                                        ehci_writel(ehci, temp | PORT_SUSPEND,
+                                                        sreg);
+                        }
                        ehci_halt(ehci);
+                        temp = ehci_readl(ehci, status_reg);
                        temp |= selector << 16;
                        ehci_writel(ehci, temp, status_reg);
                        break;
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 50e600d26e2..c4460f3d009 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -100,7 +100,7 @@ static int ixp4xx_ehci_probe(struct platform_device *pdev)
                goto fail_request_resource;
        }
        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/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index b5a0bf649c9..592d5f76803 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -40,27 +40,9 @@ static int ehci_msm_reset(struct usb_hcd *hcd)
        int retval;
        ehci->caps = USB_CAPLENGTH;
-        ehci->regs = USB_CAPLENGTH +
-                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
-        dbg_hcs_params(ehci, "reset");
-        dbg_hcc_params(ehci, "reset");
-        /* cache the data to minimize the chip reads*/
-        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
        hcd->has_tt = 1;
-        ehci->sbrn = HCD_USB2;
-        retval = ehci_halt(ehci);
-        if (retval)
-                return retval;
-        /* data structure init */
-        retval = ehci_init(hcd);
-        if (retval)
-                return retval;
-        retval = ehci_reset(ehci);
+        retval = ehci_setup(hcd);
        if (retval)
                return retval;
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 0c058be35a3..555a73c864b 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -24,6 +24,7 @@
 #include <linux/usb/ulpi.h>
 #include <linux/slab.h>
+#include <mach/hardware.h>
 #include <mach/mxc_ehci.h>
 #include <asm/mach-types.h>
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index ff55757ba7d..c3ba3ed5f3a 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -124,7 +124,7 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
                return -ENOMEM;
        hcd->rsrc_start = res_mem->start;
-        hcd->rsrc_len = res_mem->end - res_mem->start + 1;
+        hcd->rsrc_len = resource_size(res_mem);
        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
                                OCTEON_EHCI_HCD_NAME)) {
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 55a57c23dd0..45240321ca0 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -98,6 +98,18 @@ static void omap_ehci_soft_phy_reset(struct platform_device *pdev, u8 port)
        }
 }
+static void disable_put_regulator(
+                struct ehci_hcd_omap_platform_data *pdata)
+{
+        int i;
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (pdata->regulator[i]) {
+                        regulator_disable(pdata->regulator[i]);
+                        regulator_put(pdata->regulator[i]);
+                }
+        }
+}
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -231,9 +243,11 @@ err_add_hcd:
        omap_usbhs_disable(dev);
 err_enable:
+        disable_put_regulator(pdata);
        usb_put_hcd(hcd);
 err_io:
+        iounmap(regs);
        return ret;
 }
@@ -253,6 +267,8 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
        usb_remove_hcd(hcd);
        omap_usbhs_disable(dev);
+        disable_put_regulator(dev->platform_data);
+        iounmap(hcd->regs);
        usb_put_hcd(hcd);
        return 0;
 }
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 1102ce65a3a..1d1caa6a33f 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -224,6 +224,11 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                        pci_dev_put(p_smbus);
                }
                break;
+        case PCI_VENDOR_ID_NETMOS:
+                /* MosChip frame-index-register bug */
+                ehci_info(ehci, "applying MosChip frame-index workaround\n");
+                ehci->frame_index_bug = 1;
+                break;
        }
        /* optional debug port, normally in the first BAR */
diff --git a/drivers/usb/host/ehci-pmcmsp.c b/drivers/usb/host/ehci-pmcmsp.c
index cd69099cda1..e8d54de44ac 100644
--- a/drivers/usb/host/ehci-pmcmsp.c
+++ b/drivers/usb/host/ehci-pmcmsp.c
@@ -124,7 +124,7 @@ static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        if (res == NULL)
                return -ENOMEM;
-        res_len = res->end - res->start + 1;
+        res_len = resource_size(res);
        if (!request_mem_region(res->start, res_len, "mab regs"))
                return -EBUSY;
@@ -140,7 +140,7 @@ static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
                retval = -ENOMEM;
                goto err2;
        }
-        res_len = res->end - res->start + 1;
+        res_len = resource_size(res);
        if (!request_mem_region(res->start, res_len, "usbid regs")) {
                retval = -EBUSY;
                goto err2;
@@ -154,13 +154,13 @@ static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
        return 0;
 err3:
        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-        res_len = res->end - res->start + 1;
+        res_len = resource_size(res);
        release_mem_region(res->start, res_len);
 err2:
        iounmap(dev->mab_regs);
 err1:
        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        res_len = res->end - res->start + 1;
+        res_len = resource_size(res);
        release_mem_region(res->start, res_len);
        dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
        return retval;
@@ -194,7 +194,7 @@ int usb_hcd_msp_probe(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, dev->name)) {
                retval = -EBUSY;
                goto err1;
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 8552db6c29c..41d11fe1425 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -130,7 +130,7 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
                return -ENOMEM;
        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, hcd_name)) {
                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 5d6bc624c96..5c25783a764 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -103,7 +103,7 @@ qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd)
        if (!(hw->hw_info1 & cpu_to_hc32(ehci, 1 << 14))) {
                unsigned        is_out, epnum;
-                is_out = !(qtd->hw_token & cpu_to_hc32(ehci, 1 << 8));
+                is_out = qh->is_out;
                epnum = (hc32_to_cpup(ehci, &hw->hw_info1) >> 8) & 0x0f;
                if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) {
                        hw->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE);
@@ -649,7 +649,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);
@@ -946,6 +946,7 @@ done:
        hw = qh->hw;
        hw->hw_info1 = cpu_to_hc32(ehci, info1);
        hw->hw_info2 = cpu_to_hc32(ehci, info2);
+        qh->is_out = !is_input;
        usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1);
        qh_refresh (ehci, qh);
        return qh;
@@ -994,9 +995,16 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
        head->qh_next.qh = qh;
        head->hw->hw_next = dma;
+        /*
+         * flush qh descriptor into memory immediately,
+         * see comments in qh_append_tds.
+         * */
+        ehci_sync_mem();
        qh_get(qh);
        qh->xacterrs = 0;
        qh->qh_state = QH_STATE_LINKED;
+        wmb();
        /* qtd completions reported later by interrupt */
 }
@@ -1081,6 +1089,18 @@ static struct ehci_qh *qh_append_tds (
                        wmb ();
                        dummy->hw_token = token;
+                        /*
+                         * Writing to dma coherent buffer on ARM may
+                         * be delayed to reach memory, so HC may not see
+                         * hw_token of dummy qtd in time, which can cause
+                         * the qtd transaction to be executed very late,
+                         * and degrade performance a lot. ehci_sync_mem
+                         * is added to flush 'token' immediatelly into
+                         * memory, so that ehci can execute the transaction
+                         * ASAP.
+                         * */
+                        ehci_sync_mem();
                        urb->hcpriv = qh_get (qh);
                }
        }
@@ -1231,6 +1251,8 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
        prev->hw->hw_next = qh->hw->hw_next;
        prev->qh_next = qh->qh_next;
+        if (ehci->qh_scan_next == qh)
+                ehci->qh_scan_next = qh->qh_next.qh;
        wmb ();
        /* If the controller isn't running, we don't have to wait for it */
@@ -1256,53 +1278,49 @@ static void scan_async (struct ehci_hcd *ehci)
        struct ehci_qh          *qh;
        enum ehci_timer_action  action = TIMER_IO_WATCHDOG;
-        ehci->stamp = ehci_readl(ehci, &ehci->regs->frame_index);
        timer_action_done (ehci, TIMER_ASYNC_SHRINK);
-rescan:
        stopped = !HC_IS_RUNNING(ehci_to_hcd(ehci)->state);
-        qh = ehci->async->qh_next.qh;
-        if (likely (qh != NULL)) {
-                do {
-                        /* clean any finished work for this qh */
-                        if (!list_empty(&qh->qtd_list) && (stopped ||
-                                        qh->stamp != ehci->stamp)) {
-                                int temp;
-                                /* unlinks could happen here; completion
-                                 * reporting drops the lock.  rescan using
-                                 * the latest schedule, but don't rescan
-                                 * qhs we already finished (no looping)
-                                 * unless the controller is stopped.
-                                 */
-                                qh = qh_get (qh);
-                                qh->stamp = ehci->stamp;
-                                temp = qh_completions (ehci, qh);
-                                if (qh->needs_rescan)
-                                        unlink_async(ehci, qh);
-                                qh_put (qh);
-                                if (temp != 0) {
-                                        goto rescan;
-                                }
-                        }
-                        /* unlink idle entries, reducing DMA usage as well
+        ehci->qh_scan_next = ehci->async->qh_next.qh;
-                         * as HCD schedule-scanning costs.  delay for any qh
+        while (ehci->qh_scan_next) {
-                         * we just scanned, there's a not-unusual case that it
+                qh = ehci->qh_scan_next;
-                         * doesn't stay idle for long.
+                ehci->qh_scan_next = qh->qh_next.qh;
-                         * (plus, avoids some kind of re-activation race.)
+ rescan:
+                /* clean any finished work for this qh */
+                if (!list_empty(&qh->qtd_list)) {
+                        int temp;
+                        /*
+                         * Unlinks could happen here; completion reporting
+                         * drops the lock.  That's why ehci->qh_scan_next
+                         * always holds the next qh to scan; if the next qh
+                         * gets unlinked then ehci->qh_scan_next is adjusted
+                         * in start_unlink_async().
                         */
-                        if (list_empty(&qh->qtd_list)
+                        qh = qh_get(qh);
-                                        && qh->qh_state == QH_STATE_LINKED) {
+                        temp = qh_completions(ehci, qh);
-                                if (!ehci->reclaim && (stopped ||
+                        if (qh->needs_rescan)
-                                        ((ehci->stamp - qh->stamp) & 0x1fff)
+                                unlink_async(ehci, qh);
-                                                >= EHCI_SHRINK_FRAMES * 8))
+                        qh->unlink_time = jiffies + EHCI_SHRINK_JIFFIES;
-                                        start_unlink_async(ehci, qh);
+                        qh_put(qh);
-                                else
+                        if (temp != 0)
-                                        action = TIMER_ASYNC_SHRINK;
+                                goto rescan;
-                        }
+                }
-                        qh = qh->qh_next.qh;
+                /* unlink idle entries, reducing DMA usage as well
-                } while (qh);
+                 * as HCD schedule-scanning costs.  delay for any qh
+                 * we just scanned, there's a not-unusual case that it
+                 * doesn't stay idle for long.
+                 * (plus, avoids some kind of re-activation race.)
+                 */
+                if (list_empty(&qh->qtd_list)
+                                && qh->qh_state == QH_STATE_LINKED) {
+                        if (!ehci->reclaim && (stopped ||
+                                        time_after_eq(jiffies, qh->unlink_time)))
+                                start_unlink_async(ehci, qh);
+                        else
+                                action = TIMER_ASYNC_SHRINK;
+                }
        }
        if (action == TIMER_ASYNC_SHRINK)
                timer_action (ehci, TIMER_ASYNC_SHRINK);
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index e3374c8f7b3..9e77f1c8bdb 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -86,6 +86,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
                goto fail_hcd;
        }
+        s5p_ehci->hcd = hcd;
        s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
        if (IS_ERR(s5p_ehci->clk)) {
@@ -189,6 +190,100 @@ static void s5p_ehci_shutdown(struct platform_device *pdev)
                hcd->driver->shutdown(hcd);
 }
+#ifdef CONFIG_PM
+static int s5p_ehci_suspend(struct device *dev)
+{
+        struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
+        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);
+        if (pdata && pdata->phy_exit)
+                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+        return rc;
+}
+static int s5p_ehci_resume(struct device *dev)
+{
+        struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
+        if (pdata && pdata->phy_init)
+                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+        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 (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;
+        }
+        usb_root_hub_lost_power(hcd->self.root_hub);
+        (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);
+        hcd->state = HC_STATE_SUSPENDED;
+        return 0;
+}
+#else
+#define s5p_ehci_suspend        NULL
+#define s5p_ehci_resume         NULL
+#endif
+static const struct dev_pm_ops s5p_ehci_pm_ops = {
+        .suspend        = s5p_ehci_suspend,
+        .resume         = s5p_ehci_resume,
+};
 static struct platform_driver s5p_ehci_driver = {
        .probe          = s5p_ehci_probe,
        .remove         = __devexit_p(s5p_ehci_remove),
@@ -196,6 +291,7 @@ static struct platform_driver s5p_ehci_driver = {
        .driver = {
                .name   = "s5p-ehci",
                .owner  = THIS_MODULE,
+                .pm     = &s5p_ehci_pm_ops,
        }
 };
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 6c9fbe352f7..c787af2ba4b 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -36,6 +36,27 @@
 static int ehci_get_frame (struct usb_hcd *hcd);
+#ifdef CONFIG_PCI
+static unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
+{
+        unsigned uf;
+        /*
+         * The MosChip MCS9990 controller updates its microframe counter
+         * a little before the frame counter, and occasionally we will read
+         * the invalid intermediate value.  Avoid problems by checking the
+         * microframe number (the low-order 3 bits); if they are 0 then
+         * re-read the register to get the correct value.
+         */
+        uf = ehci_readl(ehci, &ehci->regs->frame_index);
+        if (unlikely(ehci->frame_index_bug && ((uf & 7) == 0)))
+                uf = ehci_readl(ehci, &ehci->regs->frame_index);
+        return uf;
+}
+#endif
 /*-------------------------------------------------------------------------*/
 /*
@@ -172,7 +193,7 @@ periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
                }
        }
 #ifdef  DEBUG
-        if (usecs > 100)
+        if (usecs > ehci->uframe_periodic_max)
                ehci_err (ehci, "uframe %d sched overrun: %d usecs\n",
                        frame * 8 + uframe, usecs);
 #endif
@@ -482,7 +503,7 @@ static int enable_periodic (struct ehci_hcd *ehci)
        ehci_to_hcd(ehci)->state = HC_STATE_RUNNING;
        /* make sure ehci_work scans these */
-        ehci->next_uframe = ehci_readl(ehci, &ehci->regs->frame_index)
+        ehci->next_uframe = ehci_read_frame_index(ehci)
                % (ehci->periodic_size << 3);
        if (unlikely(ehci->broken_periodic))
                ehci->last_periodic_enable = ktime_get_real();
@@ -709,11 +730,8 @@ static int check_period (
        if (uframe >= 8)
                return 0;
-        /*
+        /* convert "usecs we need" to "max already claimed" */
-         * 80% periodic == 100 usec/uframe available
+        usecs = ehci->uframe_periodic_max - usecs;
-         * convert "usecs we need" to "max already claimed"
-         */
-        usecs = 100 - usecs;
        /* we "know" 2 and 4 uframe intervals were rejected; so
         * for period 0, check _every_ microframe in the schedule.
@@ -1286,9 +1304,9 @@ itd_slot_ok (
 {
        uframe %= period;
        do {
-                /* can't commit more than 80% periodic == 100 usec */
+                /* can't commit more than uframe_periodic_max usec */
                if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)
-                                > (100 - usecs))
+                                > (ehci->uframe_periodic_max - usecs))
                        return 0;
                /* we know urb->interval is 2^N uframes */
@@ -1345,7 +1363,7 @@ sitd_slot_ok (
 #endif
                /* check starts (OUT uses more than one) */
-                max_used = 100 - stream->usecs;
+                max_used = ehci->uframe_periodic_max - stream->usecs;
                for (tmp = stream->raw_mask & 0xff; tmp; tmp >>= 1, uf++) {
                        if (periodic_usecs (ehci, frame, uf) > max_used)
                                return 0;
@@ -1354,7 +1372,7 @@ sitd_slot_ok (
                /* for IN, check CSPLIT */
                if (stream->c_usecs) {
                        uf = uframe & 7;
-                        max_used = 100 - stream->c_usecs;
+                        max_used = ehci->uframe_periodic_max - stream->c_usecs;
                        do {
                                tmp = 1 << uf;
                                tmp <<= 8;
@@ -1412,7 +1430,7 @@ iso_stream_schedule (
                goto fail;
        }
-        now = ehci_readl(ehci, &ehci->regs->frame_index) & (mod - 1);
+        now = ehci_read_frame_index(ehci) & (mod - 1);
        /* Typical case: reuse current schedule, stream is still active.
         * Hopefully there are no gaps from the host falling behind
@@ -1458,30 +1476,36 @@ iso_stream_schedule (
         * jump until after the queue is primed.
         */
        else {
+                int done = 0;
                start = SCHEDULE_SLOP + (now & ~0x07);
                /* NOTE:  assumes URB_ISO_ASAP, to limit complexity/bugs */
-                /* find a uframe slot with enough bandwidth */
+                /* find a uframe slot with enough bandwidth.
-                next = start + period;
+                 * Early uframes are more precious because full-speed
-                for (; start < next; start++) {
+                 * iso IN transfers can't use late uframes,
+                 * and therefore they should be allocated last.
+                 */
+                next = start;
+                start += period;
+                do {
+                        start--;
                        /* check schedule: enough space? */
                        if (stream->highspeed) {
                                if (itd_slot_ok(ehci, mod, start,
                                                stream->usecs, period))
-                                        break;
+                                        done = 1;
                        } else {
                                if ((start % 8) >= 6)
                                        continue;
                                if (sitd_slot_ok(ehci, mod, stream,
                                                start, sched, period))
-                                        break;
+                                        done = 1;
                        }
-                }
+                } while (start > next && !done);
                /* no room in the schedule */
-                if (start == next) {
+                if (!done) {
                        ehci_dbg(ehci, "iso resched full %p (now %d max %d)\n",
                                urb, now, now + mod);
                        status = -ENOSPC;
@@ -2279,7 +2303,7 @@ scan_periodic (struct ehci_hcd *ehci)
         */
        now_uframe = ehci->next_uframe;
        if (HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
-                clock = ehci_readl(ehci, &ehci->regs->frame_index);
+                clock = ehci_read_frame_index(ehci);
                clock_frame = (clock >> 3) & (ehci->periodic_size - 1);
        } else  {
                clock = now_uframe + mod - 1;
@@ -2458,8 +2482,7 @@ restart:
                                        || ehci->periodic_sched == 0)
                                break;
                        ehci->next_uframe = now_uframe;
-                        now = ehci_readl(ehci, &ehci->regs->frame_index) &
+                        now = ehci_read_frame_index(ehci) & (mod - 1);
-                                        (mod - 1);
                        if (now_uframe == now)
                                break;
diff --git a/drivers/usb/host/ehci-sysfs.c b/drivers/usb/host/ehci-sysfs.c
new file mode 100644
index 00000000000..14ced00ba22
--- /dev/null
+++ b/drivers/usb/host/ehci-sysfs.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2007 by Alan Stern
+ *
+ * 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.
+ */
+/* this file is part of ehci-hcd.c */
+/* Display the ports dedicated to the companion controller */
+static ssize_t show_companion(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        struct ehci_hcd         *ehci;
+        int                     nports, index, n;
+        int                     count = PAGE_SIZE;
+        char                    *ptr = buf;
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        nports = HCS_N_PORTS(ehci->hcs_params);
+        for (index = 0; index < nports; ++index) {
+                if (test_bit(index, &ehci->companion_ports)) {
+                        n = scnprintf(ptr, count, "%d\n", index + 1);
+                        ptr += n;
+                        count -= n;
+                }
+        }
+        return ptr - buf;
+}
+/*
+ * Dedicate or undedicate a port to the companion controller.
+ * Syntax is "[-]portnum", where a leading '-' sign means
+ * return control of the port to the EHCI controller.
+ */
+static ssize_t store_companion(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ehci_hcd         *ehci;
+        int                     portnum, new_owner;
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        new_owner = PORT_OWNER;         /* Owned by companion */
+        if (sscanf(buf, "%d", &portnum) != 1)
+                return -EINVAL;
+        if (portnum < 0) {
+                portnum = - portnum;
+                new_owner = 0;          /* Owned by EHCI */
+        }
+        if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
+                return -ENOENT;
+        portnum--;
+        if (new_owner)
+                set_bit(portnum, &ehci->companion_ports);
+        else
+                clear_bit(portnum, &ehci->companion_ports);
+        set_owner(ehci, portnum, new_owner);
+        return count;
+}
+static DEVICE_ATTR(companion, 0644, show_companion, store_companion);
+/*
+ * Display / Set uframe_periodic_max
+ */
+static ssize_t show_uframe_periodic_max(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        struct ehci_hcd         *ehci;
+        int                     n;
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        n = scnprintf(buf, PAGE_SIZE, "%d\n", ehci->uframe_periodic_max);
+        return n;
+}
+static ssize_t store_uframe_periodic_max(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ehci_hcd         *ehci;
+        unsigned                uframe_periodic_max;
+        unsigned                frame, uframe;
+        unsigned short          allocated_max;
+        unsigned long           flags;
+        ssize_t                 ret;
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        if (kstrtouint(buf, 0, &uframe_periodic_max) < 0)
+                return -EINVAL;
+        if (uframe_periodic_max < 100 || uframe_periodic_max >= 125) {
+                ehci_info(ehci, "rejecting invalid request for "
+                                "uframe_periodic_max=%u\n", uframe_periodic_max);
+                return -EINVAL;
+        }
+        ret = -EINVAL;
+        /*
+         * lock, so that our checking does not race with possible periodic
+         * bandwidth allocation through submitting new urbs.
+         */
+        spin_lock_irqsave (&ehci->lock, flags);
+        /*
+         * for request to decrease max periodic bandwidth, we have to check
+         * every microframe in the schedule to see whether the decrease is
+         * possible.
+         */
+        if (uframe_periodic_max < ehci->uframe_periodic_max) {
+                allocated_max = 0;
+                for (frame = 0; frame < ehci->periodic_size; ++frame)
+                        for (uframe = 0; uframe < 7; ++uframe)
+                                allocated_max = max(allocated_max,
+                                                    periodic_usecs (ehci, frame, uframe));
+                if (allocated_max > uframe_periodic_max) {
+                        ehci_info(ehci,
+                                "cannot decrease uframe_periodic_max becase "
+                                "periodic bandwidth is already allocated "
+                                "(%u > %u)\n",
+                                allocated_max, uframe_periodic_max);
+                        goto out_unlock;
+                }
+        }
+        /* increasing is always ok */
+        ehci_info(ehci, "setting max periodic bandwidth to %u%% "
+                        "(== %u usec/uframe)\n",
+                        100*uframe_periodic_max/125, uframe_periodic_max);
+        if (uframe_periodic_max != 100)
+                ehci_warn(ehci, "max periodic bandwidth set is non-standard\n");
+        ehci->uframe_periodic_max = uframe_periodic_max;
+        ret = count;
+out_unlock:
+        spin_unlock_irqrestore (&ehci->lock, flags);
+        return ret;
+}
+static DEVICE_ATTR(uframe_periodic_max, 0644, show_uframe_periodic_max, store_uframe_periodic_max);
+static inline int create_sysfs_files(struct ehci_hcd *ehci)
+{
+        struct device   *controller = ehci_to_hcd(ehci)->self.controller;
+        int     i = 0;
+        /* with integrated TT there is no companion! */
+        if (!ehci_is_TDI(ehci))
+                i = device_create_file(controller, &dev_attr_companion);
+        if (i)
+                goto out;
+        i = device_create_file(controller, &dev_attr_uframe_periodic_max);
+out:
+        return i;
+}
+static inline void remove_sysfs_files(struct ehci_hcd *ehci)
+{
+        struct device   *controller = ehci_to_hcd(ehci)->self.controller;
+        /* with integrated TT there is no companion! */
+        if (!ehci_is_TDI(ehci))
+                device_remove_file(controller, &dev_attr_companion);
+        device_remove_file(controller, &dev_attr_uframe_periodic_max);
+}
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 02b2bfd49a1..c6ddcab4640 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -2,7 +2,7 @@
 * EHCI-compliant USB host controller driver for NVIDIA Tegra SoCs
 *
 * Copyright (C) 2010 Google, Inc.
- * Copyright (C) 2009 NVIDIA Corporation
+ * Copyright (C) 2009 - 2011 NVIDIA Corporation
 *
 * 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
@@ -22,40 +22,80 @@
 #include <linux/irq.h>
 #include <linux/usb/otg.h>
 #include <mach/usb_phy.h>
+#include <mach/iomap.h>
+#define TEGRA_USB_PORTSC_PHCD           (1 << 23)
+#define TEGRA_USB_SUSP_CTRL_OFFSET      0x400
+#define TEGRA_USB_SUSP_CLR                      (1 << 5)
+#define TEGRA_USB_PHY_CLK_VALID                 (1 << 7)
+#define TEGRA_USB_SRT                           (1 << 25)
+#define TEGRA_USB_PHY_CLK_VALID_INT_ENB         (1 << 9)
+#define TEGRA_USB_PHY_CLK_VALID_INT_STS         (1 << 8)
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+#define TEGRA_USB_PORTSC1_OFFSET        0x184
+#else
+#define TEGRA_USB_PORTSC1_OFFSET        0x174
+#endif
+#define TEGRA_USB_PORTSC1_WKCN                  (1 << 20)
+#define TEGRA_LVL2_CLK_GATE_OVRB        0xfc
+#define TEGRA_USB2_CLK_OVR_ON                   (1 << 10)
 #define TEGRA_USB_DMA_ALIGN 32
+#define STS_SRI (1<<7)  /*      SOF Recieved    */
+#define HOSTPC_REG_OFFSET               0x1b4
+#define HOSTPC1_DEVLC_STS               (1 << 28)
+#define HOSTPC1_DEVLC_PTS(x)            (((x) & 0x7) << 29)
+#define USB1_PREFETCH_ID               6
+#define USB2_PREFETCH_ID               18
+#define USB3_PREFETCH_ID               17
 struct tegra_ehci_hcd {
        struct ehci_hcd *ehci;
        struct tegra_usb_phy *phy;
        struct clk *clk;
        struct clk *emc_clk;
+        struct clk *sclk_clk;
        struct otg_transceiver *transceiver;
        int host_resumed;
        int bus_suspended;
        int port_resuming;
        int power_down_on_bus_suspend;
+        int default_enable;
        enum tegra_usb_phy_port_speed port_speed;
+        struct work_struct clk_timer_work;
+        struct timer_list clk_timer;
+        bool clock_enabled;
+        bool timer_event;
+        struct mutex tegra_ehci_hcd_mutex;
+        unsigned int irq;
+        bool bus_suspended_fail;
 };
-static void tegra_ehci_power_up(struct usb_hcd *hcd)
+static void tegra_ehci_power_up(struct usb_hcd *hcd, bool is_dpd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
-        clk_enable(tegra->emc_clk);
+        if (!tegra->default_enable)
-        clk_enable(tegra->clk);
+                clk_enable(tegra->clk);
-        tegra_usb_phy_power_on(tegra->phy);
+        tegra_usb_phy_power_on(tegra->phy, is_dpd);
        tegra->host_resumed = 1;
 }
-static void tegra_ehci_power_down(struct usb_hcd *hcd)
+static void tegra_ehci_power_down(struct usb_hcd *hcd, bool is_dpd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
        tegra->host_resumed = 0;
-        tegra_usb_phy_power_off(tegra->phy);
+        tegra_usb_phy_power_off(tegra->phy, is_dpd);
-        clk_disable(tegra->clk);
+        if (!tegra->default_enable)
-        clk_disable(tegra->emc_clk);
+                clk_disable(tegra->clk);
 }
 static int tegra_ehci_internal_port_reset(
@@ -123,6 +163,69 @@ static int tegra_ehci_internal_port_reset(
        return retval;
 }
+static irqreturn_t tegra_ehci_irq (struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci (hcd);
+        struct ehci_regs __iomem *hw = ehci->regs;
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        u32 val;
+        irqreturn_t irq_status;
+        bool pmc_remote_wakeup = false;
+        /* Fence read for coherency of AHB master intiated writes */
+        if (tegra->phy->instance == 0)
+                readb(IO_ADDRESS(IO_PPCS_PHYS + USB1_PREFETCH_ID));
+        else if (tegra->phy->instance == 1)
+                readb(IO_ADDRESS(IO_PPCS_PHYS + USB2_PREFETCH_ID));
+        else if (tegra->phy->instance == 2)
+                readb(IO_ADDRESS(IO_PPCS_PHYS + USB3_PREFETCH_ID));
+        if ((tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) &&
+                (tegra->ehci->has_hostpc)) {
+                /* check if there is any remote wake event */
+                if (tegra_usb_phy_is_remotewake_detected(tegra->phy)) {
+                        pmc_remote_wakeup = true;
+                        spin_lock (&ehci->lock);
+                        usb_hcd_resume_root_hub(hcd);
+                        spin_unlock (&ehci->lock);
+                }
+        }
+        if (tegra->phy->hotplug) {
+                spin_lock(&ehci->lock);
+                val = readl(hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET);
+                if ((val  & TEGRA_USB_PHY_CLK_VALID_INT_STS)) {
+                        val &= ~TEGRA_USB_PHY_CLK_VALID_INT_ENB |
+                                TEGRA_USB_PHY_CLK_VALID_INT_STS;
+                        writel(val , (hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET));
+                        val = readl(&hw->status);
+                        if (!(val  & STS_PCD)) {
+                                spin_unlock(&ehci->lock);
+                                return 0;
+                        }
+                        val = readl(hcd->regs + TEGRA_USB_PORTSC1_OFFSET);
+                        val &= ~(TEGRA_USB_PORTSC1_WKCN | PORT_RWC_BITS);
+                        writel(val , (hcd->regs + TEGRA_USB_PORTSC1_OFFSET));
+                }
+                spin_unlock(&ehci->lock);
+        }
+        irq_status = ehci_irq(hcd);
+        if (pmc_remote_wakeup) {
+                ehci->controller_remote_wakeup = false;
+        }
+        if (ehci->controller_remote_wakeup) {
+                ehci->controller_remote_wakeup = false;
+                /* disable interrupts */
+                ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+                tegra_usb_phy_preresume(tegra->phy, true);
+                tegra->port_resuming = 1;
+        }
+        return irq_status;
+}
 static int tegra_ehci_hub_control(
        struct usb_hcd  *hcd,
        u16             typeReq,
@@ -133,11 +236,27 @@ static int tegra_ehci_hub_control(
 )
 {
        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        int             ports = HCS_N_PORTS(ehci->hcs_params);
+        u32             temp, status;
        u32 __iomem     *status_reg;
-        u32             temp;
+        u32             usbsts_reg;
        unsigned long   flags;
        int             retval = 0;
+        unsigned        selector;
+        struct          tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        bool            hsic = false;
+        bool do_post_resume = false;
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
+        if (!tegra->host_resumed) {
+                if (buf)
+                        memset (buf, 0, wLength);
+                mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
+                return retval;
+        }
+        hsic = (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_HSIC);
        status_reg = &ehci->regs->port_status[(wIndex & 0xff) - 1];
@@ -152,18 +271,35 @@ static int tegra_ehci_hub_control(
                temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
                ehci_writel(ehci, temp & ~PORT_PE, status_reg);
                goto done;
-        }
+        } else if (typeReq == GetPortStatus) {
-        else if (typeReq == GetPortStatus) {
                temp = ehci_readl(ehci, status_reg);
-                if (tegra->port_resuming && !(temp & PORT_SUSPEND)) {
+                if (tegra->port_resuming && !(temp & PORT_SUSPEND) &&
-                        /* Resume completed, re-enable disconnect detection */
+                        time_after_eq(jiffies, ehci->reset_done[wIndex-1])) {
+                        clear_bit((wIndex & 0xff) - 1, &ehci->suspended_ports);
+                        ehci->reset_done[wIndex-1] = 0;
+                        do_post_resume = true;
+                } else if (tegra->port_resuming && (temp & PORT_RESUME) &&
+                        time_after_eq(jiffies, ehci->reset_done[wIndex-1]) ) {
+                        do_post_resume = true;
+                }
+                if (do_post_resume) {
                        tegra->port_resuming = 0;
-                        tegra_usb_phy_postresume(tegra->phy);
+                        tegra_usb_phy_postresume(tegra->phy, false);
+                        if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) {
+                                ehci->command |= CMD_RUN;
+                                /*
+                                 * ehci run bit is disabled to avoid SOF.
+                                 * 2LS WAR is executed by now enable the run bit.
+                                 */
+                                ehci_writel(ehci, ehci->command,
+                                        &ehci->regs->command);
+                                /* Now we can safely re-enable irqs */
+                                ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
+                        }
                }
-        }
-        else if (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_SUSPEND) {
+        } else if (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_SUSPEND) {
                temp = ehci_readl(ehci, status_reg);
                if ((temp & PORT_PE) == 0 || (temp & PORT_RESET) != 0) {
                        retval = -EPIPE;
@@ -174,6 +310,9 @@ static int tegra_ehci_hub_control(
                temp |= PORT_WKDISC_E | PORT_WKOC_E;
                ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+                /* Need a 4ms delay before the controller goes to suspend */
+                mdelay(4);
                /*
                 * If a transaction is in progress, there may be a delay in
                 * suspending the port. Poll until the port is suspended.
@@ -183,6 +322,16 @@ static int tegra_ehci_hub_control(
                        pr_err("%s: timeout waiting for SUSPEND\n", __func__);
                set_bit((wIndex & 0xff) - 1, &ehci->suspended_ports);
+                if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) {
+                        /* Disable RUN bit. */
+                        ehci->command &= ~CMD_RUN;
+                        ehci_writel(ehci, ehci->command,
+                                &ehci->regs->command);
+                }
+                tegra_usb_phy_postsuspend(tegra->phy, false);
                goto done;
        }
@@ -190,6 +339,7 @@ static int tegra_ehci_hub_control(
        if (tegra->phy->instance == 0 &&
           (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_RESET)) {
                spin_unlock_irqrestore(&ehci->lock, flags);
+                mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
                return tegra_ehci_internal_port_reset(ehci, status_reg);
        }
@@ -211,108 +361,257 @@ static int tegra_ehci_hub_control(
                if (!(temp & PORT_SUSPEND))
                        goto done;
+                tegra->port_resuming = 1;
+                if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) {
+                        /* disable interrupts */
+                        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+                        /* Disable RUN bit. */
+                        ehci->command &= ~CMD_RUN;
+                        ehci_writel(ehci, ehci->command,
+                                &ehci->regs->command);
+                }
                /* Disable disconnect detection during port resume */
-                tegra_usb_phy_preresume(tegra->phy);
+                tegra_usb_phy_preresume(tegra->phy, false);
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+                if (tegra->phy->usb_phy_type != TEGRA_USB_PHY_TYPE_UTMIP) {
+#endif
+                ehci_dbg(ehci, "%s:USBSTS = 0x%x", __func__,
+                        ehci_readl(ehci, &ehci->regs->status));
+                usbsts_reg = ehci_readl(ehci, &ehci->regs->status);
+                ehci_writel(ehci, usbsts_reg, &ehci->regs->status);
+                usbsts_reg = ehci_readl(ehci, &ehci->regs->status);
+                udelay(20);
-                ehci->reset_done[wIndex-1] = jiffies + msecs_to_jiffies(25);
+                if (handshake(ehci, &ehci->regs->status, STS_SRI, STS_SRI, 2000))
+                        pr_err("%s: timeout set for STS_SRI\n", __func__);
+                usbsts_reg = ehci_readl(ehci, &ehci->regs->status);
+                ehci_writel(ehci, usbsts_reg, &ehci->regs->status);
+                if (handshake(ehci, &ehci->regs->status, STS_SRI, 0, 2000))
+                        pr_err("%s: timeout clear STS_SRI\n", __func__);
+                if (handshake(ehci, &ehci->regs->status, STS_SRI, STS_SRI, 2000))
+                        pr_err("%s: timeout set STS_SRI\n", __func__);
+                udelay(20);
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+                }
+#endif
                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
-                /* start resume signalling */
+                /* start resume signaling */
                ehci_writel(ehci, temp | PORT_RESUME, status_reg);
-                spin_unlock_irqrestore(&ehci->lock, flags);
+                ehci->reset_done[wIndex-1] = jiffies + msecs_to_jiffies(25);
-                msleep(20);
+                /* whoever resumes must GetPortStatus to complete it!! */
-                spin_lock_irqsave(&ehci->lock, flags);
+                goto done;
+        }
-                /* Poll until the controller clears RESUME and SUSPEND */
-                if (handshake(ehci, status_reg, PORT_RESUME, 0, 2000))
-                        pr_err("%s: timeout waiting for RESUME\n", __func__);
-                if (handshake(ehci, status_reg, PORT_SUSPEND, 0, 2000))
-                        pr_err("%s: timeout waiting for SUSPEND\n", __func__);
-                ehci->reset_done[wIndex-1] = 0;
+        /* Handle port reset here */
+        if ((hsic) && (typeReq == SetPortFeature) &&
+                ((wValue == USB_PORT_FEAT_RESET) || (wValue == USB_PORT_FEAT_POWER))) {
+                selector = wIndex >> 8;
+                wIndex &= 0xff;
+                if (!wIndex || wIndex > ports) {
+                        retval = -EPIPE;
+                        goto done;
+                }
+                wIndex--;
+                status = 0;
+                temp = ehci_readl(ehci, status_reg);
+                if (temp & PORT_OWNER)
+                        goto done;
+                temp &= ~PORT_RWC_BITS;
+                switch (wValue) {
+                case USB_PORT_FEAT_RESET:
+                {
+                        if (temp & PORT_RESUME) {
+                                retval = -EPIPE;
+                                goto done;
+                        }
+                        /* line status bits may report this as low speed,
+                        * which can be fine if this root hub has a
+                        * transaction translator built in.
+                        */
+                        if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
+                                        && !ehci_is_TDI(ehci) && PORT_USB11 (temp)) {
+                                ehci_dbg (ehci, "port %d low speed --> companion\n", wIndex + 1);
+                                temp |= PORT_OWNER;
+                                ehci_writel(ehci, temp, status_reg);
+                        } else {
+                                ehci_vdbg(ehci, "port %d reset\n", wIndex + 1);
+                                temp &= ~PORT_PE;
+                                /*
+                                * caller must wait, then call GetPortStatus
+                                * usb 2.0 spec says 50 ms resets on root
+                                */
+                                ehci->reset_done[wIndex] = jiffies + msecs_to_jiffies(50);
+                                ehci_writel(ehci, temp, status_reg);
+                                if (hsic && (wIndex == 0))
+                                        tegra_usb_phy_bus_reset(tegra->phy);
+                        }
-                tegra->port_resuming = 1;
+                        break;
+                }
+                case USB_PORT_FEAT_POWER:
+                {
+                        if (HCS_PPC(ehci->hcs_params))
+                                ehci_writel(ehci, temp | PORT_POWER, status_reg);
+                        if (hsic && (wIndex == 0))
+                                tegra_usb_phy_bus_connect(tegra->phy);
+                        break;
+                }
+                }
                goto done;
        }
        spin_unlock_irqrestore(&ehci->lock, flags);
        /* Handle the hub control events here */
-        return ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        retval = ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
+        return retval;
 done:
        spin_unlock_irqrestore(&ehci->lock, flags);
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
        return retval;
 }
-static void tegra_ehci_restart(struct usb_hcd *hcd)
+#ifdef CONFIG_PM
+static void tegra_ehci_restart(struct usb_hcd *hcd, bool is_dpd)
 {
        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        unsigned int temp;
+        ehci->controller_resets_phy = 0;
+        tegra_ehci_pre_reset(tegra->phy, false);
        ehci_reset(ehci);
+        tegra_ehci_post_reset(tegra->phy, false);
+        if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_NULL_ULPI)
+                ehci->controller_resets_phy = 1;
        /* setup the frame list and Async q heads */
        ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
        ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
        /* setup the command register and set the controller in RUN mode */
        ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
-        ehci->command |= CMD_RUN;
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+        /* dont start RS here for HSIC, it will be set by bus_reset */
+        if (tegra->phy->usb_phy_type != TEGRA_USB_PHY_TYPE_HSIC)
+#endif
+                ehci->command |= CMD_RUN;
        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        /* Enable the root Port Power */
+        if (HCS_PPC(ehci->hcs_params)) {
+                temp = ehci_readl(ehci, &ehci->regs->port_status[0]);
+                ehci_writel(ehci, temp | PORT_POWER, &ehci->regs->port_status[0]);
+        }
        down_write(&ehci_cf_port_reset_rwsem);
+        if(is_dpd)
+                hcd->state = HC_STATE_SUSPENDED;
+        else
+                hcd->state = HC_STATE_RUNNING;
        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
        /* flush posted writes */
        ehci_readl(ehci, &ehci->regs->command);
        up_write(&ehci_cf_port_reset_rwsem);
+        /* Turn On Interrupts */
+        ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
 }
-static int tegra_usb_suspend(struct usb_hcd *hcd)
+static int tegra_usb_suspend(struct usb_hcd *hcd, bool is_dpd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
        struct ehci_regs __iomem *hw = tegra->ehci->regs;
        unsigned long flags;
+        int hsic = 0;
+        hsic = (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_HSIC);
        spin_lock_irqsave(&tegra->ehci->lock, flags);
-        tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
+        if (tegra->ehci->has_hostpc)
+                tegra->port_speed = (readl(hcd->regs + HOSTPC_REG_OFFSET) >> 25) & 0x3;
+        else
+                tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
        ehci_halt(tegra->ehci);
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+        if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) {
+                /*
+                 * Ehci run bit is disabled by now read this into command variable
+                 * so that bus resume will not enable run bit immedialty.
+                 * this is required for 2LS WAR on UTMIP interface.
+                 */
+                tegra->ehci->command = ehci_readl(tegra->ehci,
+                                                &tegra->ehci->regs->command);
+        }
+#endif
        spin_unlock_irqrestore(&tegra->ehci->lock, flags);
-        tegra_ehci_power_down(hcd);
+        tegra_ehci_power_down(hcd, is_dpd);
        return 0;
 }
-static int tegra_usb_resume(struct usb_hcd *hcd)
+static int tegra_usb_resume(struct usb_hcd *hcd, bool is_dpd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        struct usb_device *udev = hcd->self.root_hub;
        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
        struct ehci_regs __iomem *hw = ehci->regs;
        unsigned long val;
+        bool hsic;
+        bool null_ulpi;
+        bool utmip_remote_wakeup = false;
+        null_ulpi = (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_NULL_ULPI);
+        hsic = (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_HSIC);
+        tegra_ehci_power_up(hcd, is_dpd);
        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        tegra_ehci_power_up(hcd);
-        if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
+        if ((tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) || (hsic) ||
-                /* Wait for the phy to detect new devices
+            (null_ulpi))
-                 * before we restart the controller */
-                msleep(10);
                goto restart;
-        }
        /* Force the phy to keep data lines in suspend state */
        tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
+        if ((tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) &&
+                (tegra->ehci->has_hostpc)) {
+                ehci_reset(ehci);
+        }
        /* Enable host mode */
        tdi_reset(ehci);
+        if ((tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) &&
+                (tegra->ehci->has_hostpc)) {
+                val = readl(hcd->regs + HOSTPC_REG_OFFSET);
+                val &= ~HOSTPC1_DEVLC_PTS(~0);
+                val |= HOSTPC1_DEVLC_STS;
+                writel(val, hcd->regs + HOSTPC_REG_OFFSET);
+        }
        /* Enable Port Power */
        val = readl(&hw->port_status[0]);
        val |= PORT_POWER;
        writel(val, &hw->port_status[0]);
        udelay(10);
+        if ((tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_UTMIP) &&
+                (tegra->ehci->has_hostpc) && (tegra->phy->remote_wakeup)) {
+                utmip_remote_wakeup = true;
+        }
        /* Check if the phy resume from LP0. When the phy resume from LP0
         * USB register will be reset. */
        if (!readl(&hw->async_next)) {
@@ -360,6 +659,9 @@ static int tegra_usb_resume(struct usb_hcd *hcd)
                val |= PORT_SUSPEND;
                writel(val, &hw->port_status[0]);
+                /* Need a 4ms delay before the controller goes to suspend */
+                mdelay(4);
                /* Wait until port suspend completes */
                if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
                                                         PORT_SUSPEND, 1000)) {
@@ -370,31 +672,98 @@ static int tegra_usb_resume(struct usb_hcd *hcd)
        }
        tegra_ehci_phy_restore_end(tegra->phy);
+        if (utmip_remote_wakeup) {
+                ehci->command |= CMD_RUN;
+                ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        }
        return 0;
 restart:
-        if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
+        if (null_ulpi) {
+                bool LP0 = !readl(&hw->async_next);
+                if (LP0) {
+                        static int cnt = 1;
+                        pr_info("LP0 restart %d\n", cnt++);
+                        tegra_ehci_phy_restore_start(tegra->phy,
+                                                     tegra->port_speed);
+                }
+                val = readl(&hw->port_status[0]);
+                if (!((val & PORT_POWER) && (val & PORT_PE))) {
+                        tegra_ehci_restart(hcd, is_dpd);
+                }
+                if (LP0)
+                        tegra_ehci_phy_restore_end(tegra->phy);
+                return 0;
+        }
+        if ((tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH) && (!hsic))
                tegra_ehci_phy_restore_end(tegra->phy);
+        if (hsic) {
+                val = readl(&hw->port_status[0]);
+                if (!((val & PORT_POWER) && (val & PORT_PE)))
+                        tegra_ehci_restart(hcd, false);
+                tegra_usb_phy_bus_idle(tegra->phy);
+                if (!tegra_usb_phy_is_device_connected(tegra->phy))
+                        pr_err("%s: no hsic device conenction\n", __func__);
+        } else {
+                tegra_ehci_restart(hcd, false);
+        }
-        tegra_ehci_restart(hcd);
        return 0;
 }
+#endif
+/*
+ * Disable PHY clock valid interrupts and wait for the interrupt handler to
+ * finish.
+ *
+ * Requires a lock on tegra_ehci_hcd_mutex
+ * Must not be called with a lock on ehci->lock
+ */
+static void tegra_ehci_disable_phy_interrupt(struct usb_hcd *hcd) {
+        struct tegra_ehci_hcd *tegra;
+        u32 val;
+        if (hcd->irq >= 0) {
+                tegra = dev_get_drvdata(hcd->self.controller);
+                if (tegra->phy->hotplug) {
+                        /* Disable PHY clock valid interrupts */
+                        val = readl(hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET);
+                        val &= ~TEGRA_USB_PHY_CLK_VALID_INT_ENB;
+                        writel(val , (hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET));
+                }
+                /* Wait for the interrupt handler to finish */
+                synchronize_irq(hcd->irq);
+        }
+}
 static void tegra_ehci_shutdown(struct usb_hcd *hcd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
+        tegra_ehci_disable_phy_interrupt(hcd);
        /* ehci_shutdown touches the USB controller registers, make sure
         * controller has clocks to it */
        if (!tegra->host_resumed)
-                tegra_ehci_power_up(hcd);
+                tegra_ehci_power_up(hcd, false);
        ehci_shutdown(hcd);
+        /* we are ready to shut down, powerdown the phy */
+        tegra_ehci_power_down(hcd, false);
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
 }
 static int tegra_ehci_setup(struct usb_hcd *hcd)
 {
        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
        int retval;
        /* EHCI registers start at offset 0x100 */
@@ -408,9 +777,15 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
        /* cache this readonly data; minimize chip reads */
        ehci->hcs_params = readl(&ehci->caps->hcs_params);
-        /* switch to host mode */
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+        ehci->has_hostpc = 1;
+#endif
        hcd->has_tt = 1;
-        ehci_reset(ehci);
+        if (tegra->phy->usb_phy_type != TEGRA_USB_PHY_TYPE_NULL_ULPI) {
+                ehci_reset(ehci);
+                tegra_ehci_post_reset(tegra->phy, false);
+        }
        retval = ehci_halt(ehci);
        if (retval)
@@ -422,6 +797,20 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
                return retval;
        ehci->sbrn = 0x20;
+        ehci->controller_remote_wakeup = false;
+        if (tegra->phy->usb_phy_type == TEGRA_USB_PHY_TYPE_NULL_ULPI) {
+                tegra_ehci_pre_reset(tegra->phy, false);
+                ehci_reset(ehci);
+                tegra_ehci_post_reset(tegra->phy, false);
+                /*
+                 * Resetting the controller has the side effect of resetting the PHY.
+                 * So, never reset the controller after the calling
+                 * tegra_ehci_reinit API.
+                 */
+                ehci->controller_resets_phy = 1;
+        }
        ehci_port_power(ehci, 1);
        return retval;
@@ -433,11 +822,21 @@ static int tegra_ehci_bus_suspend(struct usb_hcd *hcd)
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
        int error_status = 0;
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
+        tegra->bus_suspended_fail = false;
+        tegra_ehci_disable_phy_interrupt(hcd);
+        /* ehci_shutdown touches the USB controller registers, make sure
+         * controller has clocks to it */
+        if (!tegra->host_resumed)
+                tegra_ehci_power_up(hcd, false);
        error_status = ehci_bus_suspend(hcd);
+        if (error_status)
+                tegra->bus_suspended_fail = true;
        if (!error_status && tegra->power_down_on_bus_suspend) {
-                tegra_usb_suspend(hcd);
+                tegra_usb_suspend(hcd, false);
                tegra->bus_suspended = 1;
        }
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
        return error_status;
 }
@@ -445,50 +844,45 @@ static int tegra_ehci_bus_suspend(struct usb_hcd *hcd)
 static int tegra_ehci_bus_resume(struct usb_hcd *hcd)
 {
        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        int ehci_bus_resumed;
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
        if (tegra->bus_suspended && tegra->power_down_on_bus_suspend) {
-                tegra_usb_resume(hcd);
+                tegra_usb_resume(hcd, false);
                tegra->bus_suspended = 0;
        }
-        tegra_usb_phy_preresume(tegra->phy);
+        ehci_bus_resumed = ehci_bus_resume(hcd);
-        tegra->port_resuming = 1;
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
-        return ehci_bus_resume(hcd);
+        return ehci_bus_resumed;
 }
 #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 dma_aligned_buffer *temp = container_of(urb->transfer_buffer,
-        struct temp_buffer *temp;
+                struct dma_aligned_buffer, data);
        if (!(urb->transfer_flags & URB_ALIGNED_TEMP_BUFFER))
                return;
-        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+        if(usb_urb_dir_in(urb))
-        temp = container_of(urb->transfer_buffer, struct temp_buffer,
-                            data);
-        if (dir == DMA_FROM_DEVICE)
                memcpy(temp->old_xfer_buffer, temp->data,
                       urb->transfer_buffer_length);
        urb->transfer_buffer = temp->old_xfer_buffer;
        kfree(temp->kmalloc_ptr);
        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 dma_aligned_buffer *temp, *kmalloc_ptr;
-        struct temp_buffer *temp, *kmalloc_ptr;
        size_t kmalloc_size;
        if (urb->num_sgs || urb->sg ||
@@ -496,26 +890,22 @@ 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_in(urb))
                memcpy(temp->data, urb->transfer_buffer,
                       urb->transfer_buffer_length);
        urb->transfer_buffer = temp->data;
        urb->transfer_flags |= URB_ALIGNED_TEMP_BUFFER;
        return 0;
@@ -526,13 +916,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;
 }
@@ -540,7 +930,98 @@ 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);
+}
+void clk_timer_callback(unsigned long data)
+{
+        struct tegra_ehci_hcd *tegra = (struct tegra_ehci_hcd*) data;
+        unsigned long flags;
+        if (!timer_pending(&tegra->clk_timer)) {
+                spin_lock_irqsave(&tegra->ehci->lock, flags);
+                tegra->timer_event = 1;
+                spin_unlock_irqrestore(&tegra->ehci->lock, flags);
+                schedule_work(&tegra->clk_timer_work);
+        }
+}
+static void clk_timer_work_handler(struct work_struct* clk_timer_work) {
+        struct tegra_ehci_hcd *tegra = container_of(clk_timer_work,
+                                                struct tegra_ehci_hcd, clk_timer_work);
+        int ret;
+        unsigned long flags;
+        bool clock_enabled, timer_event;
+        spin_lock_irqsave(&tegra->ehci->lock, flags);
+        clock_enabled = tegra->clock_enabled;
+        timer_event = tegra->timer_event;
+        spin_unlock_irqrestore(&tegra->ehci->lock, flags);
+        if (timer_event) {
+                spin_lock_irqsave(&tegra->ehci->lock, flags);
+                tegra->clock_enabled = 0;
+                tegra->timer_event = 0;
+                spin_unlock_irqrestore(&tegra->ehci->lock, flags);
+                clk_disable(tegra->emc_clk);
+                clk_disable(tegra->sclk_clk);
+                return;
+        }
+        if ((!clock_enabled)) {
+                ret = mod_timer(&tegra->clk_timer, jiffies + msecs_to_jiffies(2000));
+                if (ret)
+                        pr_err("tegra_ehci_urb_enqueue timer modify failed \n");
+                clk_enable(tegra->emc_clk);
+                clk_enable(tegra->sclk_clk);
+                spin_lock_irqsave(&tegra->ehci->lock, flags);
+                tegra->clock_enabled = 1;
+                spin_unlock_irqrestore(&tegra->ehci->lock, flags);
+        } else {
+                if (timer_pending(&tegra->clk_timer)) {
+                        mod_timer_pending (&tegra->clk_timer, jiffies
+                                                + msecs_to_jiffies(2000));
+                }
+        }
+}
+static int tegra_ehci_urb_enqueue (
+        struct usb_hcd  *hcd,
+        struct urb      *urb,
+        gfp_t           mem_flags)
+{
+        struct tegra_ehci_hcd *pdata;
+        int xfertype;
+        int transfer_buffer_length;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        unsigned long flags;
+        pdata = dev_get_drvdata(hcd->self.controller);
+        xfertype = usb_endpoint_type(&urb->ep->desc);
+        transfer_buffer_length = urb->transfer_buffer_length;
+        spin_lock_irqsave(&ehci->lock,flags);
+        /* Turn on the USB busy hints */
+        switch (xfertype) {
+                case USB_ENDPOINT_XFER_INT:
+                if (transfer_buffer_length < 255) {
+                /* Do nothing for interrupt buffers < 255 */
+                } else {
+                        /* signal to set the busy hints */
+                        schedule_work(&pdata->clk_timer_work);
+                }
+                break;
+                case USB_ENDPOINT_XFER_ISOC:
+                case USB_ENDPOINT_XFER_BULK:
+                        /* signal to set the busy hints */
+                        schedule_work(&pdata->clk_timer_work);
+                break;
+                case USB_ENDPOINT_XFER_CONTROL:
+                default:
+                        /* Do nothing special here */
+                break;
+        }
+        spin_unlock_irqrestore(&ehci->lock,flags);
+        return ehci_urb_enqueue(hcd, urb, mem_flags);
 }
 static const struct hc_driver tegra_ehci_hc_driver = {
@@ -551,12 +1032,12 @@ static const struct hc_driver tegra_ehci_hc_driver = {
        .flags                  = HCD_USB2 | HCD_MEMORY,
        .reset                  = tegra_ehci_setup,
-        .irq                    = ehci_irq,
+        .irq                    = tegra_ehci_irq,
        .start                  = ehci_run,
        .stop                   = ehci_stop,
        .shutdown               = tegra_ehci_shutdown,
-        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_enqueue            = tegra_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,
@@ -594,6 +1075,8 @@ static int tegra_ehci_probe(struct platform_device *pdev)
        if (!tegra)
                return -ENOMEM;
+        mutex_init(&tegra->tegra_ehci_hcd_mutex);
        hcd = usb_create_hcd(&tegra_ehci_hc_driver, &pdev->dev,
                                        dev_name(&pdev->dev));
        if (!hcd) {
@@ -603,6 +1086,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
        }
        platform_set_drvdata(pdev, tegra);
+        tegra->default_enable = pdata->default_enable;
        tegra->clk = clk_get(&pdev->dev, NULL);
        if (IS_ERR(tegra->clk)) {
@@ -615,15 +1099,33 @@ static int tegra_ehci_probe(struct platform_device *pdev)
        if (err)
                goto fail_clken;
+        tegra->sclk_clk = clk_get(&pdev->dev, "sclk");
+        if (IS_ERR(tegra->sclk_clk)) {
+                dev_err(&pdev->dev, "Can't get sclk clock\n");
+                err = PTR_ERR(tegra->sclk_clk);
+                goto fail_sclk_clk;
+        }
+        clk_set_rate(tegra->sclk_clk, 80000000);
        tegra->emc_clk = clk_get(&pdev->dev, "emc");
        if (IS_ERR(tegra->emc_clk)) {
                dev_err(&pdev->dev, "Can't get emc clock\n");
                err = PTR_ERR(tegra->emc_clk);
                goto fail_emc_clk;
        }
+        init_timer(&tegra->clk_timer);
-        clk_enable(tegra->emc_clk);
+        tegra->clk_timer.function = clk_timer_callback;
-        clk_set_rate(tegra->emc_clk, 400000000);
+        tegra->clk_timer.data = (unsigned long) tegra;
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+        /* Set DDR busy hints to 150MHz. For Tegra 2x SOC, DDR rate is half of EMC rate */
+        clk_set_rate(tegra->emc_clk, 300000000);
+#else
+        /* Set DDR busy hints to 100MHz. For Tegra 3x SOC DDR rate equals to EMC rate */
+        clk_set_rate(tegra->emc_clk, 100000000);
+#endif
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
@@ -640,15 +1142,18 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                goto fail_io;
        }
+        INIT_WORK(&tegra->clk_timer_work, clk_timer_work_handler);
        tegra->phy = tegra_usb_phy_open(instance, hcd->regs, pdata->phy_config,
-                                                TEGRA_USB_PHY_MODE_HOST);
+                                        TEGRA_USB_PHY_MODE_HOST, pdata->phy_type);
        if (IS_ERR(tegra->phy)) {
                dev_err(&pdev->dev, "Failed to open USB phy\n");
                err = -ENXIO;
                goto fail_phy;
        }
+        tegra->phy->hotplug = pdata->hotplug;
-        err = tegra_usb_phy_power_on(tegra->phy);
+        err = tegra_usb_phy_power_on(tegra->phy, true);
        if (err) {
                dev_err(&pdev->dev, "Failed to power on the phy\n");
                goto fail;
@@ -665,6 +1170,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                goto fail;
        }
        set_irq_flags(irq, IRQF_VALID);
+        tegra->irq = irq;
 #ifdef CONFIG_USB_OTG_UTILS
        if (pdata->operating_mode == TEGRA_USB_OTG) {
@@ -676,10 +1182,19 @@ static int tegra_ehci_probe(struct platform_device *pdev)
        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
        if (err) {
-                dev_err(&pdev->dev, "Failed to add USB HCD\n");
+                dev_err(&pdev->dev, "Failed to add USB HCD error = %d\n", err);
                goto fail;
        }
+        err = enable_irq_wake(tegra->irq);
+        if (err < 0) {
+                dev_warn(&pdev->dev,
+                        "Couldn't enable USB host mode wakeup, irq=%d, "
+                        "error=%d\n", tegra->irq, err);
+                err = 0;
+                tegra->irq = 0;
+        }
        return err;
 fail:
@@ -696,6 +1211,9 @@ fail_io:
        clk_disable(tegra->emc_clk);
        clk_put(tegra->emc_clk);
 fail_emc_clk:
+        clk_disable(tegra->sclk_clk);
+        clk_put(tegra->sclk_clk);
+fail_sclk_clk:
        clk_disable(tegra->clk);
 fail_clken:
        clk_put(tegra->clk);
@@ -711,25 +1229,62 @@ static int tegra_ehci_resume(struct platform_device *pdev)
 {
        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+        int ret;
-        if (tegra->bus_suspended)
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
+        if ((tegra->bus_suspended) && (tegra->power_down_on_bus_suspend)) {
+                if (tegra->default_enable)
+                        clk_enable(tegra->clk);
+                mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
                return 0;
+        }
+        if (tegra->default_enable)
+                clk_enable(tegra->clk);
-        return tegra_usb_resume(hcd);
+        ret = tegra_usb_resume(hcd, true);
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
+        return ret;
 }
 static int tegra_ehci_suspend(struct platform_device *pdev, pm_message_t state)
 {
        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+        int ret;
+        u32 val;
+        mutex_lock(&tegra->tegra_ehci_hcd_mutex);
+        /* if bus suspend is failed means there is remote wakeup resume,
+                then abort the PM suspend */
+        if (tegra->bus_suspended_fail) {
+                tegra->bus_suspended_fail = false;
+                pr_err("%s: bus suspend failed, aborting driver suspend\n", __func__);
+                mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
+                return -EBUSY;
+        }
+        if (tegra->phy->hotplug) {
+                /* Disable PHY clock valid interrupts while going into suspend*/
+                val = readl(hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET);
+                val &= ~TEGRA_USB_PHY_CLK_VALID_INT_ENB;
+                writel(val , (hcd->regs + TEGRA_USB_SUSP_CTRL_OFFSET));
+        }
-        if (tegra->bus_suspended)
+        if ((tegra->bus_suspended) && (tegra->power_down_on_bus_suspend)) {
+                if (tegra->default_enable)
+                        clk_disable(tegra->clk);
+                mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
                return 0;
+        }
        if (time_before(jiffies, tegra->ehci->next_statechange))
                msleep(10);
-        return tegra_usb_suspend(hcd);
+        ret = tegra_usb_suspend(hcd, true);
+        if (tegra->default_enable)
+                clk_disable(tegra->clk);
+        mutex_unlock(&tegra->tegra_ehci_hcd_mutex);
+        return ret;
 }
 #endif
@@ -740,6 +1295,9 @@ static int tegra_ehci_remove(struct platform_device *pdev)
        if (tegra == NULL || hcd == NULL)
                return -EINVAL;
+        /* make sure controller is on as we will touch its registers */
+        if (!tegra->host_resumed)
+                tegra_ehci_power_up(hcd, true);
 #ifdef CONFIG_USB_OTG_UTILS
        if (tegra->transceiver) {
@@ -748,16 +1306,27 @@ static int tegra_ehci_remove(struct platform_device *pdev)
        }
 #endif
+        /* Turn Off Interrupts */
+        ehci_writel(tegra->ehci, 0, &tegra->ehci->regs->intr_enable);
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        if (tegra->irq)
+                disable_irq_wake(tegra->irq);
        usb_remove_hcd(hcd);
        usb_put_hcd(hcd);
+        tegra_usb_phy_power_off(tegra->phy, true);
        tegra_usb_phy_close(tegra->phy);
        iounmap(hcd->regs);
+        del_timer_sync(&tegra->clk_timer);
        clk_disable(tegra->clk);
        clk_put(tegra->clk);
-        clk_disable(tegra->emc_clk);
+        if (tegra->clock_enabled) {
+                clk_disable(tegra->sclk_clk);
+                clk_disable(tegra->emc_clk);
+        }
+        clk_put(tegra->sclk_clk);
        clk_put(tegra->emc_clk);
        kfree(tegra);
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index 52a027aaa37..d661cf7de14 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -41,7 +41,7 @@ static int __devinit usb_w90x900_probe(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, hcd_name)) {
                retval = -EBUSY;
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index a64d6d66d76..32793ce3d9e 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -174,7 +174,7 @@ static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
                return -ENOMEM;
        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, hcd_name)) {
                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index bd6ff489baf..e897262c6a6 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -75,6 +75,7 @@ struct ehci_hcd {			/* one per controller */
        struct ehci_qh          *async;
        struct ehci_qh          *dummy;         /* For AMD quirk use */
        struct ehci_qh          *reclaim;
+        struct ehci_qh          *qh_scan_next;
        unsigned                scanning : 1;
        /* periodic schedule support */
@@ -87,6 +88,8 @@ struct ehci_hcd {			/* one per controller */
        union ehci_shadow       *pshadow;       /* mirror hw periodic table */
        int                     next_uframe;    /* scan periodic, start here */
        unsigned                periodic_sched; /* periodic activity count */
+        unsigned                uframe_periodic_max; /* max periodic time per uframe */
        /* list of itds & sitds completed while clock_frame was still active */
        struct list_head        cached_itd_list;
@@ -117,7 +120,6 @@ struct ehci_hcd {			/* one per controller */
        struct timer_list       iaa_watchdog;
        struct timer_list       watchdog;
        unsigned long           actions;
-        unsigned                stamp;
        unsigned                periodic_stamp;
        unsigned                random_frame;
        unsigned long           next_statechange;
@@ -137,6 +139,11 @@ struct ehci_hcd {			/* one per controller */
        unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
        unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
        unsigned                has_synopsys_hc_bug:1; /* Synopsys HC */
+        unsigned                frame_index_bug:1; /* MosChip (AKA NetMos) */
+#ifdef CONFIG_USB_EHCI_TEGRA
+        unsigned                controller_resets_phy:1;
+        unsigned                controller_remote_wakeup:1;
+#endif
        /* required for usb32 quirk */
        #define OHCI_CTRL_HCFS          (3 << 6)
@@ -163,10 +170,6 @@ struct ehci_hcd {			/* one per controller */
 #ifdef DEBUG
        struct dentry           *debug_dir;
 #endif
-        /*
-         * OTG controllers and transceivers need software interaction
-         */
-        struct otg_transceiver  *transceiver;
 };
 /* convert between an HCD pointer and the corresponding EHCI_HCD */
@@ -343,6 +346,7 @@ struct ehci_qh {
        struct ehci_qh          *reclaim;       /* next to reclaim */
        struct ehci_hcd         *ehci;
+        unsigned long           unlink_time;
        /*
         * Do NOT use atomic operations for QH refcounting. On some CPUs
@@ -374,6 +378,7 @@ struct ehci_qh {
 #define NO_FRAME ((unsigned short)~0)                   /* pick new start */
        struct usb_device       *dev;           /* access to TT */
+        unsigned                is_out:1;       /* bulk or intr OUT */
        unsigned                clearing_tt:1;  /* Clear-TT-Buf in progress */
 };
@@ -736,6 +741,39 @@ static inline u32 hc32_to_cpup (const struct ehci_hcd *ehci, const __hc32 *x)
 /*-------------------------------------------------------------------------*/
+#ifdef CONFIG_PCI
+/* For working around the MosChip frame-index-register bug */
+static unsigned ehci_read_frame_index(struct ehci_hcd *ehci);
+#else
+static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
+{
+        return ehci_readl(ehci, &ehci->regs->frame_index);
+}
+#endif
+/*
+ * Writing to dma coherent memory on ARM may be delayed via L2
+ * writing buffer, so introduce the helper which can flush L2 writing
+ * buffer into memory immediately, especially used to flush ehci
+ * descriptor to memory.
+ * */
+#ifdef  CONFIG_ARM_DMA_MEM_BUFFERABLE
+static inline void ehci_sync_mem()
+{
+        mb();
+}
+#else
+static inline void ehci_sync_mem()
+{
+}
+#endif
+/*-------------------------------------------------------------------------*/
 #ifndef DEBUG
 #define STUB_DEBUG_FILES
 #endif  /* DEBUG */
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 19223c7449e..572ea53b022 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -605,7 +605,7 @@ static int __devinit of_fhci_probe(struct platform_device *ofdev)
                goto err_regs;
        }
-        hcd->regs = ioremap(usb_regs.start, usb_regs.end - usb_regs.start + 1);
+        hcd->regs = ioremap(usb_regs.start, resource_size(&usb_regs));
        if (!hcd->regs) {
                dev_err(dev, "could not ioremap regs\n");
                ret = -ENOMEM;
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index a42ef380e91..2df851b4bc7 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -1,7 +1,7 @@
 /*
 * Freescale QUICC Engine USB Host Controller Driver
 *
- * Copyright (c) Freescale Semicondutor, Inc. 2006.
+ * Copyright (c) Freescale Semicondutor, Inc. 2006, 2011.
 *               Shlomi Gridish <gridish@freescale.com>
 *               Jerry Huang <Chang-Ming.Huang@freescale.com>
 * Copyright (c) Logic Product Development, Inc. 2007
@@ -810,9 +810,11 @@ void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb)
                ed->dev_addr = usb_pipedevice(urb->pipe);
                ed->max_pkt_size = usb_maxpacket(urb->dev, urb->pipe,
                        usb_pipeout(urb->pipe));
+                /* setup stage */
                td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, FHCI_TA_SETUP,
                        USB_TD_TOGGLE_DATA0, urb->setup_packet, 8, 0, 0, true);
+                /* data stage */
                if (data_len > 0) {
                        td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
                                usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
@@ -820,9 +822,18 @@ void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb)
                                USB_TD_TOGGLE_DATA1, data, data_len, 0, 0,
                                true);
                }
-                td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
-                        usb_pipeout(urb->pipe) ? FHCI_TA_IN : FHCI_TA_OUT,
+                /* status stage */
-                        USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
+                if (data_len > 0)
+                        td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
+                                (usb_pipeout(urb->pipe) ? FHCI_TA_IN :
+                                                          FHCI_TA_OUT),
+                                USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
+                else
+                         td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
+                                FHCI_TA_IN,
+                                USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
                urb_state = US_CTRL_SETUP;
                break;
        case FHCI_TF_ISO:
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 55d3d5859ac..840beda66dd 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1583,6 +1583,9 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
        int retval = 0;
        spin_lock_irqsave(&priv->lock, spinflags);
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval)
+                goto out;
        qh = urb->ep->hcpriv;
        if (!qh) {
diff --git a/drivers/usb/host/ohci-ath79.c b/drivers/usb/host/ohci-ath79.c
index ffea3e7cb0a..c620c50f677 100644
--- a/drivers/usb/host/ohci-ath79.c
+++ b/drivers/usb/host/ohci-ath79.c
@@ -93,8 +93,8 @@ static int ohci_ath79_probe(struct platform_device *pdev)
                ret = -ENODEV;
                goto err_put_hcd;
        }
-        hcd->rsrc_start = res->start;
+        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, hcd_name)) {
                dev_dbg(&pdev->dev, "controller already in use\n");
diff --git a/drivers/usb/host/ohci-cns3xxx.c b/drivers/usb/host/ohci-cns3xxx.c
index f05ef87e934..5a00a1e1c6c 100644
--- a/drivers/usb/host/ohci-cns3xxx.c
+++ b/drivers/usb/host/ohci-cns3xxx.c
@@ -100,7 +100,7 @@ static int cns3xxx_ohci_probe(struct platform_device *pdev)
                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-da8xx.c b/drivers/usb/host/ohci-da8xx.c
index d22fb4d577b..6aca2c4453f 100644
--- a/drivers/usb/host/ohci-da8xx.c
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -322,7 +322,7 @@ static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
                goto err2;
        }
        hcd->rsrc_start = mem->start;
-        hcd->rsrc_len = mem->end - mem->start + 1;
+        hcd->rsrc_len = resource_size(mem);
        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                dev_dbg(&pdev->dev, "request_mem_region failed\n");
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index f9cf3f04b74..23107e23053 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -389,17 +389,14 @@ ohci_shutdown (struct usb_hcd *hcd)
        struct ohci_hcd *ohci;
        ohci = hcd_to_ohci (hcd);
-        ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
+        ohci_writel(ohci, (u32) ~0, &ohci->regs->intrdisable);
-        ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
-        /* If the SHUTDOWN quirk is set, don't put the controller in RESET */
+        /* Software reset, after which the controller goes into SUSPEND */
-        ohci->hc_control &= (ohci->flags & OHCI_QUIRK_SHUTDOWN ?
+        ohci_writel(ohci, OHCI_HCR, &ohci->regs->cmdstatus);
-                        OHCI_CTRL_RWC | OHCI_CTRL_HCFS :
+        ohci_readl(ohci, &ohci->regs->cmdstatus);       /* flush the writes */
-                        OHCI_CTRL_RWC);
+        udelay(10);
-        ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
-        /* flush the writes */
+        ohci_writel(ohci, ohci->fminterval, &ohci->regs->fminterval);
-        (void) ohci_readl (ohci, &ohci->regs->control);
 }
 static int check_ed(struct ohci_hcd *ohci, struct ed *ed)
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 9154615292d..2f00040fc40 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -356,10 +356,7 @@ static void ohci_finish_controller_resume(struct usb_hcd *hcd)
                msleep(20);
        }
-        /* Does the root hub have a port wakeup pending? */
+        usb_hcd_resume_root_hub(hcd);
-        if (ohci_readl(ohci, &ohci->regs->intrstatus) &
-                        (OHCI_INTR_RD | OHCI_INTR_RHSC))
-                usb_hcd_resume_root_hub(hcd);
 }
 /* Carry out polling-, autostop-, and autoresume-related state changes */
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
index e4ddfaf8870..d8b45647d1d 100644
--- a/drivers/usb/host/ohci-octeon.c
+++ b/drivers/usb/host/ohci-octeon.c
@@ -135,7 +135,7 @@ static int ohci_octeon_drv_probe(struct platform_device *pdev)
                return -ENOMEM;
        hcd->rsrc_start = res_mem->start;
-        hcd->rsrc_len = res_mem->end - res_mem->start + 1;
+        hcd->rsrc_len = resource_size(res_mem);
        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
                                OCTEON_OHCI_HCD_NAME)) {
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index ad8166c681e..bc01b064585 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -175,28 +175,6 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
        return 0;
 }
-/* nVidia controllers continue to drive Reset signalling on the bus
- * even after system shutdown, wasting power.  This flag tells the
- * shutdown routine to leave the controller OPERATIONAL instead of RESET.
- */
-static int ohci_quirk_nvidia_shutdown(struct usb_hcd *hcd)
-{
-        struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        /* Evidently nVidia fixed their later hardware; this is a guess at
-         * the changeover point.
-         */
-#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB           0x026d
-        if (pdev->device < PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB) {
-                ohci->flags |= OHCI_QUIRK_SHUTDOWN;
-                ohci_dbg(ohci, "enabled nVidia shutdown quirk\n");
-        }
-        return 0;
-}
 static void sb800_prefetch(struct ohci_hcd *ohci, int on)
 {
        struct pci_dev *pdev;
@@ -260,10 +238,6 @@ static const struct pci_device_id ohci_pci_quirks[] = {
                PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4399),
                .driver_data = (unsigned long)ohci_quirk_amd700,
        },
-        {
-                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
-                .driver_data = (unsigned long) ohci_quirk_nvidia_shutdown,
-        },
        /* FIXME for some of the early AMD 760 southbridges, OHCI
         * won't work at all.  blacklist them.
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 1ca1821320f..0c12f4e14dc 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -110,7 +110,7 @@ static int __devinit ohci_hcd_ppc_of_probe(struct platform_device *op)
                return -ENOMEM;
        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, hcd_name)) {
                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 89e670e38c1..c0f595c4448 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -56,7 +56,7 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
        if (!hcd)
                return -ENOMEM;
        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, hcd_name)) {
                pr_debug("%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index d8eb3bdafab..4204d9720d2 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -131,7 +131,7 @@ int usb_hcd_sa1111_probe (const struct hc_driver *driver,
        if (!hcd)
                return -ENOMEM;
        hcd->rsrc_start = dev->res.start;
-        hcd->rsrc_len = dev->res.end - dev->res.start + 1;
+        hcd->rsrc_len = resource_size(&dev->res);
        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                dbg("request_mem_region failed");
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index f47867ff78c..14cecb52a9f 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -3,7 +3,7 @@
 *
 * Copyright (C) 2008 Renesas Solutions Corp.
 *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.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
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 041d30f30c1..78918ca0da2 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -103,8 +103,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
                goto err0;
        }
-        if (!request_mem_region(mem->start, mem->end - mem->start + 1,
+        if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
-                                pdev->name)) {
                dev_err(dev, "request_mem_region failed\n");
                retval = -EBUSY;
                goto err0;
@@ -126,7 +125,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
        if (!dma_declare_coherent_memory(dev, mem->start,
                                         mem->start - mem->parent->start,
-                                         (mem->end - mem->start) + 1,
+                                         resource_size(mem),
                                         DMA_MEMORY_MAP |
                                         DMA_MEMORY_EXCLUSIVE)) {
                dev_err(dev, "cannot declare coherent memory\n");
@@ -149,7 +148,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
        }
        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, pdev->name)) {
                dev_err(dev, "request_mem_region failed\n");
@@ -185,7 +184,7 @@ err3:
 err2:
        dma_release_declared_memory(dev);
 err1:
-        release_mem_region(mem->start, mem->end - mem->start + 1);
+        release_mem_region(mem->start, resource_size(mem));
 err0:
        return retval;
 }
@@ -201,7 +200,7 @@ static int ohci_hcd_sm501_drv_remove(struct platform_device *pdev)
        dma_release_declared_memory(&pdev->dev);
        mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        if (mem)
-                release_mem_region(mem->start, mem->end - mem->start + 1);
+                release_mem_region(mem->start, resource_size(mem));
        /* mask interrupts and disable power */
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
index 48ee6943bf3..c4aea3b8315 100644
--- a/drivers/usb/host/ohci-ssb.c
+++ b/drivers/usb/host/ohci-ssb.c
@@ -2,7 +2,7 @@
 * Sonics Silicon Backplane
 * Broadcom USB-core OHCI driver
 *
- * Copyright 2007 Michael Buesch <mb@bu3sch.de>
+ * Copyright 2007 Michael Buesch <m@bues.ch>
 *
 * Derived from the OHCI-PCI driver
 * Copyright 1999 Roman Weissgaerber
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 3558491dd87..57ad1271fc9 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -208,13 +208,13 @@ static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
        }
        hcd->rsrc_start = regs->start;
-        hcd->rsrc_len = regs->end - regs->start + 1;
+        hcd->rsrc_len = resource_size(regs);
        tmio = hcd_to_tmio(hcd);
        spin_lock_init(&tmio->lock);
-        tmio->ccr = ioremap(config->start, config->end - config->start + 1);
+        tmio->ccr = ioremap(config->start, resource_size(config));
        if (!tmio->ccr) {
                ret = -ENOMEM;
                goto err_ioremap_ccr;
@@ -228,7 +228,7 @@ static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
        if (!dma_declare_coherent_memory(&dev->dev, sram->start,
                                sram->start,
-                                sram->end - sram->start + 1,
+                                resource_size(sram),
                                DMA_MEMORY_MAP | DMA_MEMORY_EXCLUSIVE)) {
                ret = -EBUSY;
                goto err_dma_declare;
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 35e5fd640ce..0795b934d00 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -403,7 +403,6 @@ struct ohci_hcd {
 #define OHCI_QUIRK_HUB_POWER    0x100                   /* distrust firmware power/oc setup */
 #define OHCI_QUIRK_AMD_PLL      0x200                   /* AMD PLL quirk*/
 #define OHCI_QUIRK_AMD_PREFETCH 0x400                   /* pre-fetch for ISO transfer */
-#define OHCI_QUIRK_SHUTDOWN     0x800                   /* nVidia power bug */
        // there are also chip quirks/bugs in init logic
        struct work_struct      nec_work;       /* Worker for NEC quirk */
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 5fbe997dc6d..dcd889803f0 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -3828,7 +3828,7 @@ static int oxu_drv_probe(struct platform_device *pdev)
                return -ENODEV;
        }
        memstart = res->start;
-        memlen = res->end - res->start + 1;
+        memlen = resource_size(res);
        dev_dbg(&pdev->dev, "MEM resource %lx-%lx\n", memstart, memlen);
        if (!request_mem_region(memstart, memlen,
                                oxu_hc_driver.description)) {
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index fd930618c28..23e04fb038b 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -35,6 +35,9 @@
 #define OHCI_INTRSTATUS         0x0c
 #define OHCI_INTRENABLE         0x10
 #define OHCI_INTRDISABLE        0x14
+#define OHCI_FMINTERVAL         0x34
+#define OHCI_HCFS               (3 << 6)        /* hc functional state */
+#define OHCI_HCR                (1 << 0)        /* host controller reset */
 #define OHCI_OCR                (1 << 3)        /* ownership change request */
 #define OHCI_CTRL_RWC           (1 << 9)        /* remote wakeup connected */
 #define OHCI_CTRL_IR            (1 << 8)        /* interrupt routing */
@@ -463,6 +466,8 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
 {
        void __iomem *base;
        u32 control;
+        u32 fminterval;
+        int cnt;
        if (!mmio_resource_enabled(pdev, 0))
                return;
@@ -495,32 +500,63 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
        }
 #endif
-        /* reset controller, preserving RWC (and possibly IR) */
+        /* disable interrupts */
-        writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
+        writel((u32) ~0, base + OHCI_INTRDISABLE);
-        /*
+        /* Reset the USB bus, if the controller isn't already in RESET */
-         * disable interrupts
+        if (control & OHCI_HCFS) {
-         */
+                /* Go into RESET, preserving RWC (and possibly IR) */
-        writel(~(u32)0, base + OHCI_INTRDISABLE);
+                writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
-        writel(~(u32)0, base + OHCI_INTRSTATUS);
+                readl(base + OHCI_CONTROL);
+                /* drive bus reset for at least 50 ms (7.1.7.5) */
+                msleep(50);
+        }
+        /* software reset of the controller, preserving HcFmInterval */
+        fminterval = readl(base + OHCI_FMINTERVAL);
+        writel(OHCI_HCR, base + OHCI_CMDSTATUS);
+        /* reset requires max 10 us delay */
+        for (cnt = 30; cnt > 0; --cnt) {        /* ... allow extra time */
+                if ((readl(base + OHCI_CMDSTATUS) & OHCI_HCR) == 0)
+                        break;
+                udelay(1);
+        }
+        writel(fminterval, base + OHCI_FMINTERVAL);
+        /* Now the controller is safely in SUSPEND and nothing can wake it up */
        iounmap(base);
 }
+static const struct dmi_system_id __devinitconst ehci_dmi_nohandoff_table[] = {
+        {
+                /*  Pegatron Lucid (ExoPC) */
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "EXOPG06411"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "Lucid-CE-133"),
+                },
+        },
+        {
+                /*  Pegatron Lucid (Ordissimo AIRIS) */
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "M11JB"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "Lucid-GE-133"),
+                },
+        },
+        { }
+};
 static void __devinit ehci_bios_handoff(struct pci_dev *pdev,
                                        void __iomem *op_reg_base,
                                        u32 cap, u8 offset)
 {
        int try_handoff = 1, tried_handoff = 0;
-        /* The Pegatron Lucid (ExoPC) tablet sporadically waits for 90
+        /* The Pegatron Lucid tablet sporadically waits for 98 seconds trying
-         * seconds trying the handoff on its unused controller.  Skip
+         * the handoff on its unused controller.  Skip it. */
-         * it. */
        if (pdev->vendor == 0x8086 && pdev->device == 0x283a) {
-                const char *dmi_bn = dmi_get_system_info(DMI_BOARD_NAME);
+                if (dmi_check_system(ehci_dmi_nohandoff_table))
-                const char *dmi_bv = dmi_get_system_info(DMI_BIOS_VERSION);
-                if (dmi_bn && !strcmp(dmi_bn, "EXOPG06411") &&
-                    dmi_bv && !strcmp(dmi_bv, "Lucid-CE-133"))
                        try_handoff = 0;
        }
@@ -584,7 +620,7 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
        void __iomem *base, *op_reg_base;
        u32     hcc_params, cap, val;
        u8      offset, cap_length;
-        int     wait_time, delta, count = 256/4;
+        int     wait_time, count = 256/4;
        if (!mmio_resource_enabled(pdev, 0))
                return;
@@ -630,11 +666,10 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
                writel(val, op_reg_base + EHCI_USBCMD);
                wait_time = 2000;
-                delta = 100;
                do {
                        writel(0x3f, op_reg_base + EHCI_USBSTS);
-                        udelay(delta);
+                        udelay(100);
-                        wait_time -= delta;
+                        wait_time -= 100;
                        val = readl(op_reg_base + EHCI_USBSTS);
                        if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
                                break;
@@ -775,7 +810,7 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
        /* If the BIOS owns the HC, signal that the OS wants it, and wait */
        if (val & XHCI_HC_BIOS_OWNED) {
-                writel(val & XHCI_HC_OS_OWNED, base + ext_cap_offset);
+                writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
                /* Wait for 5 seconds with 10 microsecond polling interval */
                timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 4586369dda0..40a0d8b03ad 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -6,7 +6,7 @@
 * Portions Copyright (C) 2004-2005 David Brownell
 * Portions Copyright (C) 1999 Roman Weissgaerber
 *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.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
@@ -1438,7 +1438,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
        if (pipenum > 0)
                r8a66597_write(r8a66597, ~(1 << pipenum), BEMPSTS);
        if (urb->transfer_buffer) {
-                r8a66597_write_fifo(r8a66597, td->pipe->fifoaddr, buf, size);
+                r8a66597_write_fifo(r8a66597, td->pipe, buf, size);
                if (!usb_pipebulk(urb->pipe) || td->maxpacket != size)
                        r8a66597_write(r8a66597, BVAL, td->pipe->fifoctr);
        }
@@ -2306,7 +2306,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
                dbg("resume port = %d", port);
                rh->port &= ~USB_PORT_STAT_SUSPEND;
-                rh->port |= USB_PORT_STAT_C_SUSPEND < 16;
+                rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
                r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
                msleep(50);
                r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index 25563e9a90b..f28782d20ee 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -201,11 +201,26 @@ static inline void r8a66597_write(struct r8a66597 *r8a66597, u16 val,
        iowrite16(val, r8a66597->reg + offset);
 }
+static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
+                                 u16 val, u16 pat, unsigned long offset)
+{
+        u16 tmp;
+        tmp = r8a66597_read(r8a66597, offset);
+        tmp = tmp & (~pat);
+        tmp = tmp | val;
+        r8a66597_write(r8a66597, tmp, offset);
+}
+#define r8a66597_bclr(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, 0, val, offset)
+#define r8a66597_bset(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, val, 0, offset)
 static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
-                                       unsigned long offset, u16 *buf,
+                                       struct r8a66597_pipe *pipe, u16 *buf,
                                       int len)
 {
-        void __iomem *fifoaddr = r8a66597->reg + offset;
+        void __iomem *fifoaddr = r8a66597->reg + pipe->fifoaddr;
        unsigned long count;
        unsigned char *pb;
        int i;
@@ -230,26 +245,15 @@ static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
                iowrite16_rep(fifoaddr, buf, len);
                if (unlikely(odd)) {
                        buf = &buf[len];
+                        if (r8a66597->pdata->wr0_shorted_to_wr1)
+                                r8a66597_bclr(r8a66597, MBW_16, pipe->fifosel);
                        iowrite8((unsigned char)*buf, fifoaddr);
+                        if (r8a66597->pdata->wr0_shorted_to_wr1)
+                                r8a66597_bset(r8a66597, MBW_16, pipe->fifosel);
                }
        }
 }
-static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
-                                 u16 val, u16 pat, unsigned long offset)
-{
-        u16 tmp;
-        tmp = r8a66597_read(r8a66597, offset);
-        tmp = tmp & (~pat);
-        tmp = tmp | val;
-        r8a66597_write(r8a66597, tmp, offset);
-}
-#define r8a66597_bclr(r8a66597, val, offset)    \
-                        r8a66597_mdfy(r8a66597, 0, val, offset)
-#define r8a66597_bset(r8a66597, val, offset)    \
-                        r8a66597_mdfy(r8a66597, val, 0, offset)
 static inline unsigned long get_syscfg_reg(int port)
 {
        return port == 0 ? SYSCFG0 : SYSCFG1;
diff --git a/drivers/usb/host/uhci-grlib.c b/drivers/usb/host/uhci-grlib.c
index d01c1e22768..f7a62138e3e 100644
--- a/drivers/usb/host/uhci-grlib.c
+++ b/drivers/usb/host/uhci-grlib.c
@@ -111,7 +111,7 @@ static int __devinit uhci_hcd_grlib_probe(struct platform_device *op)
                return -ENOMEM;
        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, hcd_name)) {
                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 84ed28b34f9..82539913ad8 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/init.c b/drivers/usb/host/whci/init.c
index f7582e8e216..d3e13b640d4 100644
--- a/drivers/usb/host/whci/init.c
+++ b/drivers/usb/host/whci/init.c
@@ -178,7 +178,7 @@ void whc_clean_up(struct whc *whc)
        if (whc->qset_pool)
                dma_pool_destroy(whc->qset_pool);
-        len   = whc->umc->resource.end - whc->umc->resource.start + 1;
+        len   = resource_size(&whc->umc->resource);
        if (whc->base)
                iounmap(whc->base);
        if (whc->base_phys)
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index d6e17542861..76083ae9213 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -124,7 +124,7 @@ void qset_clear(struct whc *whc, struct whc_qset *qset)
 {
        qset->td_start = qset->td_end = qset->ntds = 0;
-        qset->qh.link = cpu_to_le32(QH_LINK_NTDS(8) | QH_LINK_T);
+        qset->qh.link = cpu_to_le64(QH_LINK_NTDS(8) | QH_LINK_T);
        qset->qh.status = qset->qh.status & QH_STATUS_SEQ_MASK;
        qset->qh.err_count = 0;
        qset->qh.scratch[0] = 0;
@@ -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-dbg.c b/drivers/usb/host/xhci-dbg.c
index 1f50b4468e8..e9b0f043455 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -266,11 +266,11 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
                xhci_dbg(xhci, "Interrupter target = 0x%x\n",
                         GET_INTR_TARGET(le32_to_cpu(trb->link.intr_target)));
                xhci_dbg(xhci, "Cycle bit = %u\n",
-                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_CYCLE));
+                         le32_to_cpu(trb->link.control) & TRB_CYCLE);
                xhci_dbg(xhci, "Toggle cycle bit = %u\n",
-                         (unsigned int) (le32_to_cpu(trb->link.control) & LINK_TOGGLE));
+                         le32_to_cpu(trb->link.control) & LINK_TOGGLE);
                xhci_dbg(xhci, "No Snoop bit = %u\n",
-                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_NO_SNOOP));
+                         le32_to_cpu(trb->link.control) & TRB_NO_SNOOP);
                break;
        case TRB_TYPE(TRB_TRANSFER):
                address = le64_to_cpu(trb->trans_event.buffer);
@@ -284,9 +284,9 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
                address = le64_to_cpu(trb->event_cmd.cmd_trb);
                xhci_dbg(xhci, "Command TRB pointer = %llu\n", address);
                xhci_dbg(xhci, "Completion status = %u\n",
-                         (unsigned int) GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));
+                         GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));
                xhci_dbg(xhci, "Flags = 0x%x\n",
-                         (unsigned int) le32_to_cpu(trb->event_cmd.flags));
+                         le32_to_cpu(trb->event_cmd.flags));
                break;
        default:
                xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n",
@@ -318,10 +318,10 @@ void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg)
        for (i = 0; i < TRBS_PER_SEGMENT; ++i) {
                trb = &seg->trbs[i];
                xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n", addr,
-                         (u32)lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
-                         (u32)upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
-                         (unsigned int) le32_to_cpu(trb->link.intr_target),
+                         le32_to_cpu(trb->link.intr_target),
-                         (unsigned int) le32_to_cpu(trb->link.control));
+                         le32_to_cpu(trb->link.control));
                addr += sizeof(*trb);
        }
 }
@@ -402,8 +402,8 @@ void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
                         addr,
                         lower_32_bits(le64_to_cpu(entry->seg_addr)),
                         upper_32_bits(le64_to_cpu(entry->seg_addr)),
-                         (unsigned int) le32_to_cpu(entry->seg_size),
+                         le32_to_cpu(entry->seg_size),
-                         (unsigned int) le32_to_cpu(entry->rsvd));
+                         le32_to_cpu(entry->rsvd));
                addr += sizeof(*entry);
        }
 }
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 0be788cc2fd..ce9f974dac0 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -392,6 +392,20 @@ static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
        return max_ports;
 }
+/* Test and clear port RWC bit */
+void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 port_bit)
+{
+        u32 temp;
+        temp = xhci_readl(xhci, port_array[port_id]);
+        if (temp & port_bit) {
+                temp = xhci_port_state_to_neutral(temp);
+                temp |= port_bit;
+                xhci_writel(xhci, temp, port_array[port_id]);
+        }
+}
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                u16 wIndex, char *buf, u16 wLength)
 {
@@ -463,11 +477,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                        && (temp & PORT_POWER))
                                status |= USB_PORT_STAT_SUSPEND;
                }
-                if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
+                if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&
+                                !DEV_SUPERSPEED(temp)) {
                        if ((temp & PORT_RESET) || !(temp & PORT_PE))
                                goto error;
-                        if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
+                        if (time_after_eq(jiffies,
-                                                bus_state->resume_done[wIndex])) {
+                                        bus_state->resume_done[wIndex])) {
                                xhci_dbg(xhci, "Resume USB2 port %d\n",
                                        wIndex + 1);
                                bus_state->resume_done[wIndex] = 0;
@@ -487,6 +502,14 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                xhci_ring_device(xhci, slot_id);
                                bus_state->port_c_suspend |= 1 << wIndex;
                                bus_state->suspended_ports &= ~(1 << wIndex);
+                        } else {
+                                /*
+                                 * The resume has been signaling for less than
+                                 * 20ms. Report the port status as SUSPEND,
+                                 * let the usbcore check port status again
+                                 * and clear resume signaling later.
+                                 */
+                                status |= USB_PORT_STAT_SUSPEND;
                        }
                }
                if ((temp & PORT_PLS_MASK) == XDEV_U0
@@ -664,7 +687,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                        xhci_dbg(xhci, "PORTSC %04x\n", temp);
                        if (temp & PORT_RESET)
                                goto error;
-                        if (temp & XDEV_U3) {
+                        if ((temp & PORT_PLS_MASK) == XDEV_U3) {
                                if ((temp & PORT_PE) == 0)
                                        goto error;
@@ -752,7 +775,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
        memset(buf, 0, retval);
        status = 0;
-        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;
        spin_lock_irqsave(&xhci->lock, flags);
        /* For each port, did anything change?  If so, set that bit in buf. */
@@ -929,12 +952,8 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                        spin_lock_irqsave(&xhci->lock, flags);
                        /* Clear PLC */
-                        temp = xhci_readl(xhci, port_array[port_index]);
+                        xhci_test_and_clear_bit(xhci, port_array, port_index,
-                        if (temp & PORT_PLC) {
+                                                PORT_PLC);
-                                temp = xhci_port_state_to_neutral(temp);
-                                temp |= PORT_PLC;
-                                xhci_writel(xhci, temp, port_array[port_index]);
-                        }
                        slot_id = xhci_find_slot_id_by_port(hcd,
                                        xhci, port_index + 1);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index fcb7f7efc86..d718033dc53 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -81,7 +81,7 @@ static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
 * related flags, such as End TRB, Toggle Cycle, and no snoop.
 */
 static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
-                struct xhci_segment *next, bool link_trbs)
+                struct xhci_segment *next, bool link_trbs, bool isoc)
 {
        u32 val;
@@ -89,15 +89,17 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                return;
        prev->next = next;
        if (link_trbs) {
-                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr =
-                        segment_ptr = cpu_to_le64(next->dma);
+                        cpu_to_le64(next->dma);
                /* Set the last TRB in the segment to have a TRB type ID of Link TRB */
                val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
                val &= ~TRB_TYPE_BITMASK;
                val |= TRB_TYPE(TRB_LINK);
                /* Always set the chain bit with 0.95 hardware */
-                if (xhci_link_trb_quirk(xhci))
+                /* Set chain bit for isoc rings on AMD 0.96 host */
+                if (xhci_link_trb_quirk(xhci) ||
+                                (isoc && (xhci->quirks & XHCI_AMD_0x96_HOST)))
                        val |= TRB_CHAIN;
                prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
        }
@@ -112,18 +114,20 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
        struct xhci_segment *seg;
        struct xhci_segment *first_seg;
-        if (!ring || !ring->first_seg)
+        if (!ring)
                return;
-        first_seg = ring->first_seg;
+        if (ring->first_seg) {
-        seg = first_seg->next;
+                first_seg = ring->first_seg;
-        xhci_dbg(xhci, "Freeing ring at %p\n", ring);
+                seg = first_seg->next;
-        while (seg != first_seg) {
+                xhci_dbg(xhci, "Freeing ring at %p\n", ring);
-                struct xhci_segment *next = seg->next;
+                while (seg != first_seg) {
-                xhci_segment_free(xhci, seg);
+                        struct xhci_segment *next = seg->next;
-                seg = next;
+                        xhci_segment_free(xhci, seg);
+                        seg = next;
+                }
+                xhci_segment_free(xhci, first_seg);
+                ring->first_seg = NULL;
        }
-        xhci_segment_free(xhci, first_seg);
-        ring->first_seg = NULL;
        kfree(ring);
 }
@@ -152,7 +156,7 @@ static void xhci_initialize_ring_info(struct xhci_ring *ring)
 * See section 4.9.1 and figures 15 and 16.
 */
 static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
-                unsigned int num_segs, bool link_trbs, gfp_t flags)
+                unsigned int num_segs, bool link_trbs, bool isoc, gfp_t flags)
 {
        struct xhci_ring        *ring;
        struct xhci_segment     *prev;
@@ -178,17 +182,17 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                next = xhci_segment_alloc(xhci, flags);
                if (!next)
                        goto fail;
-                xhci_link_segments(xhci, prev, next, link_trbs);
+                xhci_link_segments(xhci, prev, next, link_trbs, isoc);
                prev = next;
                num_segs--;
        }
-        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs);
+        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs, isoc);
        if (link_trbs) {
                /* See section 4.9.2.1 and 6.4.4.1 */
-                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                prev->trbs[TRBS_PER_SEGMENT-1].link.control |=
-                        control |= cpu_to_le32(LINK_TOGGLE);
+                        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);
@@ -229,14 +233,14 @@ void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
 * pointers to the beginning of the ring.
 */
 static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
-                struct xhci_ring *ring)
+                struct xhci_ring *ring, bool isoc)
 {
        struct xhci_segment     *seg = ring->first_seg;
        do {
                memset(seg->trbs, 0,
                                sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
                /* All endpoint rings have link TRBs */
-                xhci_link_segments(xhci, seg, seg->next, 1);
+                xhci_link_segments(xhci, seg, seg->next, 1, isoc);
                seg = seg->next;
        } while (seg != ring->first_seg);
        xhci_initialize_ring_info(ring);
@@ -540,7 +544,7 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
         */
        for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
                stream_info->stream_rings[cur_stream] =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
                cur_ring = stream_info->stream_rings[cur_stream];
                if (!cur_ring)
                        goto cleanup_rings;
@@ -549,8 +553,8 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                addr = cur_ring->first_seg->dma |
                        SCT_FOR_CTX(SCT_PRI_TR) |
                        cur_ring->cycle_state;
-                stream_info->stream_ctx_array[cur_stream].
+                stream_info->stream_ctx_array[cur_stream].stream_ring =
-                        stream_ring = cpu_to_le64(addr);
+                        cpu_to_le64(addr);
                xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
                                cur_stream, (unsigned long long) addr);
@@ -765,7 +769,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
        }
        /* Allocate endpoint 0 ring */
-        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);
+        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, false, flags);
        if (!dev->eps[0].ring)
                goto fail;
@@ -786,7 +790,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
        xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
                 slot_id,
                 &xhci->dcbaa->dev_context_ptrs[slot_id],
-                 (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
+                 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
        return 1;
 fail:
@@ -871,7 +875,6 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
        struct xhci_virt_device *dev;
        struct xhci_ep_ctx      *ep0_ctx;
        struct xhci_slot_ctx    *slot_ctx;
-        struct xhci_input_control_ctx *ctrl_ctx;
        u32                     port_num;
        struct usb_device *top_dev;
@@ -883,26 +886,22 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                return -EINVAL;
        }
        ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0);
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx);
        slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
-        /* 2) New slot context and endpoint 0 context are valid*/
-        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
        /* 3) Only the control endpoint is valid - one endpoint context */
-        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route);
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | udev->route);
        switch (udev->speed) {
        case USB_SPEED_SUPER:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SS);
                break;
        case USB_SPEED_HIGH:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_HS);
                break;
        case USB_SPEED_FULL:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_FS);
                break;
        case USB_SPEED_LOW:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_LS);
                break;
        case USB_SPEED_WIRELESS:
                xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -916,7 +915,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
        port_num = xhci_find_real_port_number(xhci, udev);
        if (!port_num)
                return -EINVAL;
-        slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num));
+        slot_ctx->dev_info2 |= cpu_to_le32(ROOT_HUB_PORT(port_num));
        /* Set the port number in the virtual_device to the faked port number */
        for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
                        top_dev = top_dev->parent)
@@ -1175,10 +1174,10 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         */
        if (usb_endpoint_xfer_isoc(&ep->desc))
                virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 8, true, mem_flags);
+                        xhci_ring_alloc(xhci, 8, true, true, mem_flags);
        else
                virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
        if (!virt_dev->eps[ep_index].new_ring) {
                /* Attempt to use the ring cache */
                if (virt_dev->num_rings_cached == 0)
@@ -1187,7 +1186,8 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                        virt_dev->ring_cache[virt_dev->num_rings_cached];
                virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
                virt_dev->num_rings_cached--;
-                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring);
+                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
+                        usb_endpoint_xfer_isoc(&ep->desc) ? true : false);
        }
        virt_dev->eps[ep_index].skip = false;
        ep_ring = virt_dev->eps[ep_index].new_ring;
@@ -2001,7 +2001,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                goto fail;
        /* Set up the command ring to have one segments for now. */
-        xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags);
+        xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, false, flags);
        if (!xhci->cmd_ring)
                goto fail;
        xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring);
@@ -2032,7 +2032,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         * the event ring segment table (ERST).  Section 4.9.3.
         */
        xhci_dbg(xhci, "// Allocating event ring\n");
-        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags);
+        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, false,
+                                                flags);
        if (!xhci->event_ring)
                goto fail;
        if (xhci_check_trb_in_td_math(xhci, flags) < 0)
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index cb16de213f6..50e7156a7d8 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -128,6 +128,9 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
        if (pdev->vendor == PCI_VENDOR_ID_NEC)
                xhci->quirks |= XHCI_NEC_HOST;
+        if (pdev->vendor == PCI_VENDOR_ID_AMD && xhci->hci_version == 0x96)
+                xhci->quirks |= XHCI_AMD_0x96_HOST;
        /* AMD PLL quirk */
        if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
                xhci->quirks |= XHCI_AMD_PLL_FIX;
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 70cacbbe7fb..ae99e3b32fb 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -113,15 +113,13 @@ static int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
        if (ring == xhci->event_ring)
                return trb == &seg->trbs[TRBS_PER_SEGMENT];
        else
-                return (le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK)
+                return TRB_TYPE_LINK_LE32(trb->link.control);
-                        == TRB_TYPE(TRB_LINK);
 }
 static int enqueue_is_link_trb(struct xhci_ring *ring)
 {
        struct xhci_link_trb *link = &ring->enqueue->link;
-        return ((le32_to_cpu(link->control) & TRB_TYPE_BITMASK) ==
+        return TRB_TYPE_LINK_LE32(link->control);
-                TRB_TYPE(TRB_LINK));
 }
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
@@ -187,7 +185,7 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
 *                      prepare_transfer()?
 */
 static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
-                bool consumer, bool more_trbs_coming)
+                bool consumer, bool more_trbs_coming, bool isoc)
 {
        u32 chain;
        union xhci_trb *next;
@@ -214,11 +212,13 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                                if (!chain && !more_trbs_coming)
                                        break;
-                                /* If we're not dealing with 0.95 hardware,
+                                /* If we're not dealing with 0.95 hardware or
+                                 * isoc rings on AMD 0.96 host,
                                 * carry over the chain bit of the previous TRB
                                 * (which may mean the chain bit is cleared).
                                 */
-                                if (!xhci_link_trb_quirk(xhci)) {
+                                if (!(isoc && (xhci->quirks & XHCI_AMD_0x96_HOST))
+                                                && !xhci_link_trb_quirk(xhci)) {
                                        next->link.control &=
                                                cpu_to_le32(~TRB_CHAIN);
                                        next->link.control |=
@@ -372,7 +372,7 @@ static struct xhci_segment *find_trb_seg(
        while (cur_seg->trbs > trb ||
                        &cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) {
                generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic;
-                if (le32_to_cpu(generic_trb->field[3]) & LINK_TOGGLE)
+                if (generic_trb->field[3] & cpu_to_le32(LINK_TOGGLE))
                        *cycle_state ^= 0x1;
                cur_seg = cur_seg->next;
                if (cur_seg == start_seg)
@@ -489,8 +489,8 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
        }
        trb = &state->new_deq_ptr->generic;
-        if ((le32_to_cpu(trb->field[3]) & TRB_TYPE_BITMASK) ==
+        if (TRB_TYPE_LINK_LE32(trb->field[3]) &&
-            TRB_TYPE(TRB_LINK) && (le32_to_cpu(trb->field[3]) & LINK_TOGGLE))
+            (trb->field[3] & cpu_to_le32(LINK_TOGGLE)))
                state->new_cycle_state ^= 0x1;
        next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
@@ -516,8 +516,12 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                        (unsigned long long) addr);
 }
+/* flip_cycle means flip the cycle bit of all but the first and last TRB.
+ * (The last TRB actually points to the ring enqueue pointer, which is not part
+ * of this TD.)  This is used to remove partially enqueued isoc TDs from a ring.
+ */
 static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
-                struct xhci_td *cur_td)
+                struct xhci_td *cur_td, bool flip_cycle)
 {
        struct xhci_segment *cur_seg;
        union xhci_trb *cur_trb;
@@ -525,12 +529,17 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
        for (cur_seg = cur_td->start_seg, cur_trb = cur_td->first_trb;
                        true;
                        next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                if ((le32_to_cpu(cur_trb->generic.field[3]) & TRB_TYPE_BITMASK)
+                if (TRB_TYPE_LINK_LE32(cur_trb->generic.field[3])) {
-                    == TRB_TYPE(TRB_LINK)) {
                        /* Unchain any chained Link TRBs, but
                         * leave the pointers intact.
                         */
                        cur_trb->generic.field[3] &= cpu_to_le32(~TRB_CHAIN);
+                        /* Flip the cycle bit (link TRBs can't be the first
+                         * or last TRB).
+                         */
+                        if (flip_cycle)
+                                cur_trb->generic.field[3] ^=
+                                        cpu_to_le32(TRB_CYCLE);
                        xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
                        xhci_dbg(xhci, "Address = %p (0x%llx dma); "
                                        "in seg %p (0x%llx dma)\n",
@@ -544,6 +553,11 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                        cur_trb->generic.field[2] = 0;
                        /* Preserve only the cycle bit of this TRB */
                        cur_trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
+                        /* Flip the cycle bit except on the first or last TRB */
+                        if (flip_cycle && cur_trb != cur_td->first_trb &&
+                                        cur_trb != cur_td->last_trb)
+                                cur_trb->generic.field[3] ^=
+                                        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) "
@@ -722,14 +736,14 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                                        cur_td->urb->stream_id,
                                        cur_td, &deq_state);
                else
-                        td_to_noop(xhci, ep_ring, cur_td);
+                        td_to_noop(xhci, ep_ring, cur_td, false);
 remove_finished_td:
                /*
                 * The event handler won't see a completion for this TD anymore,
                 * so remove it from the endpoint ring's TD list.  Keep it in
                 * the cancelled TD list for URB completion later.
                 */
-                list_del(&cur_td->td_list);
+                list_del_init(&cur_td->td_list);
        }
        last_unlinked_td = cur_td;
        xhci_stop_watchdog_timer_in_irq(xhci, ep);
@@ -757,7 +771,7 @@ remove_finished_td:
        do {
                cur_td = list_entry(ep->cancelled_td_list.next,
                                struct xhci_td, cancelled_td_list);
-                list_del(&cur_td->cancelled_td_list);
+                list_del_init(&cur_td->cancelled_td_list);
                /* Clean up the cancelled URB */
                /* Doesn't matter what we pass for status, since the core will
@@ -802,23 +816,24 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
        struct xhci_ring *ring;
        struct xhci_td *cur_td;
        int ret, i, j;
+        unsigned long flags;
        ep = (struct xhci_virt_ep *) arg;
        xhci = ep->xhci;
-        spin_lock(&xhci->lock);
+        spin_lock_irqsave(&xhci->lock, flags);
        ep->stop_cmds_pending--;
        if (xhci->xhc_state & XHCI_STATE_DYING) {
                xhci_dbg(xhci, "Stop EP timer ran, but another timer marked "
                                "xHCI as DYING, exiting.\n");
-                spin_unlock(&xhci->lock);
+                spin_unlock_irqrestore(&xhci->lock, flags);
                return;
        }
        if (!(ep->stop_cmds_pending == 0 && (ep->ep_state & EP_HALT_PENDING))) {
                xhci_dbg(xhci, "Stop EP timer ran, but no command pending, "
                                "exiting.\n");
-                spin_unlock(&xhci->lock);
+                spin_unlock_irqrestore(&xhci->lock, flags);
                return;
        }
@@ -830,11 +845,11 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
        xhci->xhc_state |= XHCI_STATE_DYING;
        /* Disable interrupts from the host controller and start halting it */
        xhci_quiesce(xhci);
-        spin_unlock(&xhci->lock);
+        spin_unlock_irqrestore(&xhci->lock, flags);
        ret = xhci_halt(xhci);
-        spin_lock(&xhci->lock);
+        spin_lock_irqsave(&xhci->lock, flags);
        if (ret < 0) {
                /* This is bad; the host is not responding to commands and it's
                 * not allowing itself to be halted.  At least interrupts are
@@ -865,9 +880,9 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                cur_td = list_first_entry(&ring->td_list,
                                                struct xhci_td,
                                                td_list);
-                                list_del(&cur_td->td_list);
+                                list_del_init(&cur_td->td_list);
                                if (!list_empty(&cur_td->cancelled_td_list))
-                                        list_del(&cur_td->cancelled_td_list);
+                                        list_del_init(&cur_td->cancelled_td_list);
                                xhci_giveback_urb_in_irq(xhci, cur_td,
                                                -ESHUTDOWN, "killed");
                        }
@@ -876,13 +891,13 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                                &temp_ep->cancelled_td_list,
                                                struct xhci_td,
                                                cancelled_td_list);
-                                list_del(&cur_td->cancelled_td_list);
+                                list_del_init(&cur_td->cancelled_td_list);
                                xhci_giveback_urb_in_irq(xhci, cur_td,
                                                -ESHUTDOWN, "killed");
                        }
                }
        }
-        spin_unlock(&xhci->lock);
+        spin_unlock_irqrestore(&xhci->lock, flags);
        xhci_dbg(xhci, "Calling usb_hc_died()\n");
        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
        xhci_dbg(xhci, "xHCI host controller is dead.\n");
@@ -1000,7 +1015,7 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
         * but we don't care.
         */
        xhci_dbg(xhci, "Ignoring reset ep completion code of %u\n",
-                 (unsigned int) GET_COMP_CODE(le32_to_cpu(event->status)));
+                 GET_COMP_CODE(le32_to_cpu(event->status)));
        /* HW with the reset endpoint quirk needs to have a configure endpoint
         * command complete before the endpoint can be used.  Queue that here
@@ -1200,6 +1215,7 @@ static void handle_vendor_event(struct xhci_hcd *xhci,
 *
 * Returns a zero-based port number, which is suitable for indexing into each of
 * the split roothubs' port arrays and bus state arrays.
+ * Add one to it in order to call xhci_find_slot_id_by_port.
 */
 static unsigned int find_faked_portnum_from_hw_portnum(struct usb_hcd *hcd,
                struct xhci_hcd *xhci, u32 port_id)
@@ -1322,7 +1338,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
                        temp |= PORT_LINK_STROBE | XDEV_U0;
                        xhci_writel(xhci, temp, port_array[faked_port_index]);
                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
-                                        faked_port_index);
+                                        faked_port_index + 1);
                        if (!slot_id) {
                                xhci_dbg(xhci, "slot_id is zero\n");
                                goto cleanup;
@@ -1330,10 +1346,8 @@ static void handle_port_status(struct xhci_hcd *xhci,
                        xhci_ring_device(xhci, slot_id);
                        xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
                        /* Clear PORT_PLC */
-                        temp = xhci_readl(xhci, port_array[faked_port_index]);
+                        xhci_test_and_clear_bit(xhci, port_array,
-                        temp = xhci_port_state_to_neutral(temp);
+                                                faked_port_index, PORT_PLC);
-                        temp |= PORT_PLC;
-                        xhci_writel(xhci, temp, port_array[faked_port_index]);
                } else {
                        xhci_dbg(xhci, "resume HS port %d\n", port_id);
                        bus_state->resume_done[faked_port_index] = jiffies +
@@ -1344,6 +1358,10 @@ static void handle_port_status(struct xhci_hcd *xhci,
                }
        }
+        if (hcd->speed != HCD_USB3)
+                xhci_test_and_clear_bit(xhci, port_array, faked_port_index,
+                                        PORT_PLC);
 cleanup:
        /* Update event ring dequeue pointer before dropping the lock */
        inc_deq(xhci, xhci->event_ring, true);
@@ -1458,7 +1476,8 @@ static int xhci_requires_manual_halt_cleanup(struct xhci_hcd *xhci,
                 * endpoint anyway.  Check if a babble halted the
                 * endpoint.
                 */
-                if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) == EP_STATE_HALTED)
+                if ((ep_ctx->ep_info & cpu_to_le32(EP_STATE_MASK)) ==
+                    cpu_to_le32(EP_STATE_HALTED))
                        return 1;
        return 0;
@@ -1567,10 +1586,10 @@ td_cleanup:
                        else
                                *status = 0;
                }
-                list_del(&td->td_list);
+                list_del_init(&td->td_list);
                /* Was this TD slated to be cancelled but completed anyway? */
                if (!list_empty(&td->cancelled_td_list))
-                        list_del(&td->cancelled_td_list);
+                        list_del_init(&td->cancelled_td_list);
                urb_priv->td_cnt++;
                /* Giveback the urb when all the tds are completed */
@@ -1753,10 +1772,8 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
                for (cur_trb = ep_ring->dequeue,
                     cur_seg = ep_ring->deq_seg; cur_trb != event_trb;
                     next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
+                        if (!TRB_TYPE_NOOP_LE32(cur_trb->generic.field[3]) &&
-                         TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
+                            !TRB_TYPE_LINK_LE32(cur_trb->generic.field[3]))
-                            (le32_to_cpu(cur_trb->generic.field[3]) &
-                         TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
                                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                }
                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
@@ -1885,10 +1902,8 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg;
                                cur_trb != event_trb;
                                next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
+                        if (!TRB_TYPE_NOOP_LE32(cur_trb->generic.field[3]) &&
-                         TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
+                            !TRB_TYPE_LINK_LE32(cur_trb->generic.field[3]))
-                            (le32_to_cpu(cur_trb->generic.field[3]) &
-                         TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
                                td->urb->actual_length +=
                                        TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                }
@@ -1925,8 +1940,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
        int status = -EINPROGRESS;
        struct urb_priv *urb_priv;
        struct xhci_ep_ctx *ep_ctx;
+        struct list_head *tmp;
        u32 trb_comp_code;
        int ret = 0;
+        int td_num = 0;
        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
        xdev = xhci->devs[slot_id];
@@ -1948,6 +1965,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                return -ENODEV;
        }
+        /* Count current td numbers if ep->skip is set */
+        if (ep->skip) {
+                list_for_each(tmp, &ep_ring->td_list)
+                        td_num++;
+        }
        event_dma = le64_to_cpu(event->buffer);
        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
        /* Look for common error cases */
@@ -2047,8 +2070,8 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                  TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
                                  ep_index);
                        xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",
-                                 (unsigned int) (le32_to_cpu(event->flags)
+                                 (le32_to_cpu(event->flags) &
-                                                 & TRB_TYPE_BITMASK)>>10);
+                                  TRB_TYPE_BITMASK)>>10);
                        xhci_print_trb_offsets(xhci, (union xhci_trb *) event);
                        if (ep->skip) {
                                ep->skip = false;
@@ -2059,7 +2082,18 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                        goto cleanup;
                }
+                /* We've skipped all the TDs on the ep ring when ep->skip set */
+                if (ep->skip && td_num == 0) {
+                        ep->skip = false;
+                        xhci_dbg(xhci, "All tds on the ep_ring skipped. "
+                                                "Clear skip flag.\n");
+                        ret = 0;
+                        goto cleanup;
+                }
                td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list);
+                if (ep->skip)
+                        td_num--;
                /* Is this a TRB in the currently executing TD? */
                event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
@@ -2119,9 +2153,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 * corresponding TD has been cancelled. Just ignore
                 * the TD.
                 */
-                if ((le32_to_cpu(event_trb->generic.field[3])
+                if (TRB_TYPE_NOOP_LE32(event_trb->generic.field[3])) {
-                             & TRB_TYPE_BITMASK)
-                                 == TRB_TYPE(TRB_TR_NOOP)) {
                        xhci_dbg(xhci,
                                 "event_trb is a no-op TRB. Skip it\n");
                        goto cleanup;
@@ -2383,7 +2415,7 @@ irqreturn_t xhci_msi_irq(int irq, struct usb_hcd *hcd)
 *                      prepare_transfer()?
 */
 static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
-                bool consumer, bool more_trbs_coming,
+                bool consumer, bool more_trbs_coming, bool isoc,
                u32 field1, u32 field2, u32 field3, u32 field4)
 {
        struct xhci_generic_trb *trb;
@@ -2393,7 +2425,7 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
        trb->field[1] = cpu_to_le32(field2);
        trb->field[2] = cpu_to_le32(field3);
        trb->field[3] = cpu_to_le32(field4);
-        inc_enq(xhci, ring, consumer, more_trbs_coming);
+        inc_enq(xhci, ring, consumer, more_trbs_coming, isoc);
 }
 /*
@@ -2401,7 +2433,7 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
 * FIXME allocate segments if the ring is full.
 */
 static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
-                u32 ep_state, unsigned int num_trbs, gfp_t mem_flags)
+                u32 ep_state, unsigned int num_trbs, bool isoc, gfp_t mem_flags)
 {
        /* Make sure the endpoint has been added to xHC schedule */
        switch (ep_state) {
@@ -2443,16 +2475,17 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                next = ring->enqueue;
                while (last_trb(xhci, ring, ring->enq_seg, next)) {
-                        /* If we're not dealing with 0.95 hardware,
+                        /* If we're not dealing with 0.95 hardware or isoc rings
-                         * clear the chain bit.
+                         * on AMD 0.96 host, clear the chain bit.
                         */
-                        if (!xhci_link_trb_quirk(xhci))
+                        if (!xhci_link_trb_quirk(xhci) && !(isoc &&
+                                        (xhci->quirks & XHCI_AMD_0x96_HOST)))
                                next->link.control &= cpu_to_le32(~TRB_CHAIN);
                        else
                                next->link.control |= cpu_to_le32(TRB_CHAIN);
                        wmb();
-                        next->link.control ^= cpu_to_le32((u32) TRB_CYCLE);
+                        next->link.control ^= cpu_to_le32(TRB_CYCLE);
                        /* Toggle the cycle bit after the last ring segment. */
                        if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -2479,6 +2512,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
                unsigned int num_trbs,
                struct urb *urb,
                unsigned int td_index,
+                bool isoc,
                gfp_t mem_flags)
 {
        int ret;
@@ -2496,7 +2530,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
        ret = prepare_ring(xhci, ep_ring,
                           le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
-                           num_trbs, mem_flags);
+                           num_trbs, isoc, mem_flags);
        if (ret)
                return ret;
@@ -2508,11 +2542,8 @@ static int prepare_transfer(struct xhci_hcd *xhci,
        if (td_index == 0) {
                ret = usb_hcd_link_urb_to_ep(bus_to_hcd(urb->dev->bus), urb);
-                if (unlikely(ret)) {
+                if (unlikely(ret))
-                        xhci_urb_free_priv(xhci, urb_priv);
-                        urb->hcpriv = NULL;
                        return ret;
-                }
        }
        td->urb = urb;
@@ -2532,7 +2563,7 @@ 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");
@@ -2680,6 +2711,10 @@ static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
 {
        int packets_transferred;
+        /* One TRB with a zero-length data packet. */
+        if (running_total == 0 && trb_buff_len == 0)
+                return 0;
        /* All the TRB queueing functions don't count the current TRB in
         * running_total.
         */
@@ -2712,13 +2747,13 @@ 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,
                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
        trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id],
                        ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
        if (trb_buff_len < 0)
                return trb_buff_len;
@@ -2813,7 +2848,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                        more_trbs_coming = true;
                else
                        more_trbs_coming = false;
-                queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                queue_trb(xhci, ep_ring, false, more_trbs_coming, false,
                                lower_32_bits(addr),
                                upper_32_bits(addr),
                                length_field,
@@ -2904,7 +2939,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
        ret = prepare_transfer(xhci, xhci->devs[slot_id],
                        ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
        if (ret < 0)
                return ret;
@@ -2976,7 +3011,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                        more_trbs_coming = true;
                else
                        more_trbs_coming = false;
-                queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                queue_trb(xhci, ep_ring, false, more_trbs_coming, false,
                                lower_32_bits(addr),
                                upper_32_bits(addr),
                                length_field,
@@ -3036,7 +3071,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                num_trbs++;
        ret = prepare_transfer(xhci, xhci->devs[slot_id],
                        ep_index, urb->stream_id,
-                        num_trbs, urb, 0, mem_flags);
+                        num_trbs, urb, 0, false, mem_flags);
        if (ret < 0)
                return ret;
@@ -3069,7 +3104,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                }
        }
-        queue_trb(xhci, ep_ring, false, true,
+        queue_trb(xhci, ep_ring, false, true, false,
                  setup->bRequestType | setup->bRequest << 8 | le16_to_cpu(setup->wValue) << 16,
                  le16_to_cpu(setup->wIndex) | le16_to_cpu(setup->wLength) << 16,
                  TRB_LEN(8) | TRB_INTR_TARGET(0),
@@ -3089,7 +3124,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
        if (urb->transfer_buffer_length > 0) {
                if (setup->bRequestType & USB_DIR_IN)
                        field |= TRB_DIR_IN;
-                queue_trb(xhci, ep_ring, false, true,
+                queue_trb(xhci, ep_ring, false, true, false,
                                lower_32_bits(urb->transfer_dma),
                                upper_32_bits(urb->transfer_dma),
                                length_field,
@@ -3105,7 +3140,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                field = 0;
        else
                field = TRB_DIR_IN;
-        queue_trb(xhci, ep_ring, false, false,
+        queue_trb(xhci, ep_ring, false, false, false,
                        0,
                        0,
                        TRB_INTR_TARGET(0),
@@ -3121,21 +3156,16 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
                struct urb *urb, int i)
 {
        int num_trbs = 0;
-        u64 addr, td_len, running_total;
+        u64 addr, td_len;
        addr = (u64) (urb->transfer_dma + urb->iso_frame_desc[i].offset);
        td_len = urb->iso_frame_desc[i].length;
-        running_total = TRB_MAX_BUFF_SIZE - (addr & (TRB_MAX_BUFF_SIZE - 1));
+        num_trbs = DIV_ROUND_UP(td_len + (addr & (TRB_MAX_BUFF_SIZE - 1)),
-        running_total &= TRB_MAX_BUFF_SIZE - 1;
+                        TRB_MAX_BUFF_SIZE);
-        if (running_total != 0)
+        if (num_trbs == 0)
                num_trbs++;
-        while (running_total < td_len) {
-                num_trbs++;
-                running_total += TRB_MAX_BUFF_SIZE;
-        }
        return num_trbs;
 }
@@ -3234,6 +3264,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
        start_trb = &ep_ring->enqueue->generic;
        start_cycle = ep_ring->cycle_state;
+        urb_priv = urb->hcpriv;
        /* Queue the first TRB, even if it's zero-length */
        for (i = 0; i < num_tds; i++) {
                unsigned int total_packet_count;
@@ -3245,9 +3276,11 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                addr = start_addr + urb->iso_frame_desc[i].offset;
                td_len = urb->iso_frame_desc[i].length;
                td_remain_len = td_len;
-                /* FIXME: Ignoring zero-length packets, can those happen? */
                total_packet_count = roundup(td_len,
                                le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                /* A zero-length transfer still involves at least one packet. */
+                if (total_packet_count == 0)
+                        total_packet_count++;
                burst_count = xhci_get_burst_count(xhci, urb->dev, urb,
                                total_packet_count);
                residue = xhci_get_last_burst_packet_count(xhci,
@@ -3256,13 +3289,15 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                trbs_per_td = count_isoc_trbs_needed(xhci, urb, i);
                ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
-                                urb->stream_id, trbs_per_td, urb, i, mem_flags);
+                                urb->stream_id, trbs_per_td, urb, i, true,
-                if (ret < 0)
+                                mem_flags);
-                        return ret;
+                if (ret < 0) {
+                        if (i == 0)
+                                return ret;
+                        goto cleanup;
+                }
-                urb_priv = urb->hcpriv;
                td = urb_priv->td[i];
                for (j = 0; j < trbs_per_td; j++) {
                        u32 remainder = 0;
                        field = TRB_TBC(burst_count) | TRB_TLBPC(residue);
@@ -3325,7 +3360,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                remainder |
                                TRB_INTR_TARGET(0);
-                        queue_trb(xhci, ep_ring, false, more_trbs_coming,
+                        queue_trb(xhci, ep_ring, false, more_trbs_coming, true,
                                lower_32_bits(addr),
                                upper_32_bits(addr),
                                length_field,
@@ -3339,7 +3374,8 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                /* Check TD length */
                if (running_total != td_len) {
                        xhci_err(xhci, "ISOC TD length unmatch\n");
-                        return -EINVAL;
+                        ret = -EINVAL;
+                        goto cleanup;
                }
        }
@@ -3352,6 +3388,27 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
        giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
                        start_cycle, start_trb);
        return 0;
+cleanup:
+        /* Clean up a partially enqueued isoc transfer. */
+        for (i--; i >= 0; i--)
+                list_del_init(&urb_priv->td[i]->td_list);
+        /* Use the first TD as a temporary variable to turn the TDs we've queued
+         * into No-ops with a software-owned cycle bit. That way the hardware
+         * won't accidentally start executing bogus TDs when we partially
+         * overwrite them.  td->first_trb and td->start_seg are already set.
+         */
+        urb_priv->td[0]->last_trb = ep_ring->enqueue;
+        /* Every TRB except the first & last will have its cycle bit flipped. */
+        td_to_noop(xhci, ep_ring, urb_priv->td[0], true);
+        /* Reset the ring enqueue back to the first TRB and its cycle bit. */
+        ep_ring->enqueue = urb_priv->td[0]->first_trb;
+        ep_ring->enq_seg = urb_priv->td[0]->start_seg;
+        ep_ring->cycle_state = start_cycle;
+        usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
+        return ret;
 }
 /*
@@ -3386,7 +3443,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
         * Do not insert any td of the urb to the ring if the check failed.
         */
        ret = prepare_ring(xhci, ep_ring, le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
-                           num_trbs, mem_flags);
+                           num_trbs, true, mem_flags);
        if (ret)
                return ret;
@@ -3445,7 +3502,7 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                reserved_trbs++;
        ret = prepare_ring(xhci, xhci->cmd_ring, EP_STATE_RUNNING,
-                        reserved_trbs, GFP_ATOMIC);
+                        reserved_trbs, false, GFP_ATOMIC);
        if (ret < 0) {
                xhci_err(xhci, "ERR: No room for command on command ring\n");
                if (command_must_succeed)
@@ -3453,8 +3510,8 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                                        "unfailable commands failed.\n");
                return ret;
        }
-        queue_trb(xhci, xhci->cmd_ring, false, false, field1, field2, field3,
+        queue_trb(xhci, xhci->cmd_ring, false, false, false, field1, field2,
-                        field4 | xhci->cmd_ring->cycle_state);
+                        field3, field4 | xhci->cmd_ring->cycle_state);
        return 0;
 }
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index f5fe1ac301a..5fc595f01b3 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -345,7 +345,8 @@ static void xhci_event_ring_work(unsigned long arg)
        spin_lock_irqsave(&xhci->lock, flags);
        temp = xhci_readl(xhci, &xhci->op_regs->status);
        xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
-        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                xhci_dbg(xhci, "HW died, polling stopped.\n");
                spin_unlock_irqrestore(&xhci->lock, flags);
                return;
@@ -656,7 +657,10 @@ static void xhci_clear_command_ring(struct xhci_hcd *xhci)
        ring = xhci->cmd_ring;
        seg = ring->deq_seg;
        do {
-                memset(seg->trbs, 0, SEGMENT_SIZE);
+                memset(seg->trbs, 0,
+                        sizeof(union xhci_trb) * (TRBS_PER_SEGMENT - 1));
+                seg->trbs[TRBS_PER_SEGMENT - 1].link.control &=
+                        cpu_to_le32(~TRB_CYCLE);
                seg = seg->next;
        } while (seg != ring->deq_seg);
@@ -748,7 +752,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
        u32                     command, temp = 0;
        struct usb_hcd          *hcd = xhci_to_hcd(xhci);
        struct usb_hcd          *secondary_hcd;
-        int                     retval;
+        int                     retval = 0;
        /* Wait a bit if either of the roothubs need to settle from the
         * transition into bus suspend.
@@ -758,6 +762,9 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                                xhci->bus_state[1].next_statechange))
                msleep(100);
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
        spin_lock_irq(&xhci->lock);
        if (xhci->quirks & XHCI_RESET_ON_RESUME)
                hibernated = true;
@@ -827,20 +834,13 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                        return retval;
                xhci_dbg(xhci, "Start the primary HCD\n");
                retval = xhci_run(hcd->primary_hcd);
-                if (retval)
-                        goto failed_restart;
-                xhci_dbg(xhci, "Start the secondary HCD\n");
-                retval = xhci_run(secondary_hcd);
                if (!retval) {
-                        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+                        xhci_dbg(xhci, "Start the secondary HCD\n");
-                        set_bit(HCD_FLAG_HW_ACCESSIBLE,
+                        retval = xhci_run(secondary_hcd);
-                                        &xhci->shared_hcd->flags);
                }
-failed_restart:
                hcd->state = HC_STATE_SUSPENDED;
                xhci->shared_hcd->state = HC_STATE_SUSPENDED;
-                return retval;
+                goto done;
        }
        /* step 4: set Run/Stop bit */
@@ -859,11 +859,14 @@ failed_restart:
         * Running endpoints by ringing their doorbells
         */
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
        spin_unlock_irq(&xhci->lock);
-        return 0;
+ done:
+        if (retval == 0) {
+                usb_hcd_resume_root_hub(hcd);
+                usb_hcd_resume_root_hub(xhci->shared_hcd);
+        }
+        return retval;
 }
 #endif  /* CONFIG_PM */
@@ -939,8 +942,11 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
                return 0;
        }
+        xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_HALTED)
+                return -ENODEV;
        if (check_virt_dev) {
-                xhci = hcd_to_xhci(hcd);
                if (!udev->slot_id || !xhci->devs
                        || !xhci->devs[udev->slot_id]) {
                        printk(KERN_DEBUG "xHCI %s called with unaddressed "
@@ -1081,8 +1087,11 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                if (urb->dev->speed == USB_SPEED_FULL) {
                        ret = xhci_check_maxpacket(xhci, slot_id,
                                        ep_index, urb);
-                        if (ret < 0)
+                        if (ret < 0) {
+                                xhci_urb_free_priv(xhci, urb_priv);
+                                urb->hcpriv = NULL;
                                return ret;
+                        }
                }
                /* We have a spinlock and interrupts disabled, so we must pass
@@ -1093,6 +1102,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                        goto dying;
                ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb,
                                slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                spin_unlock_irqrestore(&xhci->lock, flags);
        } else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) {
                spin_lock_irqsave(&xhci->lock, flags);
@@ -1113,6 +1124,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                        ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
                                        slot_id, ep_index);
                }
+                if (ret)
+                        goto free_priv;
                spin_unlock_irqrestore(&xhci->lock, flags);
        } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
                spin_lock_irqsave(&xhci->lock, flags);
@@ -1120,6 +1133,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                        goto dying;
                ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb,
                                slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                spin_unlock_irqrestore(&xhci->lock, flags);
        } else {
                spin_lock_irqsave(&xhci->lock, flags);
@@ -1127,18 +1142,22 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                        goto dying;
                ret = xhci_queue_isoc_tx_prepare(xhci, GFP_ATOMIC, urb,
                                slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                spin_unlock_irqrestore(&xhci->lock, flags);
        }
 exit:
        return ret;
 dying:
-        xhci_urb_free_priv(xhci, urb_priv);
-        urb->hcpriv = NULL;
        xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for "
                        "non-responsive xHCI host.\n",
                        urb->ep->desc.bEndpointAddress, urb);
+        ret = -ESHUTDOWN;
+free_priv:
+        xhci_urb_free_priv(xhci, urb_priv);
+        urb->hcpriv = NULL;
        spin_unlock_irqrestore(&xhci->lock, flags);
-        return -ESHUTDOWN;
+        return ret;
 }
 /* Get the right ring for the given URB.
@@ -1235,6 +1254,13 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
                xhci_dbg(xhci, "HW died, freeing TD.\n");
                urb_priv = urb->hcpriv;
+                for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
+                        td = urb_priv->td[i];
+                        if (!list_empty(&td->td_list))
+                                list_del_init(&td->td_list);
+                        if (!list_empty(&td->cancelled_td_list))
+                                list_del_init(&td->cancelled_td_list);
+                }
                usb_hcd_unlink_urb_from_ep(hcd, urb);
                spin_unlock_irqrestore(&xhci->lock, flags);
@@ -1242,7 +1268,8 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                xhci_urb_free_priv(xhci, urb_priv);
                return ret;
        }
-        if (xhci->xhc_state & XHCI_STATE_DYING) {
+        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
                                "non-responsive xHCI host.\n",
                                urb->ep->desc.bEndpointAddress, urb);
@@ -1342,8 +1369,8 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
        /* If the HC already knows the endpoint is disabled,
         * or the HCD has noted it is disabled, ignore this request
         */
-        if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==
+        if (((ep_ctx->ep_info & cpu_to_le32(EP_STATE_MASK)) ==
-            EP_STATE_DISABLED ||
+             cpu_to_le32(EP_STATE_DISABLED)) ||
            le32_to_cpu(ctrl_ctx->drop_flags) &
            xhci_get_endpoint_flag(&ep->desc)) {
                xhci_warn(xhci, "xHCI %s called with disabled ep %p\n",
@@ -1541,6 +1568,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;
@@ -1758,8 +1786,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                /* Enqueue pointer can be left pointing to the link TRB,
                 * we must handle that
                 */
-                if ((le32_to_cpu(command->command_trb->link.control)
+                if (TRB_TYPE_LINK_LE32(command->command_trb->link.control))
-                     & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
                        command->command_trb =
                                xhci->cmd_ring->enq_seg->next->trbs;
@@ -1864,6 +1891,12 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
        ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
        ctrl_ctx->drop_flags &= cpu_to_le32(~(SLOT_FLAG | EP0_FLAG));
+        /* Don't issue the command if there's no endpoints to update. */
+        if (ctrl_ctx->add_flags == cpu_to_le32(SLOT_FLAG) &&
+                        ctrl_ctx->drop_flags == 0)
+                return 0;
        xhci_dbg(xhci, "New Input Control Context:\n");
        slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
        xhci_dbg_ctx(xhci, virt_dev->in_ctx,
@@ -2150,8 +2183,7 @@ static int xhci_calculate_streams_and_bitmask(struct xhci_hcd *xhci,
                if (ret < 0)
                        return ret;
-                max_streams = USB_SS_MAX_STREAMS(
+                max_streams = usb_ss_max_streams(&eps[i]->ss_ep_comp);
-                                eps[i]->ss_ep_comp.bmAttributes);
                if (max_streams < (*num_streams - 1)) {
                        xhci_dbg(xhci, "Ep 0x%x only supports %u stream IDs.\n",
                                        eps[i]->desc.bEndpointAddress,
@@ -2559,8 +2591,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
        /* Enqueue pointer can be left pointing to the link TRB,
         * we must handle that
         */
-        if ((le32_to_cpu(reset_device_cmd->command_trb->link.control)
+        if (TRB_TYPE_LINK_LE32(reset_device_cmd->command_trb->link.control))
-             & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
                reset_device_cmd->command_trb =
                        xhci->cmd_ring->enq_seg->next->trbs;
@@ -2667,7 +2698,10 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
        int i, ret;
        ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
-        if (ret <= 0)
+        /* If the host is halted due to driver unload, we still need to free the
+         * device.
+         */
+        if (ret <= 0 && ret != -ENODEV)
                return;
        virt_dev = xhci->devs[udev->slot_id];
@@ -2681,7 +2715,8 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
        spin_lock_irqsave(&xhci->lock, flags);
        /* Don't disable the slot if the host controller is dead. */
        state = xhci_readl(xhci, &xhci->op_regs->status);
-        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                xhci_free_virt_device(xhci, udev->slot_id);
                spin_unlock_irqrestore(&xhci->lock, flags);
                return;
@@ -2840,6 +2875,10 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
        /* Otherwise, update the control endpoint ring enqueue pointer. */
        else
                xhci_copy_ep0_dequeue_into_input_ctx(xhci, udev);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
+        ctrl_ctx->drop_flags = 0;
        xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
        xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
@@ -2921,7 +2960,6 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
        virt_dev->address = (le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK)
                + 1;
        /* Zero the input context control for later use */
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
        ctrl_ctx->add_flags = 0;
        ctrl_ctx->drop_flags = 0;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index d8bbf5ccb10..c149d200415 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -900,7 +900,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
@@ -1072,6 +1071,13 @@ union xhci_trb {
 /* Get NEC firmware revision. */
 #define TRB_NEC_GET_FW          49
+#define TRB_TYPE_LINK(x)        (((x) & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
+/* Above, but for __le32 types -- can avoid work by swapping constants: */
+#define TRB_TYPE_LINK_LE32(x)   (((x) & cpu_to_le32(TRB_TYPE_BITMASK)) == \
+                                 cpu_to_le32(TRB_TYPE(TRB_LINK)))
+#define TRB_TYPE_NOOP_LE32(x)   (((x) & cpu_to_le32(TRB_TYPE_BITMASK)) == \
+                                 cpu_to_le32(TRB_TYPE(TRB_TR_NOOP)))
 #define NEC_FW_MINOR(p)         (((p) >> 0) & 0xff)
 #define NEC_FW_MAJOR(p)         (((p) >> 8) & 0xff)
@@ -1311,6 +1317,7 @@ struct xhci_hcd {
 #define XHCI_EP_LIMIT_QUIRK     (1 << 5)
 #define XHCI_BROKEN_MSI         (1 << 6)
 #define XHCI_RESET_ON_RESUME    (1 << 7)
+#define XHCI_AMD_0x96_HOST      (1 << 9)
        unsigned int            num_active_eps;
        unsigned int            limit_active_eps;
        /* There are two roothubs to keep track of bus suspend info for */
@@ -1565,6 +1572,8 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                unsigned int ep_index, unsigned int stream_id);
 /* xHCI roothub code */
+void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
+                                int port_id, u32 port_bit);
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
                char *buf, u16 wLength);
 int xhci_hub_status_data(struct usb_hcd *hcd, char *buf);