18 files changed, 165 insertions, 208 deletions
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 149b13fc0a71..b948ffd94f45 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -400,6 +400,23 @@ static int ehci_hc_reset (struct usb_hcd *hcd)
                                return -EIO;
                        }
                        break;
+                case PCI_VENDOR_ID_NVIDIA:
+                        /* NVidia reports that certain chips don't handle
+                         * QH, ITD, or SITD addresses above 2GB.  (But TD,
+                         * data buffer, and periodic schedule are normal.)
+                         */
+                        switch (pdev->device) {
+                        case 0x003c:    /* MCP04 */
+                        case 0x005b:    /* CK804 */
+                        case 0x00d8:    /* CK8 */
+                        case 0x00e8:    /* CK8S */
+                                if (pci_set_consistent_dma_mask(pdev,
+                                                        DMA_31BIT_MASK) < 0)
+                                        ehci_warn (ehci, "can't enable NVidia "
+                                                "workaround for >2GB RAM\n");
+                                break;
+                        }
+                        break;
                }
                /* optional debug port, normally in the first BAR */
@@ -549,7 +566,9 @@ static int ehci_start (struct usb_hcd *hcd)
                hcd->can_wakeup = (port_wake & 1) != 0;
                /* help hc dma work well with cachelines */
-                pci_set_mwi (pdev);
+                retval = pci_set_mwi(pdev);
+                if (retval)
+                        ehci_dbg(ehci, "unable to enable MWI - not fatal.\n");
        }
 #endif
@@ -757,12 +776,16 @@ static int ehci_resume (struct usb_hcd *hcd)
        if (time_before (jiffies, ehci->next_statechange))
                msleep (100);
-        /* If any port is suspended, we know we can/must resume the HC. */
+        /* If any port is suspended (or owned by the companion),
+         * we know we can/must resume the HC (and mustn't reset it).
+         */
        for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; ) {
                u32     status;
                port--;
                status = readl (&ehci->regs->port_status [port]);
-                if (status & PORT_SUSPEND) {
+                if (!(status & PORT_POWER))
+                        continue;
+                if (status & (PORT_SUSPEND | PORT_OWNER)) {
                        down (&hcd->self.root_hub->serialize);
                        retval = ehci_hub_resume (hcd);
                        up (&hcd->self.root_hub->serialize);
@@ -1124,8 +1147,7 @@ rescan:
        case QH_STATE_UNLINK:           /* wait for hw to finish? */
 idle_timeout:
                spin_unlock_irqrestore (&ehci->lock, flags);
-                set_current_state (TASK_UNINTERRUPTIBLE);
+                schedule_timeout_uninterruptible(1);
-                schedule_timeout (1);
                goto rescan;
        case QH_STATE_IDLE:             /* fully unlinked */
                if (list_empty (&qh->qtd_list)) {
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 36cc1f2218d5..18d3f2270316 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -54,7 +54,7 @@ static int ehci_hub_suspend (struct usb_hcd *hcd)
        /* suspend any active/unsuspended ports, maybe allow wakeup */
        while (port--) {
                u32 __iomem     *reg = &ehci->regs->port_status [port];
-                u32             t1 = readl (reg);
+                u32             t1 = readl (reg) & ~PORT_RWC_BITS;
                u32             t2 = t1;
                if ((t1 & PORT_PE) && !(t1 & PORT_OWNER))
@@ -115,7 +115,8 @@ static int ehci_hub_resume (struct usb_hcd *hcd)
        i = HCS_N_PORTS (ehci->hcs_params);
        while (i--) {
                temp = readl (&ehci->regs->port_status [i]);
-                temp &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E);
+                temp &= ~(PORT_RWC_BITS
+                        | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E);
                if (temp & PORT_SUSPEND) {
                        ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
                        temp |= PORT_RESUME;
@@ -128,7 +129,7 @@ static int ehci_hub_resume (struct usb_hcd *hcd)
                temp = readl (&ehci->regs->port_status [i]);
                if ((temp & PORT_SUSPEND) == 0)
                        continue;
-                temp &= ~PORT_RESUME;
+                temp &= ~(PORT_RWC_BITS | PORT_RESUME);
                writel (temp, &ehci->regs->port_status [i]);
                ehci_vdbg (ehci, "resumed port %d\n", i + 1);
        }
@@ -191,6 +192,7 @@ static int check_reset_complete (
                // what happens if HCS_N_CC(params) == 0 ?
                port_status |= PORT_OWNER;
+                port_status &= ~PORT_RWC_BITS;
                writel (port_status, &ehci->regs->port_status [index]);
        } else
@@ -233,7 +235,8 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
                if (temp & PORT_OWNER) {
                        /* don't report this in GetPortStatus */
                        if (temp & PORT_CSC) {
-                                temp &= ~PORT_CSC;
+                                temp &= ~PORT_RWC_BITS;
+                                temp |= PORT_CSC;
                                writel (temp, &ehci->regs->port_status [i]);
                        }
                        continue;
@@ -343,7 +346,7 @@ static int ehci_hub_control (
                                &ehci->regs->port_status [wIndex]);
                        break;
                case USB_PORT_FEAT_C_ENABLE:
-                        writel (temp | PORT_PEC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_PEC,
                                &ehci->regs->port_status [wIndex]);
                        break;
                case USB_PORT_FEAT_SUSPEND:
@@ -353,7 +356,8 @@ static int ehci_hub_control (
                                if ((temp & PORT_PE) == 0)
                                        goto error;
                                /* resume signaling for 20 msec */
-                                writel ((temp & ~PORT_WAKE_BITS) | PORT_RESUME,
+                                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                                writel (temp | PORT_RESUME,
                                        &ehci->regs->port_status [wIndex]);
                                ehci->reset_done [wIndex] = jiffies
                                                + msecs_to_jiffies (20);
@@ -364,15 +368,15 @@ static int ehci_hub_control (
                        break;
                case USB_PORT_FEAT_POWER:
                        if (HCS_PPC (ehci->hcs_params))
-                                writel (temp & ~PORT_POWER,
+                                writel (temp & ~(PORT_RWC_BITS | PORT_POWER),
                                        &ehci->regs->port_status [wIndex]);
                        break;
                case USB_PORT_FEAT_C_CONNECTION:
-                        writel (temp | PORT_CSC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_CSC,
                                &ehci->regs->port_status [wIndex]);
                        break;
                case USB_PORT_FEAT_C_OVER_CURRENT:
-                        writel (temp | PORT_OCC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_OCC,
                                &ehci->regs->port_status [wIndex]);
                        break;
                case USB_PORT_FEAT_C_RESET:
@@ -416,7 +420,7 @@ static int ehci_hub_control (
                        /* stop resume signaling */
                        temp = readl (&ehci->regs->port_status [wIndex]);
-                        writel (temp & ~PORT_RESUME,
+                        writel (temp & ~(PORT_RWC_BITS | PORT_RESUME),
                                &ehci->regs->port_status [wIndex]);
                        retval = handshake (
                                        &ehci->regs->port_status [wIndex],
@@ -437,7 +441,7 @@ static int ehci_hub_control (
                        ehci->reset_done [wIndex] = 0;
                        /* force reset to complete */
-                        writel (temp & ~PORT_RESET,
+                        writel (temp & ~(PORT_RWC_BITS | PORT_RESET),
                                        &ehci->regs->port_status [wIndex]);
                        /* REVISIT:  some hardware needs 550+ usec to clear
                         * this bit; seems too long to spin routinely...
@@ -500,6 +504,7 @@ static int ehci_hub_control (
                if (temp & PORT_OWNER)
                        break;
+                temp &= ~PORT_RWC_BITS;
                switch (wValue) {
                case USB_PORT_FEAT_SUSPEND:
                        if ((temp & PORT_PE) == 0
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 20df01a79b2e..940d38ca7d91 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -677,6 +677,9 @@ qh_make (
                                goto done;
                        }
                } else {
+                        struct usb_tt   *tt = urb->dev->tt;
+                        int             think_time;
                        /* gap is f(FS/LS transfer times) */
                        qh->gap_uf = 1 + usb_calc_bus_time (urb->dev->speed,
                                        is_input, 0, maxp) / (125 * 1000);
@@ -690,6 +693,10 @@ qh_make (
                                qh->c_usecs = HS_USECS (0);
                        }
+                        think_time = tt ? tt->think_time : 0;
+                        qh->tt_usecs = NS_TO_US (think_time +
+                                        usb_calc_bus_time (urb->dev->speed,
+                                        is_input, 0, max_packet (maxp)));
                        qh->period = urb->interval;
                }
        }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 4c972b57c7c3..ccc7300baa6d 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -700,6 +700,7 @@ iso_stream_init (
        } else {
                u32             addr;
+                int             think_time;
                addr = dev->ttport << 24;
                if (!ehci_is_TDI(ehci)
@@ -709,6 +710,9 @@ iso_stream_init (
                addr |= epnum << 8;
                addr |= dev->devnum;
                stream->usecs = HS_USECS_ISO (maxp);
+                think_time = dev->tt ? dev->tt->think_time : 0;
+                stream->tt_usecs = NS_TO_US (think_time + usb_calc_bus_time (
+                                dev->speed, is_input, 1, maxp));
                if (is_input) {
                        u32     tmp;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index a7542157534c..f34a0516d35f 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -263,6 +263,7 @@ struct ehci_regs {
 #define PORT_PE         (1<<2)          /* port enable */
 #define PORT_CSC        (1<<1)          /* connect status change */
 #define PORT_CONNECT    (1<<0)          /* device connected */
+#define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_OCC)
 } __attribute__ ((packed));
 /* Appendix C, Debug port ... intended for use with special "debug devices"
@@ -421,6 +422,7 @@ struct ehci_qh {
        u8                      usecs;          /* intr bandwidth */
        u8                      gap_uf;         /* uframes split/csplit gap */
        u8                      c_usecs;        /* ... split completion bw */
+        u16                     tt_usecs;       /* tt downstream bandwidth */
        unsigned short          period;         /* polling interval */
        unsigned short          start;          /* where polling starts */
 #define NO_FRAME ((unsigned short)~0)                   /* pick new start */
@@ -479,6 +481,7 @@ struct ehci_iso_stream {
         */
        u8                      interval;
        u8                      usecs, c_usecs;
+        u16                     tt_usecs;
        u16                     maxp;
        u16                     raw_mask;
        unsigned                bandwidth;
diff --git a/drivers/usb/host/hc_crisv10.c b/drivers/usb/host/hc_crisv10.c
index 81f8f6b7fdce..a8267cf17db4 100644
--- a/drivers/usb/host/hc_crisv10.c
+++ b/drivers/usb/host/hc_crisv10.c
@@ -178,8 +178,8 @@ static __u8 root_hub_hub_des[] =
        0xff   /*  __u8  PortPwrCtrlMask; *** 7 ports max *** */
 };
-static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
+static DEFINE_TIMER(bulk_start_timer, NULL, 0, 0);
-static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
+static DEFINE_TIMER(bulk_eot_timer, NULL, 0, 0);
 /* We want the start timer to expire before the eot timer, because the former might start
   traffic, thus making it unnecessary for the latter to time out. */
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 75128c371800..41bbae83fc71 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -83,7 +83,7 @@
 #include "../core/hcd.h"
 #include "isp116x.h"
-#define DRIVER_VERSION  "08 Apr 2005"
+#define DRIVER_VERSION  "05 Aug 2005"
 #define DRIVER_DESC     "ISP116x USB Host Controller Driver"
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -629,14 +629,12 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                        ERR("Unrecoverable error\n");
                        /* What should we do here? Reset?  */
                }
-                if (intstat & HCINT_RHSC) {
+                if (intstat & HCINT_RHSC)
-                        isp116x->rhstatus =
+                        /* When root hub or any of its ports is going
-                            isp116x_read_reg32(isp116x, HCRHSTATUS);
+                           to come out of suspend, it may take more
-                        isp116x->rhport[0] =
+                           than 10ms for status bits to stabilize. */
-                            isp116x_read_reg32(isp116x, HCRHPORT1);
+                        mod_timer(&hcd->rh_timer, jiffies
-                        isp116x->rhport[1] =
+                                  + msecs_to_jiffies(20) + 1);
-                            isp116x_read_reg32(isp116x, HCRHPORT2);
-                }
                if (intstat & HCINT_RD) {
                        DBG("---- remote wakeup\n");
                        schedule_work(&isp116x->rh_resume);
@@ -925,20 +923,27 @@ static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
        struct isp116x *isp116x = hcd_to_isp116x(hcd);
        int ports, i, changed = 0;
+        unsigned long flags;
        if (!HC_IS_RUNNING(hcd->state))
                return -ESHUTDOWN;
-        ports = isp116x->rhdesca & RH_A_NDP;
+        /* Report no status change now, if we are scheduled to be
+           called later */
+        if (timer_pending(&hcd->rh_timer))
+                return 0;
-        /* init status */
+        ports = isp116x->rhdesca & RH_A_NDP;
+        spin_lock_irqsave(&isp116x->lock, flags);
+        isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
        if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
                buf[0] = changed = 1;
        else
                buf[0] = 0;
        for (i = 0; i < ports; i++) {
-                u32 status = isp116x->rhport[i];
+                u32 status = isp116x->rhport[i] =
+                    isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
                if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
                              | RH_PS_OCIC | RH_PS_PRSC)) {
@@ -947,6 +952,7 @@ static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
                        continue;
                }
        }
+        spin_unlock_irqrestore(&isp116x->lock, flags);
        return changed;
 }
@@ -1463,10 +1469,6 @@ static int isp116x_sw_reset(struct isp116x *isp116x)
        return ret;
 }
-/*
-  Reset. Tries to perform platform-specific hardware
-  reset first; falls back to software reset.
-*/
 static int isp116x_reset(struct usb_hcd *hcd)
 {
        struct isp116x *isp116x = hcd_to_isp116x(hcd);
@@ -1474,17 +1476,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
        u16 clkrdy = 0;
        int ret = 0, timeout = 15 /* ms */ ;
-        if (isp116x->board && isp116x->board->reset) {
+        ret = isp116x_sw_reset(isp116x);
-                /* Hardware reset */
-                isp116x->board->reset(hcd->self.controller, 1);
-                msleep(10);
-                if (isp116x->board->clock)
-                        isp116x->board->clock(hcd->self.controller, 1);
-                msleep(1);
-                isp116x->board->reset(hcd->self.controller, 0);
-        } else
-                ret = isp116x_sw_reset(isp116x);
        if (ret)
                return ret;
@@ -1501,10 +1493,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
                ERR("Clock not ready after 20ms\n");
                /* After sw_reset the clock won't report to be ready, if
                   H_WAKEUP pin is high. */
-                if (!isp116x->board || !isp116x->board->reset)
+                ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
-                        ERR("The driver does not support hardware wakeup.\n");
-                        ERR("Please make sure that the H_WAKEUP pin "
-                                "is pulled low!\n");
                ret = -ENODEV;
        }
        return ret;
@@ -1527,15 +1516,7 @@ static void isp116x_stop(struct usb_hcd *hcd)
        isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
        spin_unlock_irqrestore(&isp116x->lock, flags);
-        /* Put the chip into reset state */
+        isp116x_sw_reset(isp116x);
-        if (isp116x->board && isp116x->board->reset)
-                isp116x->board->reset(hcd->self.controller, 0);
-        else
-                isp116x_sw_reset(isp116x);
-        /* Stop the clock */
-        if (isp116x->board && isp116x->board->clock)
-                isp116x->board->clock(hcd->self.controller, 0);
 }
 /*
@@ -1561,6 +1542,9 @@ static int isp116x_start(struct usb_hcd *hcd)
                return -ENODEV;
        }
+        /* To be removed in future */
+        hcd->uses_new_polling = 1;
        isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
        isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
@@ -1569,7 +1553,7 @@ static int isp116x_start(struct usb_hcd *hcd)
        if (board->sel15Kres)
                val |= HCHWCFG_15KRSEL;
        /* Remote wakeup won't work without working clock */
-        if (board->clknotstop || board->remote_wakeup_enable)
+        if (board->remote_wakeup_enable)
                val |= HCHWCFG_CLKNOTSTOP;
        if (board->oc_enable)
                val |= HCHWCFG_ANALOG_OC;
@@ -1580,16 +1564,13 @@ static int isp116x_start(struct usb_hcd *hcd)
        isp116x_write_reg16(isp116x, HCHWCFG, val);
        /* ----- Root hub conf */
-        val = 0;
+        val = (25 << 24) & RH_A_POTPGT;
-        /* AN10003_1.pdf recommends NPS to be always 1 */
+        /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
-        if (board->no_power_switching)
+           be always set. Yet, instead, we request individual port
-                val |= RH_A_NPS;
+           power switching. */
-        if (board->power_switching_mode)
+        val |= RH_A_PSM;
-                val |= RH_A_PSM;
+        /* Report overcurrent per port */
-        if (board->potpg)
+        val |= RH_A_OCPM;
-                val |= (board->potpg << 24) & RH_A_POTPGT;
-        else
-                val |= (25 << 24) & RH_A_POTPGT;
        isp116x_write_reg32(isp116x, HCRHDESCA, val);
        isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
@@ -1619,9 +1600,6 @@ static int isp116x_start(struct usb_hcd *hcd)
        /* Go operational */
        val = HCCONTROL_USB_OPER;
-        /* Remote wakeup connected - NOT SUPPORTED */
-        /*  if (board->remote_wakeup_connected)
-           val |= HCCONTROL_RWC;  */
        if (board->remote_wakeup_enable)
                val |= HCCONTROL_RWE;
        isp116x_write_reg32(isp116x, HCCONTROL, val);
@@ -1670,7 +1648,7 @@ static int __init_or_module isp116x_remove(struct device *dev)
        struct platform_device *pdev;
        struct resource *res;
-        if(!hcd)
+        if (!hcd)
                return 0;
        isp116x = hcd_to_isp116x(hcd);
        pdev = container_of(dev, struct platform_device, dev);
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 447f488f5d93..7924c74f958e 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -228,23 +228,22 @@ ohci_dump_roothub (
        char **next,
        unsigned *size)
 {
-        u32                     temp, ndp, i;
+        u32                     temp, i;
        temp = roothub_a (controller);
        if (temp == ~(u32)0)
                return;
-        ndp = (temp & RH_A_NDP);
        if (verbose) {
                ohci_dbg_sw (controller, next, size,
-                        "roothub.a %08x POTPGT=%d%s%s%s%s%s NDP=%d\n", temp,
+                        "roothub.a %08x POTPGT=%d%s%s%s%s%s NDP=%d(%d)\n", temp,
                        ((temp & RH_A_POTPGT) >> 24) & 0xff,
                        (temp & RH_A_NOCP) ? " NOCP" : "",
                        (temp & RH_A_OCPM) ? " OCPM" : "",
                        (temp & RH_A_DT) ? " DT" : "",
                        (temp & RH_A_NPS) ? " NPS" : "",
                        (temp & RH_A_PSM) ? " PSM" : "",
-                        ndp
+                        (temp & RH_A_NDP), controller->num_ports
                        );
                temp = roothub_b (controller);
                ohci_dbg_sw (controller, next, size,
@@ -266,7 +265,7 @@ ohci_dump_roothub (
                        );
        }
-        for (i = 0; i < ndp; i++) {
+        for (i = 0; i < controller->num_ports; i++) {
                temp = roothub_portstatus (controller, i);
                dbg_port_sw (controller, i, temp, next, size);
        }
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 56b43f2a0e52..67c1aa5eb1c1 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -382,8 +382,7 @@ sanitize:
                        goto sanitize;
                }
                spin_unlock_irqrestore (&ohci->lock, flags);
-                set_current_state (TASK_UNINTERRUPTIBLE);
+                schedule_timeout_uninterruptible(1);
-                schedule_timeout (1);
                goto rescan;
        case ED_IDLE:           /* fully unlinked */
                if (list_empty (&ed->td_list)) {
@@ -485,6 +484,10 @@ static int ohci_init (struct ohci_hcd *ohci)
        // flush the writes
        (void) ohci_readl (ohci, &ohci->regs->control);
+        /* Read the number of ports unless overridden */
+        if (ohci->num_ports == 0)
+                ohci->num_ports = roothub_a(ohci) & RH_A_NDP;
        if (ohci->hcca)
                return 0;
@@ -561,10 +564,8 @@ static int ohci_run (struct ohci_hcd *ohci)
        msleep(temp);
        temp = roothub_a (ohci);
        if (!(temp & RH_A_NPS)) {
-                unsigned ports = temp & RH_A_NDP; 
                /* power down each port */
-                for (temp = 0; temp < ports; temp++)
+                for (temp = 0; temp < ohci->num_ports; temp++)
                        ohci_writel (ohci, RH_PS_LSDA,
                                &ohci->regs->roothub.portstatus [temp]);
        }
@@ -720,6 +721,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd, struct pt_regs *ptregs)
        if (ints & OHCI_INTR_RD) {
                ohci_vdbg (ohci, "resume detect\n");
+                ohci_writel (ohci, OHCI_INTR_RD, &regs->intrstatus);
                if (hcd->state != HC_STATE_QUIESCING)
                        schedule_work(&ohci->rh_resume);
        }
@@ -861,7 +863,7 @@ static int ohci_restart (struct ohci_hcd *ohci)
                 * and that if we try to turn them back on the root hub
                 * will respond to CSC processing.
                 */
-                i = roothub_a (ohci) & RH_A_NDP;
+                i = ohci->num_ports;
                while (i--)
                        ohci_writel (ohci, RH_PS_PSS,
                                &ohci->regs->roothub.portstatus [temp]);
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 83ca4549a50e..ce7b28da7a15 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -184,7 +184,7 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
        if (status != -EINPROGRESS)
                return status;
-        temp = roothub_a (ohci) & RH_A_NDP;
+        temp = ohci->num_ports;
        enables = 0;
        while (temp--) {
                u32 stat = ohci_readl (ohci,
@@ -304,7 +304,7 @@ static int
 ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
 {
        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ports, i, changed = 0, length = 1;
+        int             i, changed = 0, length = 1;
        int             can_suspend = hcd->can_wakeup;
        unsigned long   flags;
@@ -319,9 +319,10 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
                goto done;
        }
-        ports = roothub_a (ohci) & RH_A_NDP; 
+        /* undocumented erratum seen on at least rev D */
-        if (ports > MAX_ROOT_PORTS) {
+        if ((ohci->flags & OHCI_QUIRK_AMD756)
-                ohci_err (ohci, "bogus NDP=%d, rereads as NDP=%d\n", ports,
+                        && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
+                ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
                          ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
                /* retry later; "should not happen" */
                goto done;
@@ -332,13 +333,13 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
                buf [0] = changed = 1;
        else
                buf [0] = 0;
-        if (ports > 7) {
+        if (ohci->num_ports > 7) {
                buf [1] = 0;
                length++;
        }
        /* look at each port */
-        for (i = 0; i < ports; i++) {
+        for (i = 0; i < ohci->num_ports; i++) {
                u32     status = roothub_portstatus (ohci, i);
                if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
@@ -395,15 +396,14 @@ ohci_hub_descriptor (
        struct usb_hub_descriptor       *desc
 ) {
        u32             rh = roothub_a (ohci);
-        int             ports = rh & RH_A_NDP; 
        u16             temp;
        desc->bDescriptorType = 0x29;
        desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
        desc->bHubContrCurrent = 0;
-        desc->bNbrPorts = ports;
+        desc->bNbrPorts = ohci->num_ports;
-        temp = 1 + (ports / 8);
+        temp = 1 + (ohci->num_ports / 8);
        desc->bDescLength = 7 + 2 * temp;
        temp = 0;
@@ -421,7 +421,7 @@ ohci_hub_descriptor (
        rh = roothub_b (ohci);
        memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
        desc->bitmap [0] = rh & RH_B_DR;
-        if (ports > 7) {
+        if (ohci->num_ports > 7) {
                desc->bitmap [1] = (rh & RH_B_DR) >> 8;
                desc->bitmap [2] = 0xff;
        } else
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 17964c39d06a..251533363028 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -14,8 +14,6 @@
 * This file is licenced under the GPL.
 */
-#include <asm/usb.h>
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -23,9 +21,7 @@
 * usb_hcd_ppc_soc_probe - initialize On-Chip HCDs
 * Context: !in_interrupt()
 *
- * Allocates basic resources for this USB host controller, and
+ * Allocates basic resources for this USB host controller.
- * then invokes the start() method for the HCD associated with it
- * through the hotplug entry's driver_data.
 *
 * Store this function in the HCD's struct pci_driver as probe().
 */
@@ -37,7 +33,6 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
        struct ohci_hcd *ohci;
        struct resource *res;
        int irq;
-        struct usb_hcd_platform_data *pd = pdev->dev.platform_data;
        pr_debug("initializing PPC-SOC USB Controller\n");
@@ -73,9 +68,6 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
                goto err2;
        }
-        if (pd->start && (retval = pd->start(pdev)))
-                goto err3;
        ohci = hcd_to_ohci(hcd);
        ohci->flags |= OHCI_BIG_ENDIAN;
        ohci_hcd_init(ohci);
@@ -85,9 +77,7 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
                return retval;
        pr_debug("Removing PPC-SOC USB Controller\n");
-        if (pd && pd->stop)
-                pd->stop(pdev);
- err3:
        iounmap(hcd->regs);
 err2:
        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
@@ -105,25 +95,21 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
 * @pdev: USB Host Controller being removed
 * Context: !in_interrupt()
 *
- * Reverses the effect of usb_hcd_ppc_soc_probe(), first invoking
+ * Reverses the effect of usb_hcd_ppc_soc_probe().
- * the HCD's stop() method.  It is always called from a thread
+ * It is always called from a thread
 * context, normally "rmmod", "apmd", or something similar.
 *
 */
 static void usb_hcd_ppc_soc_remove(struct usb_hcd *hcd,
                struct platform_device *pdev)
 {
-        struct usb_hcd_platform_data *pd = pdev->dev.platform_data;
        usb_remove_hcd(hcd);
        pr_debug("stopping PPC-SOC USB Controller\n");
-        if (pd && pd->stop)
-                pd->stop(pdev);
        iounmap(hcd->regs);
        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_hcd_put(hcd);
+        usb_put_hcd(hcd);
 }
 static int __devinit
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index e5bc1789d18a..2fdb262d4726 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -75,33 +75,6 @@ static int pxa27x_ohci_select_pmm( int mode )
        return 0;
 }
-/*
-  If you select PMM_PERPORT_MODE, you should set the port power
- */
-static int pxa27x_ohci_set_port_power( int port )
-{
-        if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE)
-             && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
-                UHCRHPS(port) |= 0x100;
-                return 0;
-        }
-        return -1;
-}
-/*
-  If you select PMM_PERPORT_MODE, you should set the port power
- */
-static int pxa27x_ohci_clear_port_power( int port )
-{
-        if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE) 
-             && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
-                UHCRHPS(port) |= 0x200;
-                return 0;
-        }
-         
-        return -1;
-}
 extern int usb_disabled(void);
 /*-------------------------------------------------------------------------*/
@@ -130,11 +103,17 @@ static void pxa27x_start_hc(struct platform_device *dev)
                   Polarity Low to active low. Supply power to USB ports. */
                UHCHR = (UHCHR | UHCHR_PCPL | UHCHR_PSPL) &
                        ~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE);
+                pxa27x_ohci_pmm_state = PMM_PERPORT_MODE;
        }
        UHCHR &= ~UHCHR_SSE;
        UHCHIE = (UHCHIE_UPRIE | UHCHIE_RWIE);
+        /* Clear any OTG Pin Hold */
+        if (PSSR & PSSR_OTGPH)
+                PSSR |= PSSR_OTGPH;
 }
 static void pxa27x_stop_hc(struct platform_device *dev)
@@ -198,17 +177,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver,
        pxa27x_start_hc(dev);
        /* Select Power Management Mode */
-        pxa27x_ohci_select_pmm( PMM_PERPORT_MODE );
+        pxa27x_ohci_select_pmm(pxa27x_ohci_pmm_state);
-        /* If choosing PMM_PERPORT_MODE, we should set the port power before we use it. */
-        if (pxa27x_ohci_set_port_power(1) < 0)
-                printk(KERN_ERR "Setting port 1 power failed.\n");
-        if (pxa27x_ohci_clear_port_power(2) < 0)
-                printk(KERN_ERR "Setting port 2 power failed.\n");
-        if (pxa27x_ohci_clear_port_power(3) < 0)
-                printk(KERN_ERR "Setting port 3 power failed.\n");
        ohci_hcd_init(hcd_to_ohci(hcd));
@@ -258,6 +227,9 @@ ohci_pxa27x_start (struct usb_hcd *hcd)
        ohci_dbg (ohci, "ohci_pxa27x_start, ohci:%p", ohci);
+        /* The value of NDP in roothub_a is incorrect on this hardware */
+        ohci->num_ports = 3;
        if ((ret = ohci_init(ohci)) < 0)
                return ret;
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index e9401662503c..3d9bcf78a9a4 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -129,7 +129,7 @@ static void s3c2410_usb_set_power(struct s3c2410_hcd_info *info,
        if (info->power_control != NULL) {
                info->port[port-1].power = to;
-                (info->power_control)(port, to);
+                (info->power_control)(port-1, to);
        }
 }
@@ -339,8 +339,8 @@ int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
        struct usb_hcd *hcd = NULL;
        int retval;
-        s3c2410_usb_set_power(dev->dev.platform_data, 0, 1);
        s3c2410_usb_set_power(dev->dev.platform_data, 1, 1);
+        s3c2410_usb_set_power(dev->dev.platform_data, 2, 1);
        hcd = usb_create_hcd(driver, &dev->dev, "s3c24xx");
        if (hcd == NULL)
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 71cdd2262860..8a9b9d9209e9 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -383,6 +383,7 @@ struct ohci_hcd {
        /*
         * driver state
         */
+        int                     num_ports;
        int                     load [NUM_INTS];
        u32                     hc_control;     /* copy of hc control reg */
        unsigned long           next_statechange;       /* suspend/resume */
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 0d5d2545bf07..0c024898cbea 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -97,14 +97,9 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
 /* to make sure it doesn't hog all of the bandwidth */
 #define DEPTH_INTERVAL 5
-static inline void restart_timer(struct uhci_hcd *uhci)
-{
-        mod_timer(&uhci->stall_timer, jiffies + msecs_to_jiffies(100));
-}
-#include "uhci-hub.c"
 #include "uhci-debug.c"
 #include "uhci-q.c"
+#include "uhci-hub.c"
 /*
 * Make sure the controller is completely inactive, unable to
@@ -160,7 +155,6 @@ static void hc_died(struct uhci_hcd *uhci)
 {
        reset_hc(uhci);
        uhci->hc_inaccessible = 1;
-        del_timer(&uhci->stall_timer);
 }
 /*
@@ -287,8 +281,11 @@ __acquires(uhci->lock)
        /* Enable resume-detect interrupts if they work.
         * Then enter Global Suspend mode, still configured.
         */
-        int_enable = (resume_detect_interrupts_are_broken(uhci) ?
+        uhci->working_RD = 1;
-                        0 : USBINTR_RESUME);
+        int_enable = USBINTR_RESUME;
+        if (resume_detect_interrupts_are_broken(uhci)) {
+                uhci->working_RD = int_enable = 0;
+        }
        outw(int_enable, uhci->io_addr + USBINTR);
        outw(USBCMD_EGSM | USBCMD_CF, uhci->io_addr + USBCMD);
        mb();
@@ -315,7 +312,6 @@ __acquires(uhci->lock)
        uhci->rh_state = new_state;
        uhci->is_stopped = UHCI_IS_STOPPED;
-        del_timer(&uhci->stall_timer);
        uhci_to_hcd(uhci)->poll_rh = !int_enable;
        uhci_scan_schedule(uhci, NULL);
@@ -335,7 +331,6 @@ static void start_rh(struct uhci_hcd *uhci)
        mb();
        uhci->rh_state = UHCI_RH_RUNNING;
        uhci_to_hcd(uhci)->poll_rh = 1;
-        restart_timer(uhci);
 }
 static void wakeup_rh(struct uhci_hcd *uhci)
@@ -374,20 +369,6 @@ __acquires(uhci->lock)
        mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
 }
-static void stall_callback(unsigned long _uhci)
-{
-        struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci;
-        unsigned long flags;
-        spin_lock_irqsave(&uhci->lock, flags);
-        uhci_scan_schedule(uhci, NULL);
-        check_fsbr(uhci);
-        if (!uhci->is_stopped)
-                restart_timer(uhci);
-        spin_unlock_irqrestore(&uhci->lock, flags);
-}
 static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
 {
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
@@ -418,8 +399,10 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                                        "host controller halted, "
                                        "very bad!\n");
                                hc_died(uhci);
-                                spin_unlock_irqrestore(&uhci->lock, flags);
-                                return IRQ_HANDLED;
+                                /* Force a callback in case there are
+                                 * pending unlinks */
+                                mod_timer(&hcd->rh_timer, jiffies);
                        }
                        spin_unlock_irqrestore(&uhci->lock, flags);
                }
@@ -427,10 +410,11 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
        if (status & USBSTS_RD)
                usb_hcd_poll_rh_status(hcd);
+        else {
-        spin_lock_irqsave(&uhci->lock, flags);
+                spin_lock_irqsave(&uhci->lock, flags);
-        uhci_scan_schedule(uhci, regs);
+                uhci_scan_schedule(uhci, regs);
-        spin_unlock_irqrestore(&uhci->lock, flags);
+                spin_unlock_irqrestore(&uhci->lock, flags);
+        }
        return IRQ_HANDLED;
 }
@@ -595,10 +579,6 @@ static int uhci_start(struct usb_hcd *hcd)
        init_waitqueue_head(&uhci->waitqh);
-        init_timer(&uhci->stall_timer);
-        uhci->stall_timer.function = stall_callback;
-        uhci->stall_timer.data = (unsigned long) uhci;
        uhci->fl = dma_alloc_coherent(uhci_dev(uhci), sizeof(*uhci->fl),
                        &dma_handle, 0);
        if (!uhci->fl) {
@@ -745,11 +725,11 @@ static void uhci_stop(struct usb_hcd *hcd)
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
        spin_lock_irq(&uhci->lock);
-        reset_hc(uhci);
+        if (!uhci->hc_inaccessible)
+                reset_hc(uhci);
        uhci_scan_schedule(uhci, NULL);
        spin_unlock_irq(&uhci->lock);
-        del_timer_sync(&uhci->stall_timer);
        release_uhci(uhci);
 }
@@ -811,13 +791,12 @@ static int uhci_suspend(struct usb_hcd *hcd, pm_message_t message)
         */
        pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP, 0);
        uhci->hc_inaccessible = 1;
+        hcd->poll_rh = 0;
        /* FIXME: Enable non-PME# remote wakeup? */
 done:
        spin_unlock_irq(&uhci->lock);
-        if (rc == 0)
-                del_timer_sync(&hcd->rh_timer);
        return rc;
 }
@@ -850,8 +829,11 @@ static int uhci_resume(struct usb_hcd *hcd)
        spin_unlock_irq(&uhci->lock);
-        if (hcd->poll_rh)
+        if (!uhci->working_RD) {
+                /* Suspended root hub needs to be polled */
+                hcd->poll_rh = 1;
                usb_hcd_poll_rh_status(hcd);
+        }
        return 0;
 }
 #endif
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index bf9c5f9b508b..282f40b75881 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -345,9 +345,6 @@ enum uhci_rh_state {
 /*
 * This describes the full uhci information.
- *
- * Note how the "proper" USB information is just
- * a subset of what the full implementation needs.
 */
 struct uhci_hcd {
@@ -360,8 +357,6 @@ struct uhci_hcd {
        struct dma_pool *qh_pool;
        struct dma_pool *td_pool;
-        struct usb_bus *bus;
        struct uhci_td *term_td;        /* Terminating TD, see UHCI bug */
        struct uhci_qh *skelqh[UHCI_NUM_SKELQH];        /* Skeleton QH's */
@@ -380,6 +375,8 @@ struct uhci_hcd {
        unsigned int scan_in_progress:1;        /* Schedule scan is running */
        unsigned int need_rescan:1;             /* Redo the schedule scan */
        unsigned int hc_inaccessible:1;         /* HC is suspended or dead */
+        unsigned int working_RD:1;              /* Suspended root hub doesn't
+                                                   need to be polled */
        /* Support for port suspend/resume/reset */
        unsigned long port_c_suspend;           /* Bit-arrays of ports */
@@ -405,9 +402,7 @@ struct uhci_hcd {
        /* List of URB's awaiting completion callback */
        struct list_head complete_list;         /* P: uhci->lock */
-        int rh_numports;
+        int rh_numports;                        /* Number of root-hub ports */
-        struct timer_list stall_timer;
        wait_queue_head_t waitqh;               /* endpoint_disable waiters */
 };
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 4eace2b19ddb..a71e48a66805 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -145,15 +145,16 @@ static int uhci_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
        unsigned long flags;
-        int status;
+        int status = 0;
        spin_lock_irqsave(&uhci->lock, flags);
-        if (uhci->hc_inaccessible) {
-                status = 0;
-                goto done;
-        }
+        uhci_scan_schedule(uhci, NULL);
+        if (uhci->hc_inaccessible)
+                goto done;
+        check_fsbr(uhci);
        uhci_check_ports(uhci);
        status = get_hub_status_data(uhci, buf);
        switch (uhci->rh_state) {
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index bbb36cd6ed61..ea0d168a8c67 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -33,7 +33,7 @@ static void uhci_free_pending_tds(struct uhci_hcd *uhci);
 static inline void uhci_set_next_interrupt(struct uhci_hcd *uhci)
 {
        if (uhci->is_stopped)
-                mod_timer(&uhci->stall_timer, jiffies);
+                mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
        uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC); 
 }