2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2011-06-15 20:32:46 +00:00
|
|
|
* Open Host Controller Interface (OHCI) driver for USB.
|
|
|
|
*
|
|
|
|
* Maintainer: Alan Stern <stern@rowland.harvard.edu>
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
|
|
|
|
* (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
|
2006-12-05 11:18:31 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* [ Initialisation is based on Linus' ]
|
|
|
|
* [ uhci code and gregs ohci fragments ]
|
|
|
|
* [ (C) Copyright 1999 Linus Torvalds ]
|
|
|
|
* [ (C) Copyright 1999 Gregory P. Smith]
|
2006-12-05 11:18:31 +00:00
|
|
|
*
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* OHCI is the main "non-Intel/VIA" standard for USB 1.1 host controller
|
|
|
|
* interfaces (though some non-x86 Intel chips use it). It supports
|
|
|
|
* smarter hardware than UHCI. A download link for the spec available
|
|
|
|
* through the http://www.usb.org website.
|
|
|
|
*
|
|
|
|
* This file is licenced under the GPL.
|
|
|
|
*/
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/usb.h>
|
2006-06-29 19:27:23 +00:00
|
|
|
#include <linux/usb/otg.h>
|
2010-04-24 21:21:52 +00:00
|
|
|
#include <linux/usb/hcd.h>
|
2006-12-05 11:18:31 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
2005-04-23 19:49:16 +00:00
|
|
|
#include <linux/dmapool.h>
|
2007-05-31 21:34:27 +00:00
|
|
|
#include <linux/workqueue.h>
|
2007-09-11 21:07:31 +00:00
|
|
|
#include <linux/debugfs.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
|
|
|
|
|
|
|
#define DRIVER_AUTHOR "Roman Weissgaerber, David Brownell"
|
|
|
|
#define DRIVER_DESC "USB 1.1 'Open' Host Controller (OHCI) Driver"
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
[PATCH] USB: Fix USB suspend/resume crasher (#2)
This patch closes the IRQ race and makes various other OHCI & EHCI code
path safer vs. suspend/resume.
I've been able to (finally !) successfully suspend and resume various
Mac models, with or without USB mouse plugged, or plugging while asleep,
or unplugging while asleep etc... all without a crash.
Alan, please verify the UHCI bit I did, I only verified that it builds.
It's very simple so I wouldn't expect any issue there. If you aren't
confident, then just drop the hunks that change uhci-hcd.c
I also made the patch a little bit more "safer" by making sure the store
to the interrupt register that disables interrupts is not posted before
I set the flag and drop the spinlock.
Without this patch, you cannot reliably sleep/wakeup any recent Mac, and
I suspect PCs have some more sneaky issues too (they don't frankly crash
with machine checks because x86 tend to silently swallow PCI errors but
that won't last afaik, at least PCI Express will blow up in those
situations, but the USB code may still misbehave).
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-11-24 22:59:46 +00:00
|
|
|
#undef OHCI_VERBOSE_DEBUG /* not always helpful */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* For initializing controller (mask in an HCFS mode too) */
|
2006-08-04 18:31:55 +00:00
|
|
|
#define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
|
2005-04-16 22:20:36 +00:00
|
|
|
#define OHCI_INTR_INIT \
|
2006-08-04 18:31:55 +00:00
|
|
|
(OHCI_INTR_MIE | OHCI_INTR_RHSC | OHCI_INTR_UE \
|
|
|
|
| OHCI_INTR_RD | OHCI_INTR_WDH)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef __hppa__
|
|
|
|
/* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
|
|
|
|
#define IR_DISABLE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_ARCH_OMAP
|
|
|
|
/* OMAP doesn't support IR (no SMM; not needed) */
|
|
|
|
#define IR_DISABLE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static const char hcd_name [] = "ohci_hcd";
|
|
|
|
|
2006-08-04 18:31:55 +00:00
|
|
|
#define STATECHANGE_DELAY msecs_to_jiffies(300)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci.h"
|
2011-03-01 06:57:05 +00:00
|
|
|
#include "pci-quirks.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static void ohci_dump (struct ohci_hcd *ohci, int verbose);
|
|
|
|
static int ohci_init (struct ohci_hcd *ohci);
|
|
|
|
static void ohci_stop (struct usb_hcd *hcd);
|
2007-10-25 00:23:42 +00:00
|
|
|
|
|
|
|
#if defined(CONFIG_PM) || defined(CONFIG_PCI)
|
2007-05-31 21:34:27 +00:00
|
|
|
static int ohci_restart (struct ohci_hcd *ohci);
|
2007-10-25 00:23:42 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-08 07:03:31 +00:00
|
|
|
#ifdef CONFIG_PCI
|
2009-11-04 06:55:18 +00:00
|
|
|
static void sb800_prefetch(struct ohci_hcd *ohci, int on);
|
2008-08-08 07:03:31 +00:00
|
|
|
#else
|
2009-11-04 06:55:18 +00:00
|
|
|
static inline void sb800_prefetch(struct ohci_hcd *ohci, int on)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2008-08-08 07:03:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci-hub.c"
|
|
|
|
#include "ohci-dbg.c"
|
|
|
|
#include "ohci-mem.c"
|
|
|
|
#include "ohci-q.c"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On architectures with edge-triggered interrupts we must never return
|
|
|
|
* IRQ_NONE.
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_SA1111) /* ... or other edge-triggered systems */
|
|
|
|
#define IRQ_NOTMINE IRQ_HANDLED
|
|
|
|
#else
|
|
|
|
#define IRQ_NOTMINE IRQ_NONE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* Some boards misreport power switching/overcurrent */
|
|
|
|
static int distrust_firmware = 1;
|
|
|
|
module_param (distrust_firmware, bool, 0);
|
|
|
|
MODULE_PARM_DESC (distrust_firmware,
|
|
|
|
"true to distrust firmware power/overcurrent setup");
|
|
|
|
|
|
|
|
/* Some boards leave IR set wrongly, since they fail BIOS/SMM handshakes */
|
|
|
|
static int no_handshake = 0;
|
|
|
|
module_param (no_handshake, bool, 0);
|
|
|
|
MODULE_PARM_DESC (no_handshake, "true (not default) disables BIOS handshake");
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* queue up an urb for anything except the root hub
|
|
|
|
*/
|
|
|
|
static int ohci_urb_enqueue (
|
|
|
|
struct usb_hcd *hcd,
|
|
|
|
struct urb *urb,
|
2005-10-21 07:21:58 +00:00
|
|
|
gfp_t mem_flags
|
2005-04-16 22:20:36 +00:00
|
|
|
) {
|
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
struct ed *ed;
|
|
|
|
urb_priv_t *urb_priv;
|
|
|
|
unsigned int pipe = urb->pipe;
|
|
|
|
int i, size = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
int retval = 0;
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef OHCI_VERBOSE_DEBUG
|
2007-08-24 19:40:34 +00:00
|
|
|
urb_print(urb, "SUB", usb_pipein(pipe), -EINPROGRESS);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* every endpoint has a ed, locate and maybe (re)initialize it */
|
2007-08-08 15:48:02 +00:00
|
|
|
if (! (ed = ed_get (ohci, urb->ep, urb->dev, pipe, urb->interval)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* for the private part of the URB we need the number of TDs (size) */
|
|
|
|
switch (ed->type) {
|
|
|
|
case PIPE_CONTROL:
|
|
|
|
/* td_submit_urb() doesn't yet handle these */
|
|
|
|
if (urb->transfer_buffer_length > 4096)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
/* 1 TD for setup, 1 for ACK, plus ... */
|
|
|
|
size = 2;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
// case PIPE_INTERRUPT:
|
|
|
|
// case PIPE_BULK:
|
|
|
|
default:
|
2011-03-31 01:57:33 +00:00
|
|
|
/* one TD for every 4096 Bytes (can be up to 8K) */
|
2005-04-16 22:20:36 +00:00
|
|
|
size += urb->transfer_buffer_length / 4096;
|
|
|
|
/* ... and for any remaining bytes ... */
|
|
|
|
if ((urb->transfer_buffer_length % 4096) != 0)
|
|
|
|
size++;
|
|
|
|
/* ... and maybe a zero length packet to wrap it up */
|
|
|
|
if (size == 0)
|
|
|
|
size++;
|
|
|
|
else if ((urb->transfer_flags & URB_ZERO_PACKET) != 0
|
|
|
|
&& (urb->transfer_buffer_length
|
|
|
|
% usb_maxpacket (urb->dev, pipe,
|
|
|
|
usb_pipeout (pipe))) == 0)
|
|
|
|
size++;
|
|
|
|
break;
|
|
|
|
case PIPE_ISOCHRONOUS: /* number of packets from URB */
|
|
|
|
size = urb->number_of_packets;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate the private part of the URB */
|
some kmalloc/memset ->kzalloc (tree wide)
Transform some calls to kmalloc/memset to a single kzalloc (or kcalloc).
Here is a short excerpt of the semantic patch performing
this transformation:
@@
type T2;
expression x;
identifier f,fld;
expression E;
expression E1,E2;
expression e1,e2,e3,y;
statement S;
@@
x =
- kmalloc
+ kzalloc
(E1,E2)
... when != \(x->fld=E;\|y=f(...,x,...);\|f(...,x,...);\|x=E;\|while(...) S\|for(e1;e2;e3) S\)
- memset((T2)x,0,E1);
@@
expression E1,E2,E3;
@@
- kzalloc(E1 * E2,E3)
+ kcalloc(E1,E2,E3)
[akpm@linux-foundation.org: get kcalloc args the right way around]
Signed-off-by: Yoann Padioleau <padator@wanadoo.fr>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Acked-by: Russell King <rmk@arm.linux.org.uk>
Cc: Bryan Wu <bryan.wu@analog.com>
Acked-by: Jiri Slaby <jirislaby@gmail.com>
Cc: Dave Airlie <airlied@linux.ie>
Acked-by: Roland Dreier <rolandd@cisco.com>
Cc: Jiri Kosina <jkosina@suse.cz>
Acked-by: Dmitry Torokhov <dtor@mail.ru>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Acked-by: Mauro Carvalho Chehab <mchehab@infradead.org>
Acked-by: Pierre Ossman <drzeus-list@drzeus.cx>
Cc: Jeff Garzik <jeff@garzik.org>
Cc: "David S. Miller" <davem@davemloft.net>
Acked-by: Greg KH <greg@kroah.com>
Cc: James Bottomley <James.Bottomley@steeleye.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 08:49:03 +00:00
|
|
|
urb_priv = kzalloc (sizeof (urb_priv_t) + size * sizeof (struct td *),
|
2005-04-16 22:20:36 +00:00
|
|
|
mem_flags);
|
|
|
|
if (!urb_priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
INIT_LIST_HEAD (&urb_priv->pending);
|
|
|
|
urb_priv->length = size;
|
2006-12-05 11:18:31 +00:00
|
|
|
urb_priv->ed = ed;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* allocate the TDs (deferring hash chain updates) */
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
urb_priv->td [i] = td_alloc (ohci, mem_flags);
|
|
|
|
if (!urb_priv->td [i]) {
|
|
|
|
urb_priv->length = i;
|
|
|
|
urb_free_priv (ohci, urb_priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2006-12-05 11:18:31 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave (&ohci->lock, flags);
|
|
|
|
|
|
|
|
/* don't submit to a dead HC */
|
2010-06-22 20:39:10 +00:00
|
|
|
if (!HCD_HW_ACCESSIBLE(hcd)) {
|
[PATCH] USB: Fix USB suspend/resume crasher (#2)
This patch closes the IRQ race and makes various other OHCI & EHCI code
path safer vs. suspend/resume.
I've been able to (finally !) successfully suspend and resume various
Mac models, with or without USB mouse plugged, or plugging while asleep,
or unplugging while asleep etc... all without a crash.
Alan, please verify the UHCI bit I did, I only verified that it builds.
It's very simple so I wouldn't expect any issue there. If you aren't
confident, then just drop the hunks that change uhci-hcd.c
I also made the patch a little bit more "safer" by making sure the store
to the interrupt register that disables interrupts is not posted before
I set the flag and drop the spinlock.
Without this patch, you cannot reliably sleep/wakeup any recent Mac, and
I suspect PCs have some more sneaky issues too (they don't frankly crash
with machine checks because x86 tend to silently swallow PCI errors but
that won't last afaik, at least PCI Express will blow up in those
situations, but the USB code may still misbehave).
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-11-24 22:59:46 +00:00
|
|
|
retval = -ENODEV;
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!HC_IS_RUNNING(hcd->state)) {
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto fail;
|
|
|
|
}
|
2007-08-08 15:48:02 +00:00
|
|
|
retval = usb_hcd_link_urb_to_ep(hcd, urb);
|
|
|
|
if (retval)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* schedule the ed if needed */
|
|
|
|
if (ed->state == ED_IDLE) {
|
|
|
|
retval = ed_schedule (ohci, ed);
|
2007-08-08 15:48:02 +00:00
|
|
|
if (retval < 0) {
|
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ed->type == PIPE_ISOCHRONOUS) {
|
|
|
|
u16 frame = ohci_frame_no(ohci);
|
|
|
|
|
|
|
|
/* delay a few frames before the first TD */
|
|
|
|
frame += max_t (u16, 8, ed->interval);
|
|
|
|
frame &= ~(ed->interval - 1);
|
|
|
|
frame |= ed->branch;
|
|
|
|
urb->start_frame = frame;
|
|
|
|
|
|
|
|
/* yes, only URB_ISO_ASAP is supported, and
|
|
|
|
* urb->start_frame is never used as input.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
} else if (ed->type == PIPE_ISOCHRONOUS)
|
|
|
|
urb->start_frame = ed->last_iso + ed->interval;
|
|
|
|
|
|
|
|
/* fill the TDs and link them to the ed; and
|
|
|
|
* enable that part of the schedule, if needed
|
|
|
|
* and update count of queued periodic urbs
|
|
|
|
*/
|
|
|
|
urb->hcpriv = urb_priv;
|
|
|
|
td_submit_urb (ohci, urb);
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (retval)
|
|
|
|
urb_free_priv (ohci, urb_priv);
|
|
|
|
spin_unlock_irqrestore (&ohci->lock, flags);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-08-24 19:40:34 +00:00
|
|
|
* decouple the URB from the HC queues (TDs, urb_priv).
|
|
|
|
* reporting is always done
|
2005-04-16 22:20:36 +00:00
|
|
|
* asynchronously, and we might be dealing with an urb that's
|
|
|
|
* partially transferred, or an ED with other urbs being unlinked.
|
|
|
|
*/
|
2007-08-08 15:48:02 +00:00
|
|
|
static int ohci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
unsigned long flags;
|
2007-08-08 15:48:02 +00:00
|
|
|
int rc;
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef OHCI_VERBOSE_DEBUG
|
2007-08-24 19:40:34 +00:00
|
|
|
urb_print(urb, "UNLINK", 1, status);
|
2006-12-05 11:18:31 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave (&ohci->lock, flags);
|
2007-08-08 15:48:02 +00:00
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
if (rc) {
|
|
|
|
; /* Do nothing */
|
|
|
|
} else if (HC_IS_RUNNING(hcd->state)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
urb_priv_t *urb_priv;
|
|
|
|
|
|
|
|
/* Unless an IRQ completed the unlink while it was being
|
|
|
|
* handed to us, flag it for unlink and giveback, and force
|
|
|
|
* some upcoming INTR_SF to call finish_unlinks()
|
|
|
|
*/
|
|
|
|
urb_priv = urb->hcpriv;
|
|
|
|
if (urb_priv) {
|
|
|
|
if (urb_priv->ed->state == ED_OPER)
|
|
|
|
start_ed_unlink (ohci, urb_priv->ed);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* with HC dead, we won't respect hc queue pointers
|
|
|
|
* any more ... just clean up every urb's memory.
|
|
|
|
*/
|
|
|
|
if (urb->hcpriv)
|
2007-08-24 19:40:34 +00:00
|
|
|
finish_urb(ohci, urb, status);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore (&ohci->lock, flags);
|
2007-08-08 15:48:02 +00:00
|
|
|
return rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* frees config/altsetting state for endpoints,
|
|
|
|
* including ED memory, dummy TD, and bulk/intr data toggle
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
ohci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
unsigned long flags;
|
|
|
|
struct ed *ed = ep->hcpriv;
|
|
|
|
unsigned limit = 1000;
|
|
|
|
|
|
|
|
/* ASSERT: any requests/urbs are being unlinked */
|
|
|
|
/* ASSERT: nobody can be submitting urbs for this any more */
|
|
|
|
|
|
|
|
if (!ed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rescan:
|
|
|
|
spin_lock_irqsave (&ohci->lock, flags);
|
|
|
|
|
|
|
|
if (!HC_IS_RUNNING (hcd->state)) {
|
|
|
|
sanitize:
|
|
|
|
ed->state = ED_IDLE;
|
2007-08-01 20:24:30 +00:00
|
|
|
if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT)
|
|
|
|
ohci->eds_scheduled--;
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
finish_unlinks (ohci, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (ed->state) {
|
|
|
|
case ED_UNLINK: /* wait for hw to finish? */
|
|
|
|
/* major IRQ delivery trouble loses INTR_SF too... */
|
|
|
|
if (limit-- == 0) {
|
2007-08-01 20:24:30 +00:00
|
|
|
ohci_warn(ohci, "ED unlink timeout\n");
|
|
|
|
if (quirk_zfmicro(ohci)) {
|
|
|
|
ohci_warn(ohci, "Attempting ZF TD recovery\n");
|
|
|
|
ohci->ed_to_check = ed;
|
|
|
|
ohci->zf_delay = 2;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
goto sanitize;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore (&ohci->lock, flags);
|
2005-08-15 18:30:11 +00:00
|
|
|
schedule_timeout_uninterruptible(1);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto rescan;
|
|
|
|
case ED_IDLE: /* fully unlinked */
|
|
|
|
if (list_empty (&ed->td_list)) {
|
|
|
|
td_free (ohci, ed->dummy);
|
|
|
|
ed_free (ohci, ed);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* else FALL THROUGH */
|
|
|
|
default:
|
|
|
|
/* caller was supposed to have unlinked any requests;
|
|
|
|
* that's not our job. can't recover; must leak ed.
|
|
|
|
*/
|
|
|
|
ohci_err (ohci, "leak ed %p (#%02x) state %d%s\n",
|
|
|
|
ed, ep->desc.bEndpointAddress, ed->state,
|
|
|
|
list_empty (&ed->td_list) ? "" : " (has tds)");
|
|
|
|
td_free (ohci, ed->dummy);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ep->hcpriv = NULL;
|
|
|
|
spin_unlock_irqrestore (&ohci->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ohci_get_frame (struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
|
|
|
|
return ohci_frame_no(ohci);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 00:24:08 +00:00
|
|
|
/* ohci_shutdown forcibly disables IRQs and DMA, helping kexec and
|
2005-04-23 19:49:16 +00:00
|
|
|
* other cases where the next software may expect clean state from the
|
|
|
|
* "firmware". this is bus-neutral, unlike shutdown() methods.
|
|
|
|
*/
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 00:24:08 +00:00
|
|
|
static void
|
|
|
|
ohci_shutdown (struct usb_hcd *hcd)
|
2005-04-23 19:49:16 +00:00
|
|
|
{
|
|
|
|
struct ohci_hcd *ohci;
|
|
|
|
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 00:24:08 +00:00
|
|
|
ohci = hcd_to_ohci (hcd);
|
2011-11-17 21:41:45 +00:00
|
|
|
ohci_writel(ohci, (u32) ~0, &ohci->regs->intrdisable);
|
2010-09-10 20:37:05 +00:00
|
|
|
|
2011-11-17 21:41:45 +00:00
|
|
|
/* Software reset, after which the controller goes into SUSPEND */
|
|
|
|
ohci_writel(ohci, OHCI_HCR, &ohci->regs->cmdstatus);
|
|
|
|
ohci_readl(ohci, &ohci->regs->cmdstatus); /* flush the writes */
|
|
|
|
udelay(10);
|
2010-09-10 20:37:05 +00:00
|
|
|
|
2011-11-17 21:41:45 +00:00
|
|
|
ohci_writel(ohci, ohci->fminterval, &ohci->regs->fminterval);
|
2005-04-23 19:49:16 +00:00
|
|
|
}
|
|
|
|
|
2007-08-01 20:24:30 +00:00
|
|
|
static int check_ed(struct ohci_hcd *ohci, struct ed *ed)
|
|
|
|
{
|
|
|
|
return (hc32_to_cpu(ohci, ed->hwINFO) & ED_IN) != 0
|
|
|
|
&& (hc32_to_cpu(ohci, ed->hwHeadP) & TD_MASK)
|
|
|
|
== (hc32_to_cpu(ohci, ed->hwTailP) & TD_MASK)
|
|
|
|
&& !list_empty(&ed->td_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ZF Micro watchdog timer callback. The ZF Micro chipset sometimes completes
|
|
|
|
* an interrupt TD but neglects to add it to the donelist. On systems with
|
|
|
|
* this chipset, we need to periodically check the state of the queues to look
|
|
|
|
* for such "lost" TDs.
|
|
|
|
*/
|
|
|
|
static void unlink_watchdog_func(unsigned long _ohci)
|
|
|
|
{
|
2007-10-25 00:23:42 +00:00
|
|
|
unsigned long flags;
|
2007-08-01 20:24:30 +00:00
|
|
|
unsigned max;
|
|
|
|
unsigned seen_count = 0;
|
|
|
|
unsigned i;
|
|
|
|
struct ed **seen = NULL;
|
|
|
|
struct ohci_hcd *ohci = (struct ohci_hcd *) _ohci;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ohci->lock, flags);
|
|
|
|
max = ohci->eds_scheduled;
|
|
|
|
if (!max)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (ohci->ed_to_check)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
seen = kcalloc(max, sizeof *seen, GFP_ATOMIC);
|
|
|
|
if (!seen)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_INTS; i++) {
|
|
|
|
struct ed *ed = ohci->periodic[i];
|
|
|
|
|
|
|
|
while (ed) {
|
|
|
|
unsigned temp;
|
|
|
|
|
|
|
|
/* scan this branch of the periodic schedule tree */
|
|
|
|
for (temp = 0; temp < seen_count; temp++) {
|
|
|
|
if (seen[temp] == ed) {
|
|
|
|
/* we've checked it and what's after */
|
|
|
|
ed = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ed)
|
|
|
|
break;
|
|
|
|
seen[seen_count++] = ed;
|
|
|
|
if (!check_ed(ohci, ed)) {
|
|
|
|
ed = ed->ed_next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* HC's TD list is empty, but HCD sees at least one
|
|
|
|
* TD that's not been sent through the donelist.
|
|
|
|
*/
|
|
|
|
ohci->ed_to_check = ed;
|
|
|
|
ohci->zf_delay = 2;
|
|
|
|
|
|
|
|
/* The HC may wait until the next frame to report the
|
|
|
|
* TD as done through the donelist and INTR_WDH. (We
|
|
|
|
* just *assume* it's not a multi-TD interrupt URB;
|
|
|
|
* those could defer the IRQ more than one frame, using
|
|
|
|
* DI...) Check again after the next INTR_SF.
|
|
|
|
*/
|
|
|
|
ohci_writel(ohci, OHCI_INTR_SF,
|
|
|
|
&ohci->regs->intrstatus);
|
|
|
|
ohci_writel(ohci, OHCI_INTR_SF,
|
|
|
|
&ohci->regs->intrenable);
|
|
|
|
|
|
|
|
/* flush those writes */
|
|
|
|
(void) ohci_readl(ohci, &ohci->regs->control);
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
kfree(seen);
|
|
|
|
if (ohci->eds_scheduled)
|
2008-03-28 21:50:30 +00:00
|
|
|
mod_timer(&ohci->unlink_watchdog, round_jiffies(jiffies + HZ));
|
2007-08-01 20:24:30 +00:00
|
|
|
done:
|
|
|
|
spin_unlock_irqrestore(&ohci->lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-------------------------------------------------------------------------*
|
|
|
|
* HC functions
|
|
|
|
*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* init memory, and kick BIOS/SMM off */
|
|
|
|
|
|
|
|
static int ohci_init (struct ohci_hcd *ohci)
|
|
|
|
{
|
|
|
|
int ret;
|
2006-01-23 23:28:07 +00:00
|
|
|
struct usb_hcd *hcd = ohci_to_hcd(ohci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-06 19:35:01 +00:00
|
|
|
if (distrust_firmware)
|
|
|
|
ohci->flags |= OHCI_QUIRK_HUB_POWER;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
disable (ohci);
|
2006-01-23 23:28:07 +00:00
|
|
|
ohci->regs = hcd->regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-23 23:28:07 +00:00
|
|
|
/* REVISIT this BIOS handshake is now moved into PCI "quirks", and
|
|
|
|
* was never needed for most non-PCI systems ... remove the code?
|
|
|
|
*/
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef IR_DISABLE
|
|
|
|
/* SMM owns the HC? not for long! */
|
|
|
|
if (!no_handshake && ohci_readl (ohci,
|
|
|
|
&ohci->regs->control) & OHCI_CTRL_IR) {
|
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
ohci_dbg (ohci, "USB HC TakeOver from BIOS/SMM\n");
|
|
|
|
|
|
|
|
/* this timeout is arbitrary. we make it long, so systems
|
|
|
|
* depending on usb keyboards may be usable even if the
|
|
|
|
* BIOS/SMM code seems pretty broken.
|
|
|
|
*/
|
|
|
|
temp = 500; /* arbitrary: five seconds */
|
|
|
|
|
|
|
|
ohci_writel (ohci, OHCI_INTR_OC, &ohci->regs->intrenable);
|
|
|
|
ohci_writel (ohci, OHCI_OCR, &ohci->regs->cmdstatus);
|
|
|
|
while (ohci_readl (ohci, &ohci->regs->control) & OHCI_CTRL_IR) {
|
|
|
|
msleep (10);
|
|
|
|
if (--temp == 0) {
|
|
|
|
ohci_err (ohci, "USB HC takeover failed!"
|
|
|
|
" (BIOS/SMM bug)\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ohci_usb_reset (ohci);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Disable HC interrupts */
|
|
|
|
ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
|
2006-01-23 23:28:07 +00:00
|
|
|
|
|
|
|
/* flush the writes, and save key bits like RWC */
|
|
|
|
if (ohci_readl (ohci, &ohci->regs->control) & OHCI_CTRL_RWC)
|
|
|
|
ohci->hc_control |= OHCI_CTRL_RWC;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-31 18:52:57 +00:00
|
|
|
/* Read the number of ports unless overridden */
|
|
|
|
if (ohci->num_ports == 0)
|
|
|
|
ohci->num_ports = roothub_a(ohci) & RH_A_NDP;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ohci->hcca)
|
|
|
|
return 0;
|
|
|
|
|
2006-01-23 23:28:07 +00:00
|
|
|
ohci->hcca = dma_alloc_coherent (hcd->self.controller,
|
2005-04-16 22:20:36 +00:00
|
|
|
sizeof *ohci->hcca, &ohci->hcca_dma, 0);
|
|
|
|
if (!ohci->hcca)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if ((ret = ohci_mem_init (ohci)) < 0)
|
2006-01-23 23:28:07 +00:00
|
|
|
ohci_stop (hcd);
|
|
|
|
else {
|
|
|
|
create_debug_files (ohci);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* Start an OHCI controller, set the BUS operational
|
|
|
|
* resets USB and controller
|
2006-12-05 11:18:31 +00:00
|
|
|
* enable interrupts
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static int ohci_run (struct ohci_hcd *ohci)
|
|
|
|
{
|
2009-04-22 20:18:59 +00:00
|
|
|
u32 mask, val;
|
2005-04-16 22:20:36 +00:00
|
|
|
int first = ohci->fminterval == 0;
|
2006-01-23 23:28:07 +00:00
|
|
|
struct usb_hcd *hcd = ohci_to_hcd(ohci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
disable (ohci);
|
|
|
|
|
|
|
|
/* boot firmware should have set this up (5.1.1.3.1) */
|
|
|
|
if (first) {
|
|
|
|
|
2009-04-22 20:18:59 +00:00
|
|
|
val = ohci_readl (ohci, &ohci->regs->fminterval);
|
|
|
|
ohci->fminterval = val & 0x3fff;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ohci->fminterval != FI)
|
|
|
|
ohci_dbg (ohci, "fminterval delta %d\n",
|
|
|
|
ohci->fminterval - FI);
|
|
|
|
ohci->fminterval |= FSMP (ohci->fminterval) << 16;
|
|
|
|
/* also: power/overcurrent flags in roothub.a */
|
|
|
|
}
|
|
|
|
|
2008-12-17 22:20:38 +00:00
|
|
|
/* Reset USB nearly "by the book". RemoteWakeupConnected has
|
|
|
|
* to be checked in case boot firmware (BIOS/SMM/...) has set up
|
|
|
|
* wakeup in a way the bus isn't aware of (e.g., legacy PCI PM).
|
|
|
|
* If the bus glue detected wakeup capability then it should
|
2009-01-13 16:35:54 +00:00
|
|
|
* already be enabled; if so we'll just enable it again.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-01-13 16:35:54 +00:00
|
|
|
if ((ohci->hc_control & OHCI_CTRL_RWC) != 0)
|
|
|
|
device_set_wakeup_capable(hcd->self.controller, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
switch (ohci->hc_control & OHCI_CTRL_HCFS) {
|
|
|
|
case OHCI_USB_OPER:
|
2009-04-22 20:18:59 +00:00
|
|
|
val = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case OHCI_USB_SUSPEND:
|
|
|
|
case OHCI_USB_RESUME:
|
|
|
|
ohci->hc_control &= OHCI_CTRL_RWC;
|
|
|
|
ohci->hc_control |= OHCI_USB_RESUME;
|
2009-04-22 20:18:59 +00:00
|
|
|
val = 10 /* msec wait */;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
// case OHCI_USB_RESET:
|
|
|
|
default:
|
|
|
|
ohci->hc_control &= OHCI_CTRL_RWC;
|
|
|
|
ohci->hc_control |= OHCI_USB_RESET;
|
2009-04-22 20:18:59 +00:00
|
|
|
val = 50 /* msec wait */;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
|
|
|
|
// flush the writes
|
|
|
|
(void) ohci_readl (ohci, &ohci->regs->control);
|
2009-04-22 20:18:59 +00:00
|
|
|
msleep(val);
|
2007-05-04 15:52:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memset (ohci->hcca, 0, sizeof (struct ohci_hcca));
|
|
|
|
|
|
|
|
/* 2msec timelimit here means no irqs/preempt */
|
|
|
|
spin_lock_irq (&ohci->lock);
|
|
|
|
|
|
|
|
retry:
|
|
|
|
/* HC Reset requires max 10 us delay */
|
|
|
|
ohci_writel (ohci, OHCI_HCR, &ohci->regs->cmdstatus);
|
2009-04-22 20:18:59 +00:00
|
|
|
val = 30; /* ... allow extra time */
|
2005-04-16 22:20:36 +00:00
|
|
|
while ((ohci_readl (ohci, &ohci->regs->cmdstatus) & OHCI_HCR) != 0) {
|
2009-04-22 20:18:59 +00:00
|
|
|
if (--val == 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irq (&ohci->lock);
|
|
|
|
ohci_err (ohci, "USB HC reset timed out!\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
udelay (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now we're in the SUSPEND state ... must go OPERATIONAL
|
|
|
|
* within 2msec else HC enters RESUME
|
|
|
|
*
|
|
|
|
* ... but some hardware won't init fmInterval "by the book"
|
|
|
|
* (SiS, OPTi ...), so reset again instead. SiS doesn't need
|
|
|
|
* this if we write fmInterval after we're OPERATIONAL.
|
|
|
|
* Unclear about ALi, ServerWorks, and others ... this could
|
|
|
|
* easily be a longstanding bug in chip init on Linux.
|
|
|
|
*/
|
|
|
|
if (ohci->flags & OHCI_QUIRK_INITRESET) {
|
|
|
|
ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
|
|
|
|
// flush those writes
|
|
|
|
(void) ohci_readl (ohci, &ohci->regs->control);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell the controller where the control and bulk lists are
|
|
|
|
* The lists are empty now. */
|
|
|
|
ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);
|
|
|
|
ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);
|
|
|
|
|
|
|
|
/* a reset clears this */
|
|
|
|
ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);
|
|
|
|
|
|
|
|
periodic_reinit (ohci);
|
|
|
|
|
|
|
|
/* some OHCI implementations are finicky about how they init.
|
|
|
|
* bogus values here mean not even enumeration could work.
|
|
|
|
*/
|
|
|
|
if ((ohci_readl (ohci, &ohci->regs->fminterval) & 0x3fff0000) == 0
|
|
|
|
|| !ohci_readl (ohci, &ohci->regs->periodicstart)) {
|
|
|
|
if (!(ohci->flags & OHCI_QUIRK_INITRESET)) {
|
|
|
|
ohci->flags |= OHCI_QUIRK_INITRESET;
|
|
|
|
ohci_dbg (ohci, "enabling initreset quirk\n");
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
spin_unlock_irq (&ohci->lock);
|
|
|
|
ohci_err (ohci, "init err (%08x %04x)\n",
|
|
|
|
ohci_readl (ohci, &ohci->regs->fminterval),
|
|
|
|
ohci_readl (ohci, &ohci->regs->periodicstart));
|
|
|
|
return -EOVERFLOW;
|
|
|
|
}
|
|
|
|
|
2006-08-04 18:31:55 +00:00
|
|
|
/* use rhsc irqs after khubd is fully initialized */
|
2010-06-22 20:39:10 +00:00
|
|
|
set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2006-08-04 18:31:55 +00:00
|
|
|
hcd->uses_new_polling = 1;
|
|
|
|
|
|
|
|
/* start controller operations */
|
2005-04-16 22:20:36 +00:00
|
|
|
ohci->hc_control &= OHCI_CTRL_RWC;
|
2006-08-04 18:31:55 +00:00
|
|
|
ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
|
|
|
|
ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
|
2006-01-23 23:28:07 +00:00
|
|
|
hcd->state = HC_STATE_RUNNING;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* wake on ConnectStatusChange, matching external hubs */
|
|
|
|
ohci_writel (ohci, RH_HS_DRWE, &ohci->regs->roothub.status);
|
|
|
|
|
|
|
|
/* Choose the interrupts we care about now, others later on demand */
|
|
|
|
mask = OHCI_INTR_INIT;
|
2006-08-04 18:31:55 +00:00
|
|
|
ohci_writel (ohci, ~0, &ohci->regs->intrstatus);
|
2005-04-16 22:20:36 +00:00
|
|
|
ohci_writel (ohci, mask, &ohci->regs->intrenable);
|
|
|
|
|
|
|
|
/* handle root hub init quirks ... */
|
2009-04-22 20:18:59 +00:00
|
|
|
val = roothub_a (ohci);
|
|
|
|
val &= ~(RH_A_PSM | RH_A_OCPM);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ohci->flags & OHCI_QUIRK_SUPERIO) {
|
|
|
|
/* NSC 87560 and maybe others */
|
2009-04-22 20:18:59 +00:00
|
|
|
val |= RH_A_NOCP;
|
|
|
|
val &= ~(RH_A_POTPGT | RH_A_NPS);
|
|
|
|
ohci_writel (ohci, val, &ohci->regs->roothub.a);
|
2008-07-06 19:35:01 +00:00
|
|
|
} else if ((ohci->flags & OHCI_QUIRK_AMD756) ||
|
|
|
|
(ohci->flags & OHCI_QUIRK_HUB_POWER)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* hub power always on; required for AMD-756 and some
|
|
|
|
* Mac platforms. ganged overcurrent reporting, if any.
|
|
|
|
*/
|
2009-04-22 20:18:59 +00:00
|
|
|
val |= RH_A_NPS;
|
|
|
|
ohci_writel (ohci, val, &ohci->regs->roothub.a);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
ohci_writel (ohci, RH_HS_LPSC, &ohci->regs->roothub.status);
|
2009-04-22 20:18:59 +00:00
|
|
|
ohci_writel (ohci, (val & RH_A_NPS) ? 0 : RH_B_PPCM,
|
2005-04-16 22:20:36 +00:00
|
|
|
&ohci->regs->roothub.b);
|
|
|
|
// flush those writes
|
|
|
|
(void) ohci_readl (ohci, &ohci->regs->control);
|
|
|
|
|
2006-08-04 18:31:55 +00:00
|
|
|
ohci->next_statechange = jiffies + STATECHANGE_DELAY;
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irq (&ohci->lock);
|
|
|
|
|
|
|
|
// POTPGT delay is bits 24-31, in 2 ms units.
|
2009-04-22 20:18:59 +00:00
|
|
|
mdelay ((val >> 23) & 0x1fe);
|
2006-01-23 23:28:07 +00:00
|
|
|
hcd->state = HC_STATE_RUNNING;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-01 20:24:30 +00:00
|
|
|
if (quirk_zfmicro(ohci)) {
|
|
|
|
/* Create timer to watch for bad queue state on ZF Micro */
|
|
|
|
setup_timer(&ohci->unlink_watchdog, unlink_watchdog_func,
|
|
|
|
(unsigned long) ohci);
|
|
|
|
|
|
|
|
ohci->eds_scheduled = 0;
|
|
|
|
ohci->ed_to_check = NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ohci_dump (ohci, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* an interrupt happens */
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t ohci_irq (struct usb_hcd *hcd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
struct ohci_regs __iomem *regs = ohci->regs;
|
2007-08-01 20:24:30 +00:00
|
|
|
int ints;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-12-06 21:28:25 +00:00
|
|
|
/* Read interrupt status (and flush pending writes). We ignore the
|
|
|
|
* optimization of checking the LSB of hcca->done_head; it doesn't
|
|
|
|
* work on all systems (edge triggering for OHCI can be a factor).
|
2007-08-01 20:24:30 +00:00
|
|
|
*/
|
2007-12-06 21:28:25 +00:00
|
|
|
ints = ohci_readl(ohci, ®s->intrstatus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-12-06 21:28:25 +00:00
|
|
|
/* Check for an all 1's result which is a typical consequence
|
|
|
|
* of dead, unclocked, or unplugged (CardBus...) devices
|
|
|
|
*/
|
|
|
|
if (ints == ~(u32)0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
disable (ohci);
|
|
|
|
ohci_dbg (ohci, "device removed!\n");
|
2011-05-17 21:27:12 +00:00
|
|
|
usb_hc_died(hcd);
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_HANDLED;
|
2007-12-06 21:28:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We only care about interrupts that are enabled */
|
|
|
|
ints &= ohci_readl(ohci, ®s->intrenable);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* interrupt for some other device? */
|
2011-05-17 21:27:12 +00:00
|
|
|
if (ints == 0 || unlikely(hcd->state == HC_STATE_HALT))
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_NOTMINE;
|
2006-08-04 18:31:55 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ints & OHCI_INTR_UE) {
|
|
|
|
// e.g. due to PCI Master/Target Abort
|
2007-08-01 20:24:30 +00:00
|
|
|
if (quirk_nec(ohci)) {
|
2007-05-31 21:34:27 +00:00
|
|
|
/* Workaround for a silicon bug in some NEC chips used
|
|
|
|
* in Apple's PowerBooks. Adapted from Darwin code.
|
|
|
|
*/
|
|
|
|
ohci_err (ohci, "OHCI Unrecoverable Error, scheduling NEC chip restart\n");
|
|
|
|
|
|
|
|
ohci_writel (ohci, OHCI_INTR_UE, ®s->intrdisable);
|
|
|
|
|
|
|
|
schedule_work (&ohci->nec_work);
|
|
|
|
} else {
|
|
|
|
disable (ohci);
|
|
|
|
ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");
|
2011-05-17 21:27:12 +00:00
|
|
|
usb_hc_died(hcd);
|
2007-05-31 21:34:27 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ohci_dump (ohci, 1);
|
|
|
|
ohci_usb_reset (ohci);
|
|
|
|
}
|
|
|
|
|
2006-10-24 16:04:22 +00:00
|
|
|
if (ints & OHCI_INTR_RHSC) {
|
|
|
|
ohci_vdbg(ohci, "rhsc\n");
|
|
|
|
ohci->next_statechange = jiffies + STATECHANGE_DELAY;
|
|
|
|
ohci_writel(ohci, OHCI_INTR_RD | OHCI_INTR_RHSC,
|
|
|
|
®s->intrstatus);
|
2006-10-27 14:33:11 +00:00
|
|
|
|
|
|
|
/* NOTE: Vendors didn't always make the same implementation
|
|
|
|
* choices for RHSC. Many followed the spec; RHSC triggers
|
|
|
|
* on an edge, like setting and maybe clearing a port status
|
|
|
|
* change bit. With others it's level-triggered, active
|
|
|
|
* until khubd clears all the port status change bits. We'll
|
|
|
|
* always disable it here and rely on polling until khubd
|
|
|
|
* re-enables it.
|
|
|
|
*/
|
|
|
|
ohci_writel(ohci, OHCI_INTR_RHSC, ®s->intrdisable);
|
2006-10-24 16:04:22 +00:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For connect and disconnect events, we expect the controller
|
|
|
|
* to turn on RHSC along with RD. But for remote wakeup events
|
|
|
|
* this might not happen.
|
|
|
|
*/
|
|
|
|
else if (ints & OHCI_INTR_RD) {
|
|
|
|
ohci_vdbg(ohci, "resume detect\n");
|
|
|
|
ohci_writel(ohci, OHCI_INTR_RD, ®s->intrstatus);
|
2010-06-22 20:39:10 +00:00
|
|
|
set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2006-09-26 18:46:16 +00:00
|
|
|
if (ohci->autostop) {
|
|
|
|
spin_lock (&ohci->lock);
|
|
|
|
ohci_rh_resume (ohci);
|
|
|
|
spin_unlock (&ohci->lock);
|
|
|
|
} else
|
2005-09-23 05:42:53 +00:00
|
|
|
usb_hcd_resume_root_hub(hcd);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ints & OHCI_INTR_WDH) {
|
|
|
|
spin_lock (&ohci->lock);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
dl_done_list (ohci);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock (&ohci->lock);
|
|
|
|
}
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2007-08-01 20:24:30 +00:00
|
|
|
if (quirk_zfmicro(ohci) && (ints & OHCI_INTR_SF)) {
|
|
|
|
spin_lock(&ohci->lock);
|
|
|
|
if (ohci->ed_to_check) {
|
|
|
|
struct ed *ed = ohci->ed_to_check;
|
|
|
|
|
|
|
|
if (check_ed(ohci, ed)) {
|
|
|
|
/* HC thinks the TD list is empty; HCD knows
|
|
|
|
* at least one TD is outstanding
|
|
|
|
*/
|
|
|
|
if (--ohci->zf_delay == 0) {
|
|
|
|
struct td *td = list_entry(
|
|
|
|
ed->td_list.next,
|
|
|
|
struct td, td_list);
|
|
|
|
ohci_warn(ohci,
|
|
|
|
"Reclaiming orphan TD %p\n",
|
|
|
|
td);
|
|
|
|
takeback_td(ohci, td);
|
|
|
|
ohci->ed_to_check = NULL;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
ohci->ed_to_check = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&ohci->lock);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* could track INTR_SO to reduce available PCI/... bandwidth */
|
|
|
|
|
|
|
|
/* handle any pending URB/ED unlinks, leaving INTR_SF enabled
|
|
|
|
* when there's still unlinking to be done (next frame).
|
|
|
|
*/
|
|
|
|
spin_lock (&ohci->lock);
|
|
|
|
if (ohci->ed_rm_list)
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
finish_unlinks (ohci, ohci_frame_no(ohci));
|
2007-08-01 20:24:30 +00:00
|
|
|
if ((ints & OHCI_INTR_SF) != 0
|
|
|
|
&& !ohci->ed_rm_list
|
|
|
|
&& !ohci->ed_to_check
|
2005-04-16 22:20:36 +00:00
|
|
|
&& HC_IS_RUNNING(hcd->state))
|
2006-12-05 11:18:31 +00:00
|
|
|
ohci_writel (ohci, OHCI_INTR_SF, ®s->intrdisable);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock (&ohci->lock);
|
|
|
|
|
|
|
|
if (HC_IS_RUNNING(hcd->state)) {
|
|
|
|
ohci_writel (ohci, ints, ®s->intrstatus);
|
2006-12-05 11:18:31 +00:00
|
|
|
ohci_writel (ohci, OHCI_INTR_MIE, ®s->intrenable);
|
2005-04-16 22:20:36 +00:00
|
|
|
// flush those writes
|
|
|
|
(void) ohci_readl (ohci, &ohci->regs->control);
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static void ohci_stop (struct usb_hcd *hcd)
|
2006-12-05 11:18:31 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
|
|
|
|
|
|
|
ohci_dump (ohci, 1);
|
|
|
|
|
2010-12-24 15:14:20 +00:00
|
|
|
if (quirk_nec(ohci))
|
|
|
|
flush_work_sync(&ohci->nec_work);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ohci_usb_reset (ohci);
|
|
|
|
ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
|
2006-09-19 05:57:22 +00:00
|
|
|
free_irq(hcd->irq, hcd);
|
|
|
|
hcd->irq = -1;
|
|
|
|
|
2007-08-01 20:24:30 +00:00
|
|
|
if (quirk_zfmicro(ohci))
|
|
|
|
del_timer(&ohci->unlink_watchdog);
|
2008-08-08 07:03:31 +00:00
|
|
|
if (quirk_amdiso(ohci))
|
2011-03-01 06:57:05 +00:00
|
|
|
usb_amd_dev_put();
|
2007-08-01 20:24:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
remove_debug_files (ohci);
|
|
|
|
ohci_mem_cleanup (ohci);
|
|
|
|
if (ohci->hcca) {
|
2006-12-05 11:18:31 +00:00
|
|
|
dma_free_coherent (hcd->self.controller,
|
|
|
|
sizeof *ohci->hcca,
|
2005-04-16 22:20:36 +00:00
|
|
|
ohci->hcca, ohci->hcca_dma);
|
|
|
|
ohci->hcca = NULL;
|
|
|
|
ohci->hcca_dma = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-10-25 00:23:42 +00:00
|
|
|
#if defined(CONFIG_PM) || defined(CONFIG_PCI)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* must not be called from interrupt context */
|
|
|
|
static int ohci_restart (struct ohci_hcd *ohci)
|
|
|
|
{
|
|
|
|
int temp;
|
|
|
|
int i;
|
|
|
|
struct urb_priv *priv;
|
|
|
|
|
|
|
|
spin_lock_irq(&ohci->lock);
|
|
|
|
disable (ohci);
|
2007-05-31 21:34:27 +00:00
|
|
|
|
|
|
|
/* Recycle any "live" eds/tds (and urbs). */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!list_empty (&ohci->pending))
|
|
|
|
ohci_dbg(ohci, "abort schedule...\n");
|
|
|
|
list_for_each_entry (priv, &ohci->pending, pending) {
|
|
|
|
struct urb *urb = priv->td[0]->urb;
|
|
|
|
struct ed *ed = priv->ed;
|
|
|
|
|
|
|
|
switch (ed->state) {
|
|
|
|
case ED_OPER:
|
|
|
|
ed->state = ED_UNLINK;
|
|
|
|
ed->hwINFO |= cpu_to_hc32(ohci, ED_DEQUEUE);
|
|
|
|
ed_deschedule (ohci, ed);
|
|
|
|
|
|
|
|
ed->ed_next = ohci->ed_rm_list;
|
|
|
|
ed->ed_prev = NULL;
|
|
|
|
ohci->ed_rm_list = ed;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case ED_UNLINK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ohci_dbg(ohci, "bogus ed %p state %d\n",
|
|
|
|
ed, ed->state);
|
|
|
|
}
|
|
|
|
|
2007-08-24 19:40:34 +00:00
|
|
|
if (!urb->unlinked)
|
|
|
|
urb->unlinked = -ESHUTDOWN;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
finish_unlinks (ohci, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irq(&ohci->lock);
|
|
|
|
|
|
|
|
/* paranoia, in case that didn't work: */
|
|
|
|
|
|
|
|
/* empty the interrupt branches */
|
|
|
|
for (i = 0; i < NUM_INTS; i++) ohci->load [i] = 0;
|
|
|
|
for (i = 0; i < NUM_INTS; i++) ohci->hcca->int_table [i] = 0;
|
2006-12-05 11:18:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* no EDs to remove */
|
|
|
|
ohci->ed_rm_list = NULL;
|
|
|
|
|
2006-12-05 11:18:31 +00:00
|
|
|
/* empty control and bulk lists */
|
2005-04-16 22:20:36 +00:00
|
|
|
ohci->ed_controltail = NULL;
|
|
|
|
ohci->ed_bulktail = NULL;
|
|
|
|
|
|
|
|
if ((temp = ohci_run (ohci)) < 0) {
|
|
|
|
ohci_err (ohci, "can't restart, %d\n", temp);
|
|
|
|
return temp;
|
|
|
|
}
|
2007-05-04 15:52:40 +00:00
|
|
|
ohci_dbg(ohci, "restart complete\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-05-31 21:34:27 +00:00
|
|
|
|
2007-10-25 00:23:42 +00:00
|
|
|
#endif
|
|
|
|
|
2007-05-31 21:34:27 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_AUTHOR (DRIVER_AUTHOR);
|
2008-10-02 15:47:15 +00:00
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE ("GPL");
|
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
#include "ohci-pci.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PCI_DRIVER ohci_pci_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2008-06-02 02:05:30 +00:00
|
|
|
#if defined(CONFIG_ARCH_SA1100) && defined(CONFIG_SA1111)
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci-sa1111.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define SA1111_DRIVER ohci_hcd_sa1111_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2009-03-07 11:44:10 +00:00
|
|
|
#if defined(CONFIG_ARCH_S3C2410) || defined(CONFIG_ARCH_S3C64XX)
|
2005-07-29 19:18:03 +00:00
|
|
|
#include "ohci-s3c2410.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_s3c2410_driver
|
2005-07-29 19:18:03 +00:00
|
|
|
#endif
|
|
|
|
|
2010-05-10 16:26:12 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_HCD_OMAP1
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci-omap.c"
|
2010-05-10 16:26:12 +00:00
|
|
|
#define OMAP1_PLATFORM_DRIVER ohci_hcd_omap_driver
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_OHCI_HCD_OMAP3
|
|
|
|
#include "ohci-omap3.c"
|
|
|
|
#define OMAP3_PLATFORM_DRIVER ohci_hcd_omap3_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2007-12-12 01:07:47 +00:00
|
|
|
#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci-pxa27x.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_pxa27x_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2006-06-23 21:02:01 +00:00
|
|
|
#ifdef CONFIG_ARCH_EP93XX
|
|
|
|
#include "ohci-ep93xx.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_ep93xx_driver
|
2006-06-23 21:02:01 +00:00
|
|
|
#endif
|
|
|
|
|
2010-07-15 19:45:04 +00:00
|
|
|
#ifdef CONFIG_MIPS_ALCHEMY
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ohci-au1xxx.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_au1xxx_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2006-10-09 08:32:00 +00:00
|
|
|
#ifdef CONFIG_PNX8550
|
|
|
|
#include "ohci-pnx8550.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_pnx8550_driver
|
2006-10-09 08:32:00 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_HCD_PPC_SOC
|
|
|
|
#include "ohci-ppc-soc.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_ppc_soc_driver
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2006-12-01 13:51:13 +00:00
|
|
|
#ifdef CONFIG_ARCH_AT91
|
2006-01-22 18:32:13 +00:00
|
|
|
#include "ohci-at91.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER ohci_hcd_at91_driver
|
2006-01-22 18:32:13 +00:00
|
|
|
#endif
|
|
|
|
|
2006-06-29 14:28:18 +00:00
|
|
|
#ifdef CONFIG_ARCH_PNX4008
|
|
|
|
#include "ohci-pnx4008.c"
|
2006-12-13 20:09:54 +00:00
|
|
|
#define PLATFORM_DRIVER usb_hcd_pnx4008_driver
|
2006-06-29 14:28:18 +00:00
|
|
|
#endif
|
|
|
|
|
2010-02-12 19:52:34 +00:00
|
|
|
#ifdef CONFIG_ARCH_DAVINCI_DA8XX
|
|
|
|
#include "ohci-da8xx.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_hcd_da8xx_driver
|
|
|
|
#endif
|
|
|
|
|
2011-03-01 07:58:37 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_SH
|
2008-01-11 13:56:15 +00:00
|
|
|
#include "ohci-sh.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_hcd_sh_driver
|
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:54 +00:00
|
|
|
|
2006-12-13 20:09:55 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_HCD_PPC_OF
|
|
|
|
#include "ohci-ppc-of.c"
|
|
|
|
#define OF_PLATFORM_DRIVER ohci_hcd_ppc_of_driver
|
|
|
|
#endif
|
|
|
|
|
2010-11-10 09:03:18 +00:00
|
|
|
#ifdef CONFIG_PLAT_SPEAR
|
|
|
|
#include "ohci-spear.c"
|
|
|
|
#define PLATFORM_DRIVER spear_ohci_hcd_driver
|
|
|
|
#endif
|
|
|
|
|
2007-01-16 04:12:10 +00:00
|
|
|
#ifdef CONFIG_PPC_PS3
|
|
|
|
#include "ohci-ps3.c"
|
2007-06-06 03:04:35 +00:00
|
|
|
#define PS3_SYSTEM_BUS_DRIVER ps3_ohci_driver
|
2007-01-16 04:12:10 +00:00
|
|
|
#endif
|
|
|
|
|
2007-10-10 06:47:17 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_HCD_SSB
|
|
|
|
#include "ohci-ssb.c"
|
|
|
|
#define SSB_OHCI_DRIVER ssb_ohci_driver
|
|
|
|
#endif
|
|
|
|
|
2008-01-23 06:58:46 +00:00
|
|
|
#ifdef CONFIG_MFD_SM501
|
|
|
|
#include "ohci-sm501.c"
|
2008-06-08 16:20:11 +00:00
|
|
|
#define SM501_OHCI_DRIVER ohci_hcd_sm501_driver
|
2008-01-23 06:58:46 +00:00
|
|
|
#endif
|
|
|
|
|
2008-10-08 12:14:23 +00:00
|
|
|
#ifdef CONFIG_MFD_TC6393XB
|
|
|
|
#include "ohci-tmio.c"
|
|
|
|
#define TMIO_OHCI_DRIVER ohci_hcd_tmio_driver
|
2010-06-19 04:08:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MACH_JZ4740
|
|
|
|
#include "ohci-jz4740.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_hcd_jz4740_driver
|
2008-10-08 12:14:23 +00:00
|
|
|
#endif
|
|
|
|
|
2010-10-08 21:47:52 +00:00
|
|
|
#ifdef CONFIG_USB_OCTEON_OHCI
|
|
|
|
#include "ohci-octeon.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_octeon_driver
|
|
|
|
#endif
|
|
|
|
|
2010-11-25 15:58:00 +00:00
|
|
|
#ifdef CONFIG_USB_CNS3XXX_OHCI
|
|
|
|
#include "ohci-cns3xxx.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_hcd_cns3xxx_driver
|
|
|
|
#endif
|
|
|
|
|
2011-04-13 08:54:24 +00:00
|
|
|
#ifdef CONFIG_USB_OHCI_ATH79
|
|
|
|
#include "ohci-ath79.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_hcd_ath79_driver
|
|
|
|
#endif
|
|
|
|
|
2011-08-04 19:58:22 +00:00
|
|
|
#ifdef CONFIG_NLM_XLR
|
|
|
|
#include "ohci-xls.c"
|
|
|
|
#define PLATFORM_DRIVER ohci_xls_driver
|
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:54 +00:00
|
|
|
#if !defined(PCI_DRIVER) && \
|
|
|
|
!defined(PLATFORM_DRIVER) && \
|
2010-05-10 16:26:12 +00:00
|
|
|
!defined(OMAP1_PLATFORM_DRIVER) && \
|
|
|
|
!defined(OMAP3_PLATFORM_DRIVER) && \
|
2006-12-13 20:09:55 +00:00
|
|
|
!defined(OF_PLATFORM_DRIVER) && \
|
2007-01-16 04:12:10 +00:00
|
|
|
!defined(SA1111_DRIVER) && \
|
2007-10-10 06:47:17 +00:00
|
|
|
!defined(PS3_SYSTEM_BUS_DRIVER) && \
|
2008-06-08 16:20:11 +00:00
|
|
|
!defined(SM501_OHCI_DRIVER) && \
|
2008-10-08 12:14:23 +00:00
|
|
|
!defined(TMIO_OHCI_DRIVER) && \
|
2007-10-10 06:47:17 +00:00
|
|
|
!defined(SSB_OHCI_DRIVER)
|
2005-04-16 22:20:36 +00:00
|
|
|
#error "missing bus glue for ohci-hcd"
|
|
|
|
#endif
|
2006-12-13 20:09:54 +00:00
|
|
|
|
|
|
|
static int __init ohci_hcd_mod_init(void)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
if (usb_disabled())
|
|
|
|
return -ENODEV;
|
|
|
|
|
2008-10-02 15:47:15 +00:00
|
|
|
printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
|
2006-12-13 20:09:54 +00:00
|
|
|
pr_debug ("%s: block sizes: ed %Zd td %Zd\n", hcd_name,
|
|
|
|
sizeof (struct ed), sizeof (struct td));
|
2008-10-02 15:48:13 +00:00
|
|
|
set_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
|
2006-12-13 20:09:54 +00:00
|
|
|
|
2007-09-11 21:07:31 +00:00
|
|
|
#ifdef DEBUG
|
2009-04-24 22:14:38 +00:00
|
|
|
ohci_debug_root = debugfs_create_dir("ohci", usb_debug_root);
|
2007-09-11 21:07:31 +00:00
|
|
|
if (!ohci_debug_root) {
|
|
|
|
retval = -ENOENT;
|
|
|
|
goto error_debug;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-01-16 04:12:10 +00:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 03:04:35 +00:00
|
|
|
retval = ps3_ohci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
|
|
|
|
if (retval < 0)
|
|
|
|
goto error_ps3;
|
2007-01-16 04:12:10 +00:00
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:54 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
retval = platform_driver_register(&PLATFORM_DRIVER);
|
|
|
|
if (retval < 0)
|
2007-01-16 04:12:06 +00:00
|
|
|
goto error_platform;
|
2006-12-13 20:09:54 +00:00
|
|
|
#endif
|
|
|
|
|
2010-05-10 16:26:12 +00:00
|
|
|
#ifdef OMAP1_PLATFORM_DRIVER
|
|
|
|
retval = platform_driver_register(&OMAP1_PLATFORM_DRIVER);
|
|
|
|
if (retval < 0)
|
|
|
|
goto error_omap1_platform;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef OMAP3_PLATFORM_DRIVER
|
|
|
|
retval = platform_driver_register(&OMAP3_PLATFORM_DRIVER);
|
|
|
|
if (retval < 0)
|
|
|
|
goto error_omap3_platform;
|
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:55 +00:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
retval = platform_driver_register(&OF_PLATFORM_DRIVER);
|
2006-12-13 20:09:55 +00:00
|
|
|
if (retval < 0)
|
2007-01-16 04:12:06 +00:00
|
|
|
goto error_of_platform;
|
2006-12-13 20:09:55 +00:00
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:54 +00:00
|
|
|
#ifdef SA1111_DRIVER
|
|
|
|
retval = sa1111_driver_register(&SA1111_DRIVER);
|
|
|
|
if (retval < 0)
|
2007-01-16 04:12:06 +00:00
|
|
|
goto error_sa1111;
|
2006-12-13 20:09:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
retval = pci_register_driver(&PCI_DRIVER);
|
|
|
|
if (retval < 0)
|
2007-01-16 04:12:06 +00:00
|
|
|
goto error_pci;
|
2006-12-13 20:09:54 +00:00
|
|
|
#endif
|
|
|
|
|
2007-10-10 06:47:17 +00:00
|
|
|
#ifdef SSB_OHCI_DRIVER
|
|
|
|
retval = ssb_driver_register(&SSB_OHCI_DRIVER);
|
|
|
|
if (retval)
|
|
|
|
goto error_ssb;
|
|
|
|
#endif
|
|
|
|
|
2008-06-08 16:20:11 +00:00
|
|
|
#ifdef SM501_OHCI_DRIVER
|
|
|
|
retval = platform_driver_register(&SM501_OHCI_DRIVER);
|
|
|
|
if (retval < 0)
|
|
|
|
goto error_sm501;
|
|
|
|
#endif
|
|
|
|
|
2008-10-08 12:14:23 +00:00
|
|
|
#ifdef TMIO_OHCI_DRIVER
|
|
|
|
retval = platform_driver_register(&TMIO_OHCI_DRIVER);
|
|
|
|
if (retval < 0)
|
|
|
|
goto error_tmio;
|
|
|
|
#endif
|
|
|
|
|
2006-12-13 20:09:54 +00:00
|
|
|
return retval;
|
|
|
|
|
|
|
|
/* Error path */
|
2008-10-08 12:14:23 +00:00
|
|
|
#ifdef TMIO_OHCI_DRIVER
|
|
|
|
platform_driver_unregister(&TMIO_OHCI_DRIVER);
|
|
|
|
error_tmio:
|
|
|
|
#endif
|
2008-06-08 16:20:11 +00:00
|
|
|
#ifdef SM501_OHCI_DRIVER
|
2008-10-08 12:14:23 +00:00
|
|
|
platform_driver_unregister(&SM501_OHCI_DRIVER);
|
2008-06-08 16:20:11 +00:00
|
|
|
error_sm501:
|
|
|
|
#endif
|
2007-10-10 06:47:17 +00:00
|
|
|
#ifdef SSB_OHCI_DRIVER
|
2008-10-08 12:14:23 +00:00
|
|
|
ssb_driver_unregister(&SSB_OHCI_DRIVER);
|
2007-10-10 06:47:17 +00:00
|
|
|
error_ssb:
|
|
|
|
#endif
|
2007-01-16 04:12:06 +00:00
|
|
|
#ifdef PCI_DRIVER
|
2007-10-10 06:47:17 +00:00
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
2007-01-16 04:12:06 +00:00
|
|
|
error_pci:
|
|
|
|
#endif
|
|
|
|
#ifdef SA1111_DRIVER
|
|
|
|
sa1111_driver_unregister(&SA1111_DRIVER);
|
|
|
|
error_sa1111:
|
2006-12-13 20:09:54 +00:00
|
|
|
#endif
|
2006-12-13 20:09:55 +00:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2007-01-16 04:12:06 +00:00
|
|
|
error_of_platform:
|
2006-12-13 20:09:55 +00:00
|
|
|
#endif
|
2007-01-16 04:12:06 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
error_platform:
|
2007-01-16 04:12:10 +00:00
|
|
|
#endif
|
2010-05-10 16:26:12 +00:00
|
|
|
#ifdef OMAP1_PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&OMAP1_PLATFORM_DRIVER);
|
|
|
|
error_omap1_platform:
|
|
|
|
#endif
|
|
|
|
#ifdef OMAP3_PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
|
|
|
|
error_omap3_platform:
|
|
|
|
#endif
|
2007-01-16 04:12:10 +00:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 03:04:35 +00:00
|
|
|
ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
2007-01-16 04:12:10 +00:00
|
|
|
error_ps3:
|
2006-12-13 20:09:54 +00:00
|
|
|
#endif
|
2007-09-11 21:07:31 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
debugfs_remove(ohci_debug_root);
|
|
|
|
ohci_debug_root = NULL;
|
|
|
|
error_debug:
|
|
|
|
#endif
|
|
|
|
|
2008-10-02 15:48:13 +00:00
|
|
|
clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
|
2006-12-13 20:09:54 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
module_init(ohci_hcd_mod_init);
|
|
|
|
|
|
|
|
static void __exit ohci_hcd_mod_exit(void)
|
|
|
|
{
|
2008-10-08 12:14:23 +00:00
|
|
|
#ifdef TMIO_OHCI_DRIVER
|
|
|
|
platform_driver_unregister(&TMIO_OHCI_DRIVER);
|
|
|
|
#endif
|
2008-06-08 16:20:11 +00:00
|
|
|
#ifdef SM501_OHCI_DRIVER
|
|
|
|
platform_driver_unregister(&SM501_OHCI_DRIVER);
|
|
|
|
#endif
|
2007-10-10 06:47:17 +00:00
|
|
|
#ifdef SSB_OHCI_DRIVER
|
|
|
|
ssb_driver_unregister(&SSB_OHCI_DRIVER);
|
|
|
|
#endif
|
2006-12-13 20:09:54 +00:00
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
|
|
|
#endif
|
|
|
|
#ifdef SA1111_DRIVER
|
|
|
|
sa1111_driver_unregister(&SA1111_DRIVER);
|
|
|
|
#endif
|
2006-12-13 20:09:55 +00:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2006-12-13 20:09:55 +00:00
|
|
|
#endif
|
2006-12-13 20:09:54 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
#endif
|
2010-09-13 23:10:01 +00:00
|
|
|
#ifdef OMAP3_PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
|
|
|
|
#endif
|
2007-01-16 04:12:10 +00:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 03:04:35 +00:00
|
|
|
ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
2007-01-16 04:12:10 +00:00
|
|
|
#endif
|
2007-09-11 21:07:31 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
debugfs_remove(ohci_debug_root);
|
|
|
|
#endif
|
2008-10-02 15:48:13 +00:00
|
|
|
clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
|
2006-12-13 20:09:54 +00:00
|
|
|
}
|
|
|
|
module_exit(ohci_hcd_mod_exit);
|
|
|
|
|