14 files changed, 45 insertions, 49 deletions

diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 9b66df8278f3..40d886adff53 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -173,12 +173,9 @@ static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
          * mark HW unaccessible, bail out if RH has been resumed. Use
          * the spinlock to properly synchronize with possible pending
          * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
          */
         spin_lock_irqsave(&ohci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
+        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
                 rc = -EINVAL;
                 goto bail;
         }
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index d7d34492934a..5179fcd73d8a 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -127,6 +127,19 @@ static char *hcfs2string (int state)
         return "?";
 }
 
+static const char *rh_state_string(struct ohci_hcd *ohci)
+{
+        switch (ohci->rh_state) {
+        case OHCI_RH_HALTED:
+                return "halted";
+        case OHCI_RH_SUSPENDED:
+                return "suspended";
+        case OHCI_RH_RUNNING:
+                return "running";
+        }
+        return "?";
+}
+
 // dump control and status registers
 static void
 ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size)
@@ -136,9 +149,10 @@ ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size)
 
         temp = ohci_readl (controller, &regs->revision) & 0xff;
         ohci_dbg_sw (controller, next, size,
-                "OHCI %d.%d, %s legacy support registers\n",
+                "OHCI %d.%d, %s legacy support registers, rh state %s\n",
                 0x03 & (temp >> 4), (temp & 0x0f),
-                (temp & 0x0100) ? "with" : "NO");
+                (temp & 0x0100) ? "with" : "NO",
+                rh_state_string(controller));
 
         temp = ohci_readl (controller, &regs->control);
         ohci_dbg_sw (controller, next, size,
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index dc45d489d00e..3d63574d2c7e 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -179,8 +179,6 @@ static int ohci_hcd_ep93xx_drv_suspend(struct platform_device *pdev, pm_message_
         ohci->next_statechange = jiffies;
 
         ep93xx_stop_hc(&pdev->dev);
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 34efd479e068..03c4631dc27a 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -209,7 +209,7 @@ static int ohci_urb_enqueue (
                 retval = -ENODEV;
                 goto fail;
         }
-        if (!HC_IS_RUNNING(hcd->state)) {
+        if (ohci->rh_state != OHCI_RH_RUNNING) {
                 retval = -ENODEV;
                 goto fail;
         }
@@ -274,7 +274,7 @@ static int ohci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
         if (rc) {
                 ;       /* Do nothing */
-        } else if (HC_IS_RUNNING(hcd->state)) {
+        } else if (ohci->rh_state == OHCI_RH_RUNNING) {
                 urb_priv_t  *urb_priv;
 
                 /* Unless an IRQ completed the unlink while it was being
@@ -321,7 +321,7 @@ ohci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
 rescan:
         spin_lock_irqsave (&ohci->lock, flags);
 
-        if (!HC_IS_RUNNING (hcd->state)) {
+        if (ohci->rh_state != OHCI_RH_RUNNING) {
 sanitize:
                 ed->state = ED_IDLE;
                 if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT)
@@ -377,6 +377,7 @@ static void ohci_usb_reset (struct ohci_hcd *ohci)
         ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
         ohci->hc_control &= OHCI_CTRL_RWC;
         ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
+        ohci->rh_state = OHCI_RH_HALTED;
 }
 
 /* ohci_shutdown forcibly disables IRQs and DMA, helping kexec and
@@ -503,7 +504,7 @@ static int ohci_init (struct ohci_hcd *ohci)
         if (distrust_firmware)
                 ohci->flags |= OHCI_QUIRK_HUB_POWER;
 
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
         ohci->regs = hcd->regs;
 
         /* REVISIT this BIOS handshake is now moved into PCI "quirks", and
@@ -578,7 +579,7 @@ static int ohci_run (struct ohci_hcd *ohci)
         int                     first = ohci->fminterval == 0;
         struct usb_hcd          *hcd = ohci_to_hcd(ohci);
 
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
 
         /* boot firmware should have set this up (5.1.1.3.1) */
         if (first) {
@@ -691,7 +692,7 @@ retry:
         ohci->hc_control &= OHCI_CTRL_RWC;
         ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
         ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
-        hcd->state = HC_STATE_RUNNING;
+        ohci->rh_state = OHCI_RH_RUNNING;
 
         /* wake on ConnectStatusChange, matching external hubs */
         ohci_writel (ohci, RH_HS_DRWE, &ohci->regs->roothub.status);
@@ -728,7 +729,6 @@ retry:
 
         // POTPGT delay is bits 24-31, in 2 ms units.
         mdelay ((val >> 23) & 0x1fe);
-        hcd->state = HC_STATE_RUNNING;
 
         if (quirk_zfmicro(ohci)) {
                 /* Create timer to watch for bad queue state on ZF Micro */
@@ -764,7 +764,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
          * of dead, unclocked, or unplugged (CardBus...) devices
          */
         if (ints == ~(u32)0) {
-                disable (ohci);
+                ohci->rh_state = OHCI_RH_HALTED;
                 ohci_dbg (ohci, "device removed!\n");
                 usb_hc_died(hcd);
                 return IRQ_HANDLED;
@@ -774,7 +774,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         ints &= ohci_readl(ohci, &regs->intrenable);
 
         /* interrupt for some other device? */
-        if (ints == 0 || unlikely(hcd->state == HC_STATE_HALT))
+        if (ints == 0 || unlikely(ohci->rh_state == OHCI_RH_HALTED))
                 return IRQ_NOTMINE;
 
         if (ints & OHCI_INTR_UE) {
@@ -789,8 +789,8 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
 
                         schedule_work (&ohci->nec_work);
                 } else {
-                        disable (ohci);
                         ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");
+                        ohci->rh_state = OHCI_RH_HALTED;
                         usb_hc_died(hcd);
                 }
 
@@ -874,11 +874,11 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         if ((ints & OHCI_INTR_SF) != 0
                         && !ohci->ed_rm_list
                         && !ohci->ed_to_check
-                        && HC_IS_RUNNING(hcd->state))
+                        && ohci->rh_state == OHCI_RH_RUNNING)
                 ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable);
         spin_unlock (&ohci->lock);
 
-        if (HC_IS_RUNNING(hcd->state)) {
+        if (ohci->rh_state == OHCI_RH_RUNNING) {
                 ohci_writel (ohci, ints, &regs->intrstatus);
                 ohci_writel (ohci, OHCI_INTR_MIE, &regs->intrenable);
                 // flush those writes
@@ -932,7 +932,7 @@ static int ohci_restart (struct ohci_hcd *ohci)
         struct urb_priv *priv;
 
         spin_lock_irq(&ohci->lock);
-        disable (ohci);
+        ohci->rh_state = OHCI_RH_HALTED;
 
         /* Recycle any "live" eds/tds (and urbs). */
         if (!list_empty (&ohci->pending))
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 2f00040fc408..836772dfabd3 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -111,6 +111,7 @@ __acquires(ohci->lock)
         if (!autostop) {
                 ohci->next_statechange = jiffies + msecs_to_jiffies (5);
                 ohci->autostop = 0;
+                ohci->rh_state = OHCI_RH_SUSPENDED;
         }
 
 done:
@@ -140,7 +141,7 @@ __acquires(ohci->lock)
 
         if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
                 /* this can happen after resuming a swsusp snapshot */
-                if (hcd->state == HC_STATE_RESUMING) {
+                if (ohci->rh_state != OHCI_RH_RUNNING) {
                         ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
                                         ohci->hc_control);
                         status = -EBUSY;
@@ -274,6 +275,7 @@ skip_resume:
                 (void) ohci_readl (ohci, &ohci->regs->control);
         }
 
+        ohci->rh_state = OHCI_RH_RUNNING;
         return 0;
 }
 
@@ -336,11 +338,8 @@ static void ohci_finish_controller_resume(struct usb_hcd *hcd)
         /* If needed, reinitialize and suspend the root hub */
         if (need_reinit) {
                 spin_lock_irq(&ohci->lock);
-                hcd->state = HC_STATE_RESUMING;
                 ohci_rh_resume(ohci);
-                hcd->state = HC_STATE_QUIESCING;
                 ohci_rh_suspend(ohci, 0);
-                hcd->state = HC_STATE_SUSPENDED;
                 spin_unlock_irq(&ohci->lock);
         }
 
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index e4b8782cc6e2..db3968656d21 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -516,7 +516,6 @@ static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
         ohci->next_statechange = jiffies;
 
         omap_ohci_clock_power(0);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index ad8166c681e2..847187df50a1 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -334,12 +334,9 @@ static int ohci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
          * mark HW unaccessible, bail out if RH has been resumed. Use
          * the spinlock to properly synchronize with possible pending
          * RH suspend or resume activity.
-         *
-         * This is still racy as hcd->state is manipulated outside of
-         * any locks =P But that will be a different fix.
          */
         spin_lock_irqsave (&ohci->lock, flags);
-        if (hcd->state != HC_STATE_SUSPENDED) {
+        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
                 rc = -EINVAL;
                 goto bail;
         }
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 29dfefe1c726..6313e4439f37 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -502,8 +502,6 @@ static int ohci_hcd_pxa27x_drv_suspend(struct device *dev)
         ohci->ohci.next_statechange = jiffies;
 
         pxa27x_stop_hc(ohci, dev);
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 15dc51ded61a..c5a1ea9145fa 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -912,7 +912,7 @@ rescan_all:
                 /* only take off EDs that the HC isn't using, accounting for
                  * frame counter wraps and EDs with partially retired TDs
                  */
-                if (likely (HC_IS_RUNNING(ohci_to_hcd(ohci)->state))) {
+                if (likely(ohci->rh_state == OHCI_RH_RUNNING)) {
                         if (tick_before (tick, ed->tick)) {
 skip_ed:
                                 last = &ed->ed_next;
@@ -1012,7 +1012,7 @@ rescan_this:
 
                 /* but if there's work queued, reschedule */
                 if (!list_empty (&ed->td_list)) {
-                        if (HC_IS_RUNNING(ohci_to_hcd(ohci)->state))
+                        if (ohci->rh_state == OHCI_RH_RUNNING)
                                 ed_schedule (ohci, ed);
                 }
 
@@ -1021,9 +1021,7 @@ rescan_this:
         }
 
         /* maybe reenable control and bulk lists */
-        if (HC_IS_RUNNING(ohci_to_hcd(ohci)->state)
-                        && ohci_to_hcd(ohci)->state != HC_STATE_QUIESCING
-                        && !ohci->ed_rm_list) {
+        if (ohci->rh_state == OHCI_RH_RUNNING && !ohci->ed_rm_list) {
                 u32     command = 0, control = 0;
 
                 if (ohci->ed_controltail) {
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index afc4eb6bb9d0..84686d90805b 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -29,7 +29,6 @@ static int ohci_sh_start(struct usb_hcd *hcd)
         ohci_hcd_init(ohci);
         ohci_init(ohci);
         ohci_run(ohci);
-        hcd->state = HC_STATE_RUNNING;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 968cea2b6d4e..5596ac2ba1ca 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -224,7 +224,6 @@ static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
         ohci->next_statechange = jiffies;
 
         sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 69874654f3b5..95c16489e883 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -203,7 +203,6 @@ static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
         ohci->next_statechange = jiffies;
 
         spear_stop_ohci(ohci_p);
-        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 06331d931171..120bfe6ede38 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -318,9 +318,6 @@ static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t s
                 if (ret)
                         return ret;
         }
-
-        hcd->state = HC_STATE_SUSPENDED;
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 35e5fd640ce7..3a978a2130cb 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -344,6 +344,12 @@ typedef struct urb_priv {
  * a subset of what the full implementation needs. (Linus)
  */
 
+enum ohci_rh_state {
+        OHCI_RH_HALTED,
+        OHCI_RH_SUSPENDED,
+        OHCI_RH_RUNNING
+};
+
 struct ohci_hcd {
         spinlock_t              lock;
 
@@ -384,6 +390,7 @@ struct ohci_hcd {
         /*
          * driver state
          */
+        enum ohci_rh_state      rh_state;
         int                     num_ports;
         int                     load [NUM_INTS];
         u32                     hc_control;     /* copy of hc control reg */
@@ -680,11 +687,6 @@ static inline u16 ohci_hwPSW(const struct ohci_hcd *ohci,
 
 /*-------------------------------------------------------------------------*/
 
-static inline void disable (struct ohci_hcd *ohci)
-{
-        ohci_to_hcd(ohci)->state = HC_STATE_HALT;
-}
-
 #define FI                      0x2edf          /* 12000 bits per frame (-1) */
 #define FSMP(fi)                (0x7fff & ((6 * ((fi) - 210)) / 7))
 #define FIT                     (1 << 31)
@@ -708,7 +710,7 @@ static inline void periodic_reinit (struct ohci_hcd *ohci)
 #define read_roothub(hc, register, mask) ({ \
         u32 temp = ohci_readl (hc, &hc->regs->roothub.register); \
         if (temp == -1) \
-                disable (hc); \
+                hc->rh_state = OHCI_RH_HALTED; \
         else if (hc->flags & OHCI_QUIRK_AMD756) \
                 while (temp & mask) \
                         temp = ohci_readl (hc, &hc->regs->roothub.register); \