lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

OHCI: remove uses of hcd->state

Browse Source 
This patch (as1500) removes all uses of the objectionable hcd->state
variable from the ohci-hcd family of drivers.  It is replaced by a
private ohci->rh_state field, just as in uhci-hcd and ehci-hcd.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Alan Stern
2011-11-17 16:41:56 -05:00
committed by Greg Kroah-Hartman
parent c6249ff752
commit b7463c71fb
14 changed files with 45 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/usb/host/ohci-au1xxx.c
View File

@@ -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 * mark HW unaccessible, bail out if RH has been resumed. Use
* the spinlock to properly synchronize with possible pending * the spinlock to properly synchronize with possible pending
* RH suspend or resume activity. * 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); spin_lock_irqsave(&ohci->lock, flags);
if (hcd->state != HC_STATE_SUSPENDED) { if (ohci->rh_state != OHCI_RH_SUSPENDED) {
rc = -EINVAL; rc = -EINVAL;
goto bail; goto bail;
} }

18
drivers/usb/host/ohci-dbg.c
View File

@@ -127,6 +127,19 @@ static char *hcfs2string (int state)
return "?"; 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 // dump control and status registers
static void static void
ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size) 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; temp = ohci_readl (controller, &regs->revision) & 0xff;
ohci_dbg_sw (controller, next, size, 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), 0x03 & (temp >> 4), (temp & 0x0f),
(temp & 0x0100) ? "with" : "NO"); (temp & 0x0100) ? "with" : "NO",
rh_state_string(controller));
temp = ohci_readl (controller, &regs->control); temp = ohci_readl (controller, &regs->control);
ohci_dbg_sw (controller, next, size, ohci_dbg_sw (controller, next, size,

2
drivers/usb/host/ohci-ep93xx.c
View File

@@ -179,8 +179,6 @@ static int ohci_hcd_ep93xx_drv_suspend(struct platform_device *pdev, pm_message_
ohci->next_statechange = jiffies; ohci->next_statechange = jiffies;
ep93xx_stop_hc(&pdev->dev); ep93xx_stop_hc(&pdev->dev);
hcd->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

26
drivers/usb/host/ohci-hcd.c
View File

@@ -209,7 +209,7 @@ static int ohci_urb_enqueue (
retval = -ENODEV; retval = -ENODEV;
goto fail; goto fail;
} }
if (!HC_IS_RUNNING(hcd->state)) { if (ohci->rh_state != OHCI_RH_RUNNING) {
retval = -ENODEV; retval = -ENODEV;
goto fail; 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); rc = usb_hcd_check_unlink_urb(hcd, urb, status);
if (rc) { if (rc) {
; /* Do nothing */ ; /* Do nothing */
} else if (HC_IS_RUNNING(hcd->state)) { } else if (ohci->rh_state == OHCI_RH_RUNNING) {
urb_priv_t *urb_priv; urb_priv_t *urb_priv;
/* Unless an IRQ completed the unlink while it was being /* 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: rescan:
spin_lock_irqsave (&ohci->lock, flags); spin_lock_irqsave (&ohci->lock, flags);
if (!HC_IS_RUNNING (hcd->state)) { if (ohci->rh_state != OHCI_RH_RUNNING) {
sanitize: sanitize:
ed->state = ED_IDLE; ed->state = ED_IDLE;
if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT) 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_readl (ohci, &ohci->regs->control);
ohci->hc_control &= OHCI_CTRL_RWC; ohci->hc_control &= OHCI_CTRL_RWC;
ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 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 /* 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) if (distrust_firmware)
ohci->flags |= OHCI_QUIRK_HUB_POWER; ohci->flags |= OHCI_QUIRK_HUB_POWER;
disable (ohci); ohci->rh_state = OHCI_RH_HALTED;
ohci->regs = hcd->regs; ohci->regs = hcd->regs;
/* REVISIT this BIOS handshake is now moved into PCI "quirks", and /* 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; int first = ohci->fminterval == 0;
struct usb_hcd *hcd = ohci_to_hcd(ohci); 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) */ /* boot firmware should have set this up (5.1.1.3.1) */
if (first) { if (first) {
@@ -691,7 +692,7 @@ retry:
ohci->hc_control &= OHCI_CTRL_RWC; ohci->hc_control &= OHCI_CTRL_RWC;
ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER; ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 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 */ /* wake on ConnectStatusChange, matching external hubs */
ohci_writel (ohci, RH_HS_DRWE, &ohci->regs->roothub.status); 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. // POTPGT delay is bits 24-31, in 2 ms units.
mdelay ((val >> 23) & 0x1fe); mdelay ((val >> 23) & 0x1fe);
hcd->state = HC_STATE_RUNNING;
if (quirk_zfmicro(ohci)) { if (quirk_zfmicro(ohci)) {
/* Create timer to watch for bad queue state on ZF Micro */ /* 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 * of dead, unclocked, or unplugged (CardBus...) devices
*/ */
if (ints == ~(u32)0) { if (ints == ~(u32)0) {
disable (ohci); ohci->rh_state = OHCI_RH_HALTED;
ohci_dbg (ohci, "device removed!\n"); ohci_dbg (ohci, "device removed!\n");
usb_hc_died(hcd); usb_hc_died(hcd);
return IRQ_HANDLED; return IRQ_HANDLED;
@@ -774,7 +774,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
ints &= ohci_readl(ohci, &regs->intrenable); ints &= ohci_readl(ohci, &regs->intrenable);
/* interrupt for some other device? */ /* 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; return IRQ_NOTMINE;
if (ints & OHCI_INTR_UE) { if (ints & OHCI_INTR_UE) {
@@ -789,8 +789,8 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
schedule_work (&ohci->nec_work); schedule_work (&ohci->nec_work);
} else { } else {
disable (ohci);
ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n"); ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");
ohci->rh_state = OHCI_RH_HALTED;
usb_hc_died(hcd); usb_hc_died(hcd);
} }
@@ -874,11 +874,11 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
if ((ints & OHCI_INTR_SF) != 0 if ((ints & OHCI_INTR_SF) != 0
&& !ohci->ed_rm_list && !ohci->ed_rm_list
&& !ohci->ed_to_check && !ohci->ed_to_check
&& HC_IS_RUNNING(hcd->state)) && ohci->rh_state == OHCI_RH_RUNNING)
ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable); ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable);
spin_unlock (&ohci->lock); 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, ints, &regs->intrstatus);
ohci_writel (ohci, OHCI_INTR_MIE, &regs->intrenable); ohci_writel (ohci, OHCI_INTR_MIE, &regs->intrenable);
// flush those writes // flush those writes
@@ -932,7 +932,7 @@ static int ohci_restart (struct ohci_hcd *ohci)
struct urb_priv *priv; struct urb_priv *priv;
spin_lock_irq(&ohci->lock); spin_lock_irq(&ohci->lock);
disable (ohci); ohci->rh_state = OHCI_RH_HALTED;
/* Recycle any "live" eds/tds (and urbs). */ /* Recycle any "live" eds/tds (and urbs). */
if (!list_empty (&ohci->pending)) if (!list_empty (&ohci->pending))

7
drivers/usb/host/ohci-hub.c
View File

@@ -111,6 +111,7 @@ __acquires(ohci->lock)
if (!autostop) { if (!autostop) {
ohci->next_statechange = jiffies + msecs_to_jiffies (5); ohci->next_statechange = jiffies + msecs_to_jiffies (5);
ohci->autostop = 0; ohci->autostop = 0;
ohci->rh_state = OHCI_RH_SUSPENDED;
} }
done: done:
@@ -140,7 +141,7 @@ __acquires(ohci->lock)
if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) { if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
/* this can happen after resuming a swsusp snapshot */ /* 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_dbg (ohci, "BIOS/SMM active, control %03x\n",
ohci->hc_control); ohci->hc_control);
status = -EBUSY; status = -EBUSY;
@@ -274,6 +275,7 @@ skip_resume:
(void) ohci_readl (ohci, &ohci->regs->control); (void) ohci_readl (ohci, &ohci->regs->control);
} }
ohci->rh_state = OHCI_RH_RUNNING;
return 0; 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 needed, reinitialize and suspend the root hub */
if (need_reinit) { if (need_reinit) {
spin_lock_irq(&ohci->lock); spin_lock_irq(&ohci->lock);
hcd->state = HC_STATE_RESUMING;
ohci_rh_resume(ohci); ohci_rh_resume(ohci);
hcd->state = HC_STATE_QUIESCING;
ohci_rh_suspend(ohci, 0); ohci_rh_suspend(ohci, 0);
hcd->state = HC_STATE_SUSPENDED;
spin_unlock_irq(&ohci->lock); spin_unlock_irq(&ohci->lock);
} }

1
drivers/usb/host/ohci-omap.c
View File

@@ -516,7 +516,6 @@ static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
ohci->next_statechange = jiffies; ohci->next_statechange = jiffies;
omap_ohci_clock_power(0); omap_ohci_clock_power(0);
ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

5
drivers/usb/host/ohci-pci.c
View File

@@ -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 * mark HW unaccessible, bail out if RH has been resumed. Use
* the spinlock to properly synchronize with possible pending * the spinlock to properly synchronize with possible pending
* RH suspend or resume activity. * 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); spin_lock_irqsave (&ohci->lock, flags);
if (hcd->state != HC_STATE_SUSPENDED) { if (ohci->rh_state != OHCI_RH_SUSPENDED) {
rc = -EINVAL; rc = -EINVAL;
goto bail; goto bail;
} }

2
drivers/usb/host/ohci-pxa27x.c
View File

@@ -502,8 +502,6 @@ static int ohci_hcd_pxa27x_drv_suspend(struct device *dev)
ohci->ohci.next_statechange = jiffies; ohci->ohci.next_statechange = jiffies;
pxa27x_stop_hc(ohci, dev); pxa27x_stop_hc(ohci, dev);
hcd->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

8
drivers/usb/host/ohci-q.c
View File

@@ -912,7 +912,7 @@ rescan_all:
/* only take off EDs that the HC isn't using, accounting for /* only take off EDs that the HC isn't using, accounting for
* frame counter wraps and EDs with partially retired TDs * 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)) { if (tick_before (tick, ed->tick)) {
skip_ed: skip_ed:
last = &ed->ed_next; last = &ed->ed_next;
@@ -1012,7 +1012,7 @@ rescan_this:
/* but if there's work queued, reschedule */ /* but if there's work queued, reschedule */
if (!list_empty (&ed->td_list)) { 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); ed_schedule (ohci, ed);
} }
@@ -1021,9 +1021,7 @@ rescan_this:
} }
/* maybe reenable control and bulk lists */ /* maybe reenable control and bulk lists */
if (HC_IS_RUNNING(ohci_to_hcd(ohci)->state) if (ohci->rh_state == OHCI_RH_RUNNING && !ohci->ed_rm_list) {
&& ohci_to_hcd(ohci)->state != HC_STATE_QUIESCING
&& !ohci->ed_rm_list) {
u32 command = 0, control = 0; u32 command = 0, control = 0;
if (ohci->ed_controltail) { if (ohci->ed_controltail) {

1
drivers/usb/host/ohci-sh.c
View File

@@ -29,7 +29,6 @@ static int ohci_sh_start(struct usb_hcd *hcd)
ohci_hcd_init(ohci); ohci_hcd_init(ohci);
ohci_init(ohci); ohci_init(ohci);
ohci_run(ohci); ohci_run(ohci);
hcd->state = HC_STATE_RUNNING;
return 0; return 0;
} }

1
drivers/usb/host/ohci-sm501.c
View File

@@ -224,7 +224,6 @@ static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
ohci->next_statechange = jiffies; ohci->next_statechange = jiffies;
sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0); sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

1
drivers/usb/host/ohci-spear.c
View File

@@ -203,7 +203,6 @@ static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
ohci->next_statechange = jiffies; ohci->next_statechange = jiffies;
spear_stop_ohci(ohci_p); spear_stop_ohci(ohci_p);
ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

3
drivers/usb/host/ohci-tmio.c
View File

@@ -318,9 +318,6 @@ static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t s
if (ret) if (ret)
return ret; return ret;
} }
hcd->state = HC_STATE_SUSPENDED;
return 0; return 0;
} }

14
drivers/usb/host/ohci.h
View File

@@ -344,6 +344,12 @@ typedef struct urb_priv {
* a subset of what the full implementation needs. (Linus) * 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 { struct ohci_hcd {
spinlock_t lock; spinlock_t lock;
@@ -384,6 +390,7 @@ struct ohci_hcd {
/* /*
* driver state * driver state
*/ */
enum ohci_rh_state rh_state;
int num_ports; int num_ports;
int load [NUM_INTS]; int load [NUM_INTS];
u32 hc_control; /* copy of hc control reg */ 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 FI 0x2edf /* 12000 bits per frame (-1) */
#define FSMP(fi) (0x7fff & ((6 * ((fi) - 210)) / 7)) #define FSMP(fi) (0x7fff & ((6 * ((fi) - 210)) / 7))
#define FIT (1 << 31) #define FIT (1 << 31)
@@ -708,7 +710,7 @@ static inline void periodic_reinit (struct ohci_hcd *ohci)
#define read_roothub(hc, register, mask) ({ \ #define read_roothub(hc, register, mask) ({ \
u32 temp = ohci_readl (hc, &hc->regs->roothub.register); \ u32 temp = ohci_readl (hc, &hc->regs->roothub.register); \
if (temp == -1) \ if (temp == -1) \
disable (hc); \ hc->rh_state = OHCI_RH_HALTED; \
else if (hc->flags & OHCI_QUIRK_AMD756) \ else if (hc->flags & OHCI_QUIRK_AMD756) \
while (temp & mask) \ while (temp & mask) \
temp = ohci_readl (hc, &hc->regs->roothub.register); \ temp = ohci_readl (hc, &hc->regs->roothub.register); \