2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Universal Host Controller Interface driver for USB.
|
|
|
|
*
|
|
|
|
* Maintainer: Alan Stern <stern@rowland.harvard.edu>
|
|
|
|
*
|
|
|
|
* (C) Copyright 1999 Linus Torvalds
|
|
|
|
* (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
|
|
|
|
* (C) Copyright 1999 Randy Dunlap
|
|
|
|
* (C) Copyright 1999 Georg Acher, acher@in.tum.de
|
|
|
|
* (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
|
|
|
|
* (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
|
|
|
|
* (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
|
|
|
|
* (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
|
|
|
|
* support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
|
|
|
|
* (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
|
2007-02-19 13:52:45 -07:00
|
|
|
* (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Intel documents this fairly well, and as far as I know there
|
|
|
|
* are no royalties or anything like that, but even so there are
|
|
|
|
* people who decided that they want to do the same thing in a
|
|
|
|
* completely different way.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/dmapool.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-10-10 08:54:00 -06:00
|
|
|
#include <linux/dmi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
|
|
|
|
#include "../core/hcd.h"
|
|
|
|
#include "uhci-hcd.h"
|
2006-03-25 10:01:53 -07:00
|
|
|
#include "pci-quirks.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
|
|
|
#define DRIVER_AUTHOR "Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, \
|
|
|
|
Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber, \
|
|
|
|
Alan Stern"
|
|
|
|
#define DRIVER_DESC "USB Universal Host Controller Interface driver"
|
|
|
|
|
2006-12-05 14:29:55 -07:00
|
|
|
/* for flakey hardware, ignore overcurrent indicators */
|
|
|
|
static int ignore_oc;
|
|
|
|
module_param(ignore_oc, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(ignore_oc, "ignore hardware overcurrent indications");
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* debug = 0, no debugging messages
|
2005-11-30 15:16:19 -07:00
|
|
|
* debug = 1, dump failed URBs except for stalls
|
|
|
|
* debug = 2, dump all failed URBs (including stalls)
|
2005-04-16 16:20:36 -06:00
|
|
|
* show all queues in /debug/uhci/[pci_addr]
|
2005-11-30 15:16:19 -07:00
|
|
|
* debug = 3, show all TDs in URBs when dumping
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#ifdef DEBUG
|
2005-12-17 16:03:37 -07:00
|
|
|
#define DEBUG_CONFIGURED 1
|
2005-04-16 16:20:36 -06:00
|
|
|
static int debug = 1;
|
|
|
|
module_param(debug, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug level");
|
2005-12-17 16:03:37 -07:00
|
|
|
|
|
|
|
#else
|
|
|
|
#define DEBUG_CONFIGURED 0
|
|
|
|
#define debug 0
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static char *errbuf;
|
|
|
|
#define ERRBUF_LEN (32 * 1024)
|
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *uhci_up_cachep; /* urb_priv */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-21 14:04:58 -06:00
|
|
|
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
|
|
|
|
static void wakeup_rh(struct uhci_hcd *uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
|
|
|
|
|
2007-01-08 10:00:28 -07:00
|
|
|
/*
|
|
|
|
* Calculate the link pointer DMA value for the first Skeleton QH in a frame.
|
|
|
|
*/
|
|
|
|
static __le32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
|
|
|
|
{
|
|
|
|
int skelnum;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The interrupt queues will be interleaved as evenly as possible.
|
|
|
|
* There's not much to be done about period-1 interrupts; they have
|
|
|
|
* to occur in every frame. But we can schedule period-2 interrupts
|
|
|
|
* in odd-numbered frames, period-4 interrupts in frames congruent
|
|
|
|
* to 2 (mod 4), and so on. This way each frame only has two
|
|
|
|
* interrupt QHs, which will help spread out bandwidth utilization.
|
|
|
|
*
|
|
|
|
* ffs (Find First bit Set) does exactly what we need:
|
2007-02-19 13:52:45 -07:00
|
|
|
* 1,3,5,... => ffs = 0 => use period-2 QH = skelqh[8],
|
|
|
|
* 2,6,10,... => ffs = 1 => use period-4 QH = skelqh[7], etc.
|
2007-01-08 10:00:28 -07:00
|
|
|
* ffs >= 7 => not on any high-period queue, so use
|
2007-02-19 13:52:45 -07:00
|
|
|
* period-1 QH = skelqh[9].
|
2007-01-08 10:00:28 -07:00
|
|
|
* Add in UHCI_NUMFRAMES to insure at least one bit is set.
|
|
|
|
*/
|
|
|
|
skelnum = 8 - (int) __ffs(frame | UHCI_NUMFRAMES);
|
|
|
|
if (skelnum <= 1)
|
|
|
|
skelnum = 9;
|
2007-02-19 13:51:51 -07:00
|
|
|
return LINK_TO_QH(uhci->skelqh[skelnum]);
|
2007-01-08 10:00:28 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "uhci-debug.c"
|
|
|
|
#include "uhci-q.c"
|
2005-09-05 11:59:51 -06:00
|
|
|
#include "uhci-hub.c"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
/*
|
2005-10-03 14:36:29 -06:00
|
|
|
* Finish up a host controller reset and update the recorded state.
|
2005-04-09 15:29:00 -06:00
|
|
|
*/
|
2005-10-03 14:36:29 -06:00
|
|
|
static void finish_reset(struct uhci_hcd *uhci)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-04-22 12:39:12 -06:00
|
|
|
int port;
|
|
|
|
|
|
|
|
/* HCRESET doesn't affect the Suspend, Reset, and Resume Detect
|
|
|
|
* bits in the port status and control registers.
|
|
|
|
* We have to clear them by hand.
|
|
|
|
*/
|
|
|
|
for (port = 0; port < uhci->rh_numports; ++port)
|
|
|
|
outw(0, uhci->io_addr + USBPORTSC1 + (port * 2));
|
|
|
|
|
2006-04-04 12:47:44 -06:00
|
|
|
uhci->port_c_suspend = uhci->resuming_ports = 0;
|
2005-04-09 15:27:32 -06:00
|
|
|
uhci->rh_state = UHCI_RH_RESET;
|
2005-04-09 15:29:00 -06:00
|
|
|
uhci->is_stopped = UHCI_IS_STOPPED;
|
|
|
|
uhci_to_hcd(uhci)->state = HC_STATE_HALT;
|
2005-04-21 14:04:58 -06:00
|
|
|
uhci_to_hcd(uhci)->poll_rh = 0;
|
2006-06-05 10:21:30 -06:00
|
|
|
|
|
|
|
uhci->dead = 0; /* Full reset resurrects the controller */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-04-09 15:30:08 -06:00
|
|
|
/*
|
|
|
|
* Last rites for a defunct/nonfunctional controller
|
2005-04-28 12:51:27 -06:00
|
|
|
* or one we don't want to use any more.
|
2005-04-09 15:30:08 -06:00
|
|
|
*/
|
2006-06-05 10:21:30 -06:00
|
|
|
static void uhci_hc_died(struct uhci_hcd *uhci)
|
2005-04-09 15:30:08 -06:00
|
|
|
{
|
2006-06-05 10:21:30 -06:00
|
|
|
uhci_get_current_frame_number(uhci);
|
2005-10-03 14:36:29 -06:00
|
|
|
uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
|
|
|
|
finish_reset(uhci);
|
2006-06-05 10:21:30 -06:00
|
|
|
uhci->dead = 1;
|
|
|
|
|
|
|
|
/* The current frame may already be partway finished */
|
|
|
|
++uhci->frame_number;
|
2005-04-09 15:30:08 -06:00
|
|
|
}
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
/*
|
2006-06-05 10:16:39 -06:00
|
|
|
* Initialize a controller that was newly discovered or has lost power
|
|
|
|
* or otherwise been reset while it was suspended. In none of these cases
|
|
|
|
* can we be sure of its previous state.
|
2005-04-09 15:29:00 -06:00
|
|
|
*/
|
|
|
|
static void check_and_reset_hc(struct uhci_hcd *uhci)
|
|
|
|
{
|
2005-10-03 14:36:29 -06:00
|
|
|
if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
|
|
|
|
finish_reset(uhci);
|
2005-04-09 15:29:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the basic register settings needed by the controller.
|
|
|
|
*/
|
|
|
|
static void configure_hc(struct uhci_hcd *uhci)
|
|
|
|
{
|
|
|
|
/* Set the frame length to the default: 1 ms exactly */
|
|
|
|
outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);
|
|
|
|
|
|
|
|
/* Store the frame list base address */
|
2005-09-16 12:22:51 -06:00
|
|
|
outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
|
2005-04-09 15:29:00 -06:00
|
|
|
|
|
|
|
/* Set the current frame number */
|
2006-05-19 14:34:57 -06:00
|
|
|
outw(uhci->frame_number & UHCI_MAX_SOF_NUMBER,
|
|
|
|
uhci->io_addr + USBFRNUM);
|
2005-04-09 15:29:00 -06:00
|
|
|
|
2005-10-17 08:42:06 -06:00
|
|
|
/* Mark controller as not halted before we enable interrupts */
|
|
|
|
uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
|
2005-04-09 15:29:00 -06:00
|
|
|
mb();
|
|
|
|
|
|
|
|
/* Enable PIRQ */
|
|
|
|
pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP,
|
|
|
|
USBLEGSUP_DEFAULT);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-09 15:27:32 -06:00
|
|
|
static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-04-09 15:27:32 -06:00
|
|
|
int port;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-05 14:29:55 -07:00
|
|
|
/* If we have to ignore overcurrent events then almost by definition
|
|
|
|
* we can't depend on resume-detect interrupts. */
|
|
|
|
if (ignore_oc)
|
|
|
|
return 1;
|
|
|
|
|
2005-04-09 15:27:32 -06:00
|
|
|
switch (to_pci_dev(uhci_dev(uhci))->vendor) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCI_VENDOR_ID_GENESYS:
|
|
|
|
/* Genesys Logic's GL880S controllers don't generate
|
|
|
|
* resume-detect interrupts.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PCI_VENDOR_ID_INTEL:
|
|
|
|
/* Some of Intel's USB controllers have a bug that causes
|
|
|
|
* resume-detect interrupts if any port has an over-current
|
|
|
|
* condition. To make matters worse, some motherboards
|
|
|
|
* hardwire unused USB ports' over-current inputs active!
|
|
|
|
* To prevent problems, we will not enable resume-detect
|
|
|
|
* interrupts if any ports are OC.
|
|
|
|
*/
|
|
|
|
for (port = 0; port < uhci->rh_numports; ++port) {
|
|
|
|
if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
|
|
|
|
USBPORTSC_OC)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-22 08:49:15 -06:00
|
|
|
static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
|
2006-10-10 08:54:00 -06:00
|
|
|
{
|
|
|
|
int port;
|
2007-10-03 13:15:40 -06:00
|
|
|
const char *sys_info;
|
2006-12-15 14:06:25 -07:00
|
|
|
static char bad_Asus_board[] = "A7V8X";
|
2006-10-10 08:54:00 -06:00
|
|
|
|
|
|
|
/* One of Asus's motherboards has a bug which causes it to
|
|
|
|
* wake up immediately from suspend-to-RAM if any of the ports
|
|
|
|
* are connected. In such cases we will not set EGSM.
|
|
|
|
*/
|
2006-12-15 14:06:25 -07:00
|
|
|
sys_info = dmi_get_system_info(DMI_BOARD_NAME);
|
|
|
|
if (sys_info && !strcmp(sys_info, bad_Asus_board)) {
|
2006-10-10 08:54:00 -06:00
|
|
|
for (port = 0; port < uhci->rh_numports; ++port) {
|
|
|
|
if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
|
|
|
|
USBPORTSC_CCS)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
|
2005-04-09 15:27:32 -06:00
|
|
|
__releases(uhci->lock)
|
|
|
|
__acquires(uhci->lock)
|
|
|
|
{
|
|
|
|
int auto_stop;
|
2008-04-22 08:49:15 -06:00
|
|
|
int int_enable, egsm_enable, wakeup_enable;
|
2008-04-14 10:17:10 -06:00
|
|
|
struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
|
2005-04-09 15:27:32 -06:00
|
|
|
|
|
|
|
auto_stop = (new_state == UHCI_RH_AUTO_STOPPED);
|
2008-04-14 10:17:10 -06:00
|
|
|
dev_dbg(&rhdev->dev, "%s%s\n", __func__,
|
2005-04-09 15:27:32 -06:00
|
|
|
(auto_stop ? " (auto-stop)" : ""));
|
|
|
|
|
2008-04-22 08:49:15 -06:00
|
|
|
/* Start off by assuming Resume-Detect interrupts and EGSM work
|
|
|
|
* and that remote wakeups should be enabled.
|
2005-04-09 15:27:32 -06:00
|
|
|
*/
|
2006-10-10 08:54:00 -06:00
|
|
|
egsm_enable = USBCMD_EGSM;
|
2008-04-22 08:49:15 -06:00
|
|
|
uhci->RD_enable = 1;
|
2005-09-05 11:59:51 -06:00
|
|
|
int_enable = USBINTR_RESUME;
|
2008-04-22 08:49:15 -06:00
|
|
|
wakeup_enable = 1;
|
|
|
|
|
|
|
|
/* In auto-stop mode wakeups must always be detected, but
|
|
|
|
* Resume-Detect interrupts may be prohibited. (In the absence
|
|
|
|
* of CONFIG_PM, they are always disallowed.)
|
|
|
|
*/
|
|
|
|
if (auto_stop) {
|
|
|
|
if (!device_may_wakeup(&rhdev->dev))
|
|
|
|
int_enable = 0;
|
|
|
|
|
|
|
|
/* In bus-suspend mode wakeups may be disabled, but if they are
|
|
|
|
* allowed then so are Resume-Detect interrupts.
|
|
|
|
*/
|
|
|
|
} else {
|
2008-04-14 10:17:10 -06:00
|
|
|
#ifdef CONFIG_PM
|
2008-04-22 08:49:15 -06:00
|
|
|
if (!rhdev->do_remote_wakeup)
|
|
|
|
wakeup_enable = 0;
|
2008-04-14 10:17:10 -06:00
|
|
|
#endif
|
2008-04-22 08:49:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* EGSM causes the root hub to echo a 'K' signal (resume) out any
|
|
|
|
* port which requests a remote wakeup. According to the USB spec,
|
|
|
|
* every hub is supposed to do this. But if we are ignoring
|
|
|
|
* remote-wakeup requests anyway then there's no point to it.
|
|
|
|
* We also shouldn't enable EGSM if it's broken.
|
|
|
|
*/
|
|
|
|
if (!wakeup_enable || global_suspend_mode_is_broken(uhci))
|
|
|
|
egsm_enable = 0;
|
|
|
|
|
|
|
|
/* If we're ignoring wakeup events then there's no reason to
|
|
|
|
* enable Resume-Detect interrupts. We also shouldn't enable
|
|
|
|
* them if they are broken or disallowed.
|
|
|
|
*
|
|
|
|
* This logic may lead us to enabling RD but not EGSM. The UHCI
|
|
|
|
* spec foolishly says that RD works only when EGSM is on, but
|
|
|
|
* there's no harm in enabling it anyway -- perhaps some chips
|
|
|
|
* will implement it!
|
|
|
|
*/
|
|
|
|
if (!wakeup_enable || resume_detect_interrupts_are_broken(uhci) ||
|
|
|
|
!int_enable)
|
|
|
|
uhci->RD_enable = int_enable = 0;
|
2006-10-10 08:54:00 -06:00
|
|
|
|
2005-04-09 15:27:32 -06:00
|
|
|
outw(int_enable, uhci->io_addr + USBINTR);
|
2006-10-10 08:54:00 -06:00
|
|
|
outw(egsm_enable | USBCMD_CF, uhci->io_addr + USBCMD);
|
2005-04-09 15:29:00 -06:00
|
|
|
mb();
|
2005-04-09 15:27:32 -06:00
|
|
|
udelay(5);
|
|
|
|
|
|
|
|
/* If we're auto-stopping then no devices have been attached
|
|
|
|
* for a while, so there shouldn't be any active URBs and the
|
|
|
|
* controller should stop after a few microseconds. Otherwise
|
|
|
|
* we will give the controller one frame to stop.
|
|
|
|
*/
|
|
|
|
if (!auto_stop && !(inw(uhci->io_addr + USBSTS) & USBSTS_HCH)) {
|
|
|
|
uhci->rh_state = UHCI_RH_SUSPENDING;
|
|
|
|
spin_unlock_irq(&uhci->lock);
|
|
|
|
msleep(1);
|
|
|
|
spin_lock_irq(&uhci->lock);
|
2006-06-05 10:21:30 -06:00
|
|
|
if (uhci->dead)
|
2005-04-09 15:30:08 -06:00
|
|
|
return;
|
2005-04-09 15:27:32 -06:00
|
|
|
}
|
|
|
|
if (!(inw(uhci->io_addr + USBSTS) & USBSTS_HCH))
|
2008-04-14 10:17:10 -06:00
|
|
|
dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
uhci_get_current_frame_number(uhci);
|
2005-04-09 15:27:32 -06:00
|
|
|
|
|
|
|
uhci->rh_state = new_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
uhci->is_stopped = UHCI_IS_STOPPED;
|
2008-04-22 08:49:15 -06:00
|
|
|
|
|
|
|
/* If interrupts don't work and remote wakeup is enabled then
|
|
|
|
* the suspended root hub needs to be polled.
|
|
|
|
*/
|
|
|
|
uhci_to_hcd(uhci)->poll_rh = (!int_enable && wakeup_enable);
|
2005-04-16 16:20:36 -06: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 07:55:46 -06:00
|
|
|
uhci_scan_schedule(uhci);
|
2006-05-12 09:35:45 -06:00
|
|
|
uhci_fsbr_off(uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
static void start_rh(struct uhci_hcd *uhci)
|
|
|
|
{
|
2005-10-17 08:42:06 -06:00
|
|
|
uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
|
2005-04-09 15:29:00 -06:00
|
|
|
uhci->is_stopped = 0;
|
|
|
|
|
|
|
|
/* Mark it configured and running with a 64-byte max packet.
|
|
|
|
* All interrupts are enabled, even though RESUME won't do anything.
|
|
|
|
*/
|
|
|
|
outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, uhci->io_addr + USBCMD);
|
|
|
|
outw(USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP,
|
|
|
|
uhci->io_addr + USBINTR);
|
|
|
|
mb();
|
2005-04-21 14:04:58 -06:00
|
|
|
uhci->rh_state = UHCI_RH_RUNNING;
|
|
|
|
uhci_to_hcd(uhci)->poll_rh = 1;
|
2005-04-09 15:29:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void wakeup_rh(struct uhci_hcd *uhci)
|
2005-04-09 15:27:32 -06:00
|
|
|
__releases(uhci->lock)
|
|
|
|
__acquires(uhci->lock)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-06-05 10:16:39 -06:00
|
|
|
dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
|
2008-03-03 17:08:34 -07:00
|
|
|
"%s%s\n", __func__,
|
2005-04-09 15:27:32 -06:00
|
|
|
uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
|
|
|
|
" (auto-start)" : "");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:27:32 -06:00
|
|
|
/* If we are auto-stopped then no devices are attached so there's
|
|
|
|
* no need for wakeup signals. Otherwise we send Global Resume
|
|
|
|
* for 20 ms.
|
|
|
|
*/
|
|
|
|
if (uhci->rh_state == UHCI_RH_SUSPENDED) {
|
2008-04-22 08:49:15 -06:00
|
|
|
unsigned egsm;
|
|
|
|
|
|
|
|
/* Keep EGSM on if it was set before */
|
|
|
|
egsm = inw(uhci->io_addr + USBCMD) & USBCMD_EGSM;
|
2005-04-09 15:27:32 -06:00
|
|
|
uhci->rh_state = UHCI_RH_RESUMING;
|
2008-04-22 08:49:15 -06:00
|
|
|
outw(USBCMD_FGR | USBCMD_CF | egsm, uhci->io_addr + USBCMD);
|
2005-04-09 15:27:32 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
|
|
|
msleep(20);
|
|
|
|
spin_lock_irq(&uhci->lock);
|
2006-06-05 10:21:30 -06:00
|
|
|
if (uhci->dead)
|
2005-04-09 15:30:08 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:27:32 -06:00
|
|
|
/* End Global Resume and wait for EOP to be sent */
|
|
|
|
outw(USBCMD_CF, uhci->io_addr + USBCMD);
|
2005-04-09 15:29:00 -06:00
|
|
|
mb();
|
2005-04-09 15:27:32 -06:00
|
|
|
udelay(4);
|
|
|
|
if (inw(uhci->io_addr + USBCMD) & USBCMD_FGR)
|
|
|
|
dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
start_rh(uhci);
|
2005-04-09 15:27:32 -06:00
|
|
|
|
2005-04-21 14:04:58 -06:00
|
|
|
/* Restart root hub polling */
|
|
|
|
mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
|
2005-04-16 16:20:36 -06: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 07:55:46 -06:00
|
|
|
static irqreturn_t uhci_irq(struct usb_hcd *hcd)
|
2005-04-09 15:24:42 -06:00
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
|
|
|
unsigned short status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2005-04-09 15:24:42 -06:00
|
|
|
* Read the interrupt status, and write it back to clear the
|
|
|
|
* interrupt cause. Contrary to the UHCI specification, the
|
|
|
|
* "HC Halted" status bit is persistent: it is RO, not R/WC.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2005-04-09 15:29:00 -06:00
|
|
|
status = inw(uhci->io_addr + USBSTS);
|
2005-04-09 15:24:42 -06:00
|
|
|
if (!(status & ~USBSTS_HCH)) /* shared interrupt, not mine */
|
|
|
|
return IRQ_NONE;
|
2005-04-09 15:29:00 -06:00
|
|
|
outw(status, uhci->io_addr + USBSTS); /* Clear it */
|
2005-04-09 15:24:42 -06:00
|
|
|
|
|
|
|
if (status & ~(USBSTS_USBINT | USBSTS_ERROR | USBSTS_RD)) {
|
|
|
|
if (status & USBSTS_HSE)
|
|
|
|
dev_err(uhci_dev(uhci), "host system error, "
|
|
|
|
"PCI problems?\n");
|
|
|
|
if (status & USBSTS_HCPE)
|
|
|
|
dev_err(uhci_dev(uhci), "host controller process "
|
|
|
|
"error, something bad happened!\n");
|
2005-04-09 15:30:08 -06:00
|
|
|
if (status & USBSTS_HCH) {
|
2007-12-06 12:47:08 -07:00
|
|
|
spin_lock(&uhci->lock);
|
2005-04-09 15:30:08 -06:00
|
|
|
if (uhci->rh_state >= UHCI_RH_RUNNING) {
|
|
|
|
dev_err(uhci_dev(uhci),
|
|
|
|
"host controller halted, "
|
2005-04-09 15:24:42 -06:00
|
|
|
"very bad!\n");
|
2005-12-17 16:03:37 -07:00
|
|
|
if (debug > 1 && errbuf) {
|
|
|
|
/* Print the schedule for debugging */
|
|
|
|
uhci_sprint_schedule(uhci,
|
|
|
|
errbuf, ERRBUF_LEN);
|
|
|
|
lprintk(errbuf);
|
|
|
|
}
|
2006-06-05 10:21:30 -06:00
|
|
|
uhci_hc_died(uhci);
|
2005-09-05 11:59:51 -06:00
|
|
|
|
|
|
|
/* Force a callback in case there are
|
|
|
|
* pending unlinks */
|
|
|
|
mod_timer(&hcd->rh_timer, jiffies);
|
2005-04-09 15:30:08 -06:00
|
|
|
}
|
2007-12-06 12:47:08 -07:00
|
|
|
spin_unlock(&uhci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-09 15:24:42 -06:00
|
|
|
if (status & USBSTS_RD)
|
2005-04-21 14:04:58 -06:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-09-05 11:59:51 -06:00
|
|
|
else {
|
2007-12-06 12:47:08 -07:00
|
|
|
spin_lock(&uhci->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 07:55:46 -06:00
|
|
|
uhci_scan_schedule(uhci);
|
2007-12-06 12:47:08 -07:00
|
|
|
spin_unlock(&uhci->lock);
|
2005-09-05 11:59:51 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:24:42 -06:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-09 15:24:42 -06:00
|
|
|
/*
|
|
|
|
* Store the current frame number in uhci->frame_number if the controller
|
2006-05-19 14:34:57 -06:00
|
|
|
* is runnning. Expand from 11 bits (of which we use only 10) to a
|
|
|
|
* full-sized integer.
|
|
|
|
*
|
|
|
|
* Like many other parts of the driver, this code relies on being polled
|
|
|
|
* more than once per second as long as the controller is running.
|
2005-04-09 15:24:42 -06:00
|
|
|
*/
|
|
|
|
static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
|
|
|
|
{
|
2006-05-19 14:34:57 -06:00
|
|
|
if (!uhci->is_stopped) {
|
|
|
|
unsigned delta;
|
|
|
|
|
|
|
|
delta = (inw(uhci->io_addr + USBFRNUM) - uhci->frame_number) &
|
|
|
|
(UHCI_NUMFRAMES - 1);
|
|
|
|
uhci->frame_number += delta;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* De-allocate all resources
|
|
|
|
*/
|
|
|
|
static void release_uhci(struct uhci_hcd *uhci)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-12-17 16:03:37 -07:00
|
|
|
if (DEBUG_CONFIGURED) {
|
|
|
|
spin_lock_irq(&uhci->lock);
|
|
|
|
uhci->is_initialized = 0;
|
|
|
|
spin_unlock_irq(&uhci->lock);
|
|
|
|
|
|
|
|
debugfs_remove(uhci->dentry);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < UHCI_NUM_SKELQH; i++)
|
2005-09-16 12:17:45 -06:00
|
|
|
uhci_free_qh(uhci, uhci->skelqh[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:17:45 -06:00
|
|
|
uhci_free_td(uhci, uhci->term_td);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:17:45 -06:00
|
|
|
dma_pool_destroy(uhci->qh_pool);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:17:45 -06:00
|
|
|
dma_pool_destroy(uhci->td_pool);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:22:51 -06:00
|
|
|
kfree(uhci->frame_cpu);
|
|
|
|
|
|
|
|
dma_free_coherent(uhci_dev(uhci),
|
|
|
|
UHCI_NUMFRAMES * sizeof(*uhci->frame),
|
|
|
|
uhci->frame, uhci->frame_dma_handle);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-05 10:16:39 -06:00
|
|
|
static int uhci_init(struct usb_hcd *hcd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2005-04-22 12:39:12 -06:00
|
|
|
unsigned io_size = (unsigned) hcd->rsrc_len;
|
|
|
|
int port;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
uhci->io_addr = (unsigned long) hcd->rsrc_start;
|
|
|
|
|
2005-04-22 12:39:12 -06:00
|
|
|
/* The UHCI spec says devices must have 2 ports, and goes on to say
|
|
|
|
* they may have more but gives no way to determine how many there
|
2005-05-31 14:33:21 -06:00
|
|
|
* are. However according to the UHCI spec, Bit 7 of the port
|
2005-04-22 12:39:12 -06:00
|
|
|
* status and control register is always set to 1. So we try to
|
2005-05-31 14:33:21 -06:00
|
|
|
* use this to our advantage. Another common failure mode when
|
|
|
|
* a nonexistent register is addressed is to return all ones, so
|
|
|
|
* we test for that also.
|
2005-04-22 12:39:12 -06:00
|
|
|
*/
|
|
|
|
for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
|
|
|
|
unsigned int portstatus;
|
|
|
|
|
|
|
|
portstatus = inw(uhci->io_addr + USBPORTSC1 + (port * 2));
|
2005-05-31 14:33:21 -06:00
|
|
|
if (!(portstatus & 0x0080) || portstatus == 0xffff)
|
2005-04-22 12:39:12 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (debug)
|
|
|
|
dev_info(uhci_dev(uhci), "detected %d ports\n", port);
|
|
|
|
|
2005-05-31 14:33:21 -06:00
|
|
|
/* Anything greater than 7 is weird so we'll ignore it. */
|
|
|
|
if (port > UHCI_RH_MAXCHILD) {
|
2005-04-22 12:39:12 -06:00
|
|
|
dev_info(uhci_dev(uhci), "port count misdetected? "
|
|
|
|
"forcing to 2 ports\n");
|
|
|
|
port = 2;
|
|
|
|
}
|
|
|
|
uhci->rh_numports = port;
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
/* Kick BIOS off this hardware and reset if the controller
|
|
|
|
* isn't already safely quiescent.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2005-04-09 15:29:00 -06:00
|
|
|
check_and_reset_hc(uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-28 12:51:27 -06:00
|
|
|
/* Make sure the controller is quiescent and that we're not using it
|
|
|
|
* any more. This is mainly for the benefit of programs which, like kexec,
|
|
|
|
* expect the hardware to be idle: not doing DMA or generating IRQs.
|
|
|
|
*
|
|
|
|
* This routine may be called in a damaged or failing kernel. Hence we
|
|
|
|
* do not acquire the spinlock before shutting down the controller.
|
|
|
|
*/
|
|
|
|
static void uhci_shutdown(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = (struct usb_hcd *) pci_get_drvdata(pdev);
|
|
|
|
|
2006-06-05 10:21:30 -06:00
|
|
|
uhci_hc_died(hcd_to_uhci(hcd));
|
2005-04-28 12:51:27 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Allocate a frame list, and then setup the skeleton
|
|
|
|
*
|
|
|
|
* The hardware doesn't really know any difference
|
|
|
|
* in the queues, but the order does matter for the
|
2007-02-19 13:52:45 -07:00
|
|
|
* protocols higher up. The order in which the queues
|
|
|
|
* are encountered by the hardware is:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-02-19 13:52:45 -07:00
|
|
|
* - All isochronous events are handled before any
|
2005-04-16 16:20:36 -06:00
|
|
|
* of the queues. We don't do that here, because
|
|
|
|
* we'll create the actual TD entries on demand.
|
2007-02-19 13:52:45 -07:00
|
|
|
* - The first queue is the high-period interrupt queue.
|
|
|
|
* - The second queue is the period-1 interrupt and async
|
|
|
|
* (low-speed control, full-speed control, then bulk) queue.
|
|
|
|
* - The third queue is the terminating bandwidth reclamation queue,
|
|
|
|
* which contains no members, loops back to itself, and is present
|
|
|
|
* only when FSBR is on and there are no full-speed control or bulk QHs.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static int uhci_start(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
|
|
|
int retval = -EBUSY;
|
2005-04-22 12:39:12 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dentry *dentry;
|
|
|
|
|
2005-04-21 14:04:58 -06:00
|
|
|
hcd->uses_new_polling = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_init(&uhci->lock);
|
2006-06-05 10:28:57 -06:00
|
|
|
setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout,
|
|
|
|
(unsigned long) uhci);
|
2005-12-17 15:58:46 -07:00
|
|
|
INIT_LIST_HEAD(&uhci->idle_qh_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
init_waitqueue_head(&uhci->waitqh);
|
|
|
|
|
2005-12-17 16:03:37 -07:00
|
|
|
if (DEBUG_CONFIGURED) {
|
|
|
|
dentry = debugfs_create_file(hcd->self.bus_name,
|
|
|
|
S_IFREG|S_IRUGO|S_IWUSR, uhci_debugfs_root,
|
|
|
|
uhci, &uhci_debug_operations);
|
|
|
|
if (!dentry) {
|
|
|
|
dev_err(uhci_dev(uhci), "couldn't create uhci "
|
|
|
|
"debugfs entry\n");
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto err_create_debug_entry;
|
|
|
|
}
|
|
|
|
uhci->dentry = dentry;
|
|
|
|
}
|
|
|
|
|
2005-09-16 12:22:51 -06:00
|
|
|
uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
|
|
|
|
UHCI_NUMFRAMES * sizeof(*uhci->frame),
|
|
|
|
&uhci->frame_dma_handle, 0);
|
|
|
|
if (!uhci->frame) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_err(uhci_dev(uhci), "unable to allocate "
|
|
|
|
"consistent memory for frame list\n");
|
2005-09-16 12:22:51 -06:00
|
|
|
goto err_alloc_frame;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-09-16 12:22:51 -06:00
|
|
|
memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:22:51 -06:00
|
|
|
uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!uhci->frame_cpu) {
|
|
|
|
dev_err(uhci_dev(uhci), "unable to allocate "
|
|
|
|
"memory for frame pointers\n");
|
|
|
|
goto err_alloc_frame_cpu;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
|
|
|
|
sizeof(struct uhci_td), 16, 0);
|
|
|
|
if (!uhci->td_pool) {
|
|
|
|
dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
|
|
|
|
goto err_create_td_pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
|
|
|
|
sizeof(struct uhci_qh), 16, 0);
|
|
|
|
if (!uhci->qh_pool) {
|
|
|
|
dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
|
|
|
|
goto err_create_qh_pool;
|
|
|
|
}
|
|
|
|
|
2005-04-25 09:14:31 -06:00
|
|
|
uhci->term_td = uhci_alloc_td(uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!uhci->term_td) {
|
|
|
|
dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
|
|
|
|
goto err_alloc_term_td;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < UHCI_NUM_SKELQH; i++) {
|
2005-12-17 15:58:46 -07:00
|
|
|
uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!uhci->skelqh[i]) {
|
|
|
|
dev_err(uhci_dev(uhci), "unable to allocate QH\n");
|
|
|
|
goto err_alloc_skelqh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-02-19 13:52:45 -07:00
|
|
|
* 8 Interrupt queues; link all higher int queues to int1 = async
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-02-19 13:52:45 -07:00
|
|
|
for (i = SKEL_ISO + 1; i < SKEL_ASYNC; ++i)
|
|
|
|
uhci->skelqh[i]->link = LINK_TO_QH(uhci->skel_async_qh);
|
2007-03-19 13:31:42 -06:00
|
|
|
uhci->skel_async_qh->link = UHCI_PTR_TERM;
|
|
|
|
uhci->skel_term_qh->link = LINK_TO_QH(uhci->skel_term_qh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* This dummy TD is to work around a bug in Intel PIIX controllers */
|
2005-11-30 09:57:51 -07:00
|
|
|
uhci_fill_td(uhci->term_td, 0, uhci_explen(0) |
|
2007-02-19 13:52:45 -07:00
|
|
|
(0x7f << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN, 0);
|
|
|
|
uhci->term_td->link = UHCI_PTR_TERM;
|
|
|
|
uhci->skel_async_qh->element = uhci->skel_term_qh->element =
|
|
|
|
LINK_TO_TD(uhci->term_td);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill the frame list: make all entries point to the proper
|
|
|
|
* interrupt queue.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < UHCI_NUMFRAMES; i++) {
|
|
|
|
|
|
|
|
/* Only place we don't use the frame list routines */
|
2007-01-08 10:00:28 -07:00
|
|
|
uhci->frame[i] = uhci_frame_skel_link(uhci, i);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some architectures require a full mb() to enforce completion of
|
2005-04-09 15:29:00 -06:00
|
|
|
* the memory writes above before the I/O transfers in configure_hc().
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
mb();
|
2005-04-09 15:29:00 -06:00
|
|
|
|
|
|
|
configure_hc(uhci);
|
2005-12-17 16:03:37 -07:00
|
|
|
uhci->is_initialized = 1;
|
2005-04-09 15:29:00 -06:00
|
|
|
start_rh(uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* error exits:
|
|
|
|
*/
|
|
|
|
err_alloc_skelqh:
|
2005-09-16 12:17:45 -06:00
|
|
|
for (i = 0; i < UHCI_NUM_SKELQH; i++) {
|
|
|
|
if (uhci->skelqh[i])
|
2005-04-16 16:20:36 -06:00
|
|
|
uhci_free_qh(uhci, uhci->skelqh[i]);
|
2005-09-16 12:17:45 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
uhci_free_td(uhci, uhci->term_td);
|
|
|
|
|
|
|
|
err_alloc_term_td:
|
|
|
|
dma_pool_destroy(uhci->qh_pool);
|
|
|
|
|
|
|
|
err_create_qh_pool:
|
|
|
|
dma_pool_destroy(uhci->td_pool);
|
|
|
|
|
|
|
|
err_create_td_pool:
|
2005-09-16 12:22:51 -06:00
|
|
|
kfree(uhci->frame_cpu);
|
|
|
|
|
|
|
|
err_alloc_frame_cpu:
|
|
|
|
dma_free_coherent(uhci_dev(uhci),
|
|
|
|
UHCI_NUMFRAMES * sizeof(*uhci->frame),
|
|
|
|
uhci->frame, uhci->frame_dma_handle);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-16 12:22:51 -06:00
|
|
|
err_alloc_frame:
|
2005-04-16 16:20:36 -06:00
|
|
|
debugfs_remove(uhci->dentry);
|
|
|
|
|
|
|
|
err_create_debug_entry:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void uhci_stop(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
|
|
|
|
|
|
|
spin_lock_irq(&uhci->lock);
|
2006-06-05 10:21:30 -06:00
|
|
|
if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) && !uhci->dead)
|
|
|
|
uhci_hc_died(uhci);
|
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 07:55:46 -06:00
|
|
|
uhci_scan_schedule(uhci);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
2005-04-21 14:04:58 -06:00
|
|
|
|
2006-06-05 10:28:57 -06:00
|
|
|
del_timer_sync(&uhci->fsbr_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
release_uhci(uhci);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2005-04-09 15:29:00 -06:00
|
|
|
static int uhci_rh_suspend(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2006-06-05 10:16:39 -06:00
|
|
|
int rc = 0;
|
2005-04-09 15:29:00 -06:00
|
|
|
|
|
|
|
spin_lock_irq(&uhci->lock);
|
2006-06-05 10:16:39 -06:00
|
|
|
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
|
|
|
|
rc = -ESHUTDOWN;
|
2006-06-05 10:21:30 -06:00
|
|
|
else if (!uhci->dead)
|
2005-04-09 15:30:08 -06:00
|
|
|
suspend_rh(uhci, UHCI_RH_SUSPENDED);
|
2005-04-09 15:29:00 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
2006-06-05 10:16:39 -06:00
|
|
|
return rc;
|
2005-04-09 15:29:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int uhci_rh_resume(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2005-04-09 15:30:08 -06:00
|
|
|
int rc = 0;
|
2005-04-09 15:29:00 -06:00
|
|
|
|
|
|
|
spin_lock_irq(&uhci->lock);
|
2007-06-21 14:25:35 -06:00
|
|
|
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
|
2006-06-05 10:16:39 -06:00
|
|
|
rc = -ESHUTDOWN;
|
2007-06-21 14:25:35 -06:00
|
|
|
else if (!uhci->dead)
|
2005-04-09 15:30:08 -06:00
|
|
|
wakeup_rh(uhci);
|
2005-04-09 15:29:00 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
2005-04-09 15:30:08 -06:00
|
|
|
return rc;
|
2005-04-09 15:29:00 -06:00
|
|
|
}
|
|
|
|
|
2009-04-27 11:33:41 -06:00
|
|
|
static int uhci_pci_suspend(struct usb_hcd *hcd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2005-04-09 15:30:08 -06:00
|
|
|
int rc = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dev_dbg(uhci_dev(uhci), "%s\n", __func__);
|
2005-04-09 15:29:00 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_irq(&uhci->lock);
|
2006-06-05 10:21:30 -06:00
|
|
|
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)
|
|
|
|
goto done_okay; /* Already suspended or dead */
|
2005-04-09 15:29:00 -06:00
|
|
|
|
2005-04-09 15:30:08 -06:00
|
|
|
if (uhci->rh_state > UHCI_RH_SUSPENDED) {
|
|
|
|
dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
|
|
|
|
rc = -EBUSY;
|
|
|
|
goto done;
|
|
|
|
};
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
/* All PCI host controllers are required to disable IRQ generation
|
|
|
|
* at the source, so we must turn off PIRQ.
|
|
|
|
*/
|
|
|
|
pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP, 0);
|
2005-12-16 12:09:01 -07:00
|
|
|
mb();
|
2005-09-05 11:59:51 -06:00
|
|
|
hcd->poll_rh = 0;
|
2005-04-09 15:29:00 -06:00
|
|
|
|
|
|
|
/* FIXME: Enable non-PME# remote wakeup? */
|
|
|
|
|
2006-06-05 10:21:30 -06:00
|
|
|
done_okay:
|
|
|
|
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
2005-04-09 15:30:08 -06:00
|
|
|
done:
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
2005-04-09 15:30:08 -06:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-04-27 11:33:41 -06:00
|
|
|
static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dev_dbg(uhci_dev(uhci), "%s\n", __func__);
|
2005-04-09 15:29:00 -06:00
|
|
|
|
2005-11-30 15:16:19 -07:00
|
|
|
/* Since we aren't in D3 any more, it's safe to set this flag
|
2006-06-05 10:21:30 -06:00
|
|
|
* even if the controller was dead.
|
[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 15:59:46 -07:00
|
|
|
*/
|
|
|
|
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
2005-12-16 12:09:01 -07:00
|
|
|
mb();
|
[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 15:59:46 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_irq(&uhci->lock);
|
|
|
|
|
2009-04-27 11:33:41 -06:00
|
|
|
/* Make sure resume from hibernation re-enumerates everything */
|
|
|
|
if (hibernated)
|
|
|
|
uhci_hc_died(uhci);
|
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
/* FIXME: Disable non-PME# remote wakeup? */
|
|
|
|
|
2006-06-05 10:21:30 -06:00
|
|
|
/* The firmware or a boot kernel may have changed the controller
|
|
|
|
* settings during a system wakeup. Check it and reconfigure
|
|
|
|
* to avoid problems.
|
2005-04-09 15:29:00 -06:00
|
|
|
*/
|
|
|
|
check_and_reset_hc(uhci);
|
2006-06-05 10:21:30 -06:00
|
|
|
|
|
|
|
/* If the controller was dead before, it's back alive now */
|
2005-04-09 15:29:00 -06:00
|
|
|
configure_hc(uhci);
|
|
|
|
|
2005-11-14 09:45:38 -07:00
|
|
|
if (uhci->rh_state == UHCI_RH_RESET) {
|
|
|
|
|
|
|
|
/* The controller had to be reset */
|
|
|
|
usb_root_hub_lost_power(hcd->self.root_hub);
|
2005-04-09 15:29:00 -06:00
|
|
|
suspend_rh(uhci, UHCI_RH_SUSPENDED);
|
2005-11-14 09:45:38 -07:00
|
|
|
}
|
2005-04-09 15:27:32 -06:00
|
|
|
|
2005-04-09 15:29:00 -06:00
|
|
|
spin_unlock_irq(&uhci->lock);
|
2005-04-21 14:04:58 -06:00
|
|
|
|
2008-04-22 08:49:15 -06:00
|
|
|
/* If interrupts don't work and remote wakeup is enabled then
|
|
|
|
* the suspended root hub needs to be polled.
|
|
|
|
*/
|
|
|
|
if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup) {
|
2005-09-05 11:59:51 -06:00
|
|
|
hcd->poll_rh = 1;
|
2005-04-21 14:04:58 -06:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-09-05 11:59:51 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-12-17 15:58:46 -07:00
|
|
|
/* Wait until a particular device/endpoint's QH is idle, and free it */
|
2005-04-16 16:20:36 -06:00
|
|
|
static void uhci_hcd_endpoint_disable(struct usb_hcd *hcd,
|
2005-12-17 15:58:46 -07:00
|
|
|
struct usb_host_endpoint *hep)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2005-12-17 15:58:46 -07:00
|
|
|
struct uhci_qh *qh;
|
|
|
|
|
|
|
|
spin_lock_irq(&uhci->lock);
|
|
|
|
qh = (struct uhci_qh *) hep->hcpriv;
|
|
|
|
if (qh == NULL)
|
|
|
|
goto done;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-17 15:58:46 -07:00
|
|
|
while (qh->state != QH_STATE_IDLE) {
|
|
|
|
++uhci->num_waiting;
|
|
|
|
spin_unlock_irq(&uhci->lock);
|
|
|
|
wait_event_interruptible(uhci->waitqh,
|
|
|
|
qh->state == QH_STATE_IDLE);
|
|
|
|
spin_lock_irq(&uhci->lock);
|
|
|
|
--uhci->num_waiting;
|
|
|
|
}
|
|
|
|
|
|
|
|
uhci_free_qh(uhci, qh);
|
|
|
|
done:
|
|
|
|
spin_unlock_irq(&uhci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int uhci_hcd_get_frame_number(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
|
2006-05-19 14:34:57 -06:00
|
|
|
unsigned frame_number;
|
|
|
|
unsigned delta;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Minimize latency by avoiding the spinlock */
|
2006-05-19 14:34:57 -06:00
|
|
|
frame_number = uhci->frame_number;
|
|
|
|
barrier();
|
|
|
|
delta = (inw(uhci->io_addr + USBFRNUM) - frame_number) &
|
|
|
|
(UHCI_NUMFRAMES - 1);
|
|
|
|
return frame_number + delta;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char hcd_name[] = "uhci_hcd";
|
|
|
|
|
|
|
|
static const struct hc_driver uhci_driver = {
|
|
|
|
.description = hcd_name,
|
|
|
|
.product_desc = "UHCI Host Controller",
|
|
|
|
.hcd_priv_size = sizeof(struct uhci_hcd),
|
|
|
|
|
|
|
|
/* Generic hardware linkage */
|
|
|
|
.irq = uhci_irq,
|
|
|
|
.flags = HCD_USB11,
|
|
|
|
|
|
|
|
/* Basic lifecycle operations */
|
2006-06-05 10:16:39 -06:00
|
|
|
.reset = uhci_init,
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = uhci_start,
|
|
|
|
#ifdef CONFIG_PM
|
2008-04-03 16:03:06 -06:00
|
|
|
.pci_suspend = uhci_pci_suspend,
|
|
|
|
.pci_resume = uhci_pci_resume,
|
2005-10-13 15:08:02 -06:00
|
|
|
.bus_suspend = uhci_rh_suspend,
|
|
|
|
.bus_resume = uhci_rh_resume,
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
.stop = uhci_stop,
|
|
|
|
|
|
|
|
.urb_enqueue = uhci_urb_enqueue,
|
|
|
|
.urb_dequeue = uhci_urb_dequeue,
|
|
|
|
|
|
|
|
.endpoint_disable = uhci_hcd_endpoint_disable,
|
|
|
|
.get_frame_number = uhci_hcd_get_frame_number,
|
|
|
|
|
|
|
|
.hub_status_data = uhci_hub_status_data,
|
|
|
|
.hub_control = uhci_hub_control,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct pci_device_id uhci_pci_ids[] = { {
|
|
|
|
/* handle any USB UHCI controller */
|
2006-04-09 12:07:35 -06:00
|
|
|
PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
|
2005-04-16 16:20:36 -06:00
|
|
|
.driver_data = (unsigned long) &uhci_driver,
|
|
|
|
}, { /* end: all zeroes */ }
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
|
|
|
|
|
|
|
|
static struct pci_driver uhci_pci_driver = {
|
|
|
|
.name = (char *)hcd_name,
|
|
|
|
.id_table = uhci_pci_ids,
|
|
|
|
|
|
|
|
.probe = usb_hcd_pci_probe,
|
|
|
|
.remove = usb_hcd_pci_remove,
|
2005-04-28 12:51:27 -06:00
|
|
|
.shutdown = uhci_shutdown,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-27 11:33:24 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
.driver = {
|
|
|
|
.pm = &usb_hcd_pci_pm_ops
|
|
|
|
},
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init uhci_hcd_init(void)
|
|
|
|
{
|
|
|
|
int retval = -ENOMEM;
|
|
|
|
|
|
|
|
if (usb_disabled())
|
|
|
|
return -ENODEV;
|
|
|
|
|
2008-10-02 09:47:15 -06:00
|
|
|
printk(KERN_INFO "uhci_hcd: " DRIVER_DESC "%s\n",
|
|
|
|
ignore_oc ? ", overcurrent ignored" : "");
|
2008-10-02 09:48:13 -06:00
|
|
|
set_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
|
2008-10-02 09:47:15 -06:00
|
|
|
|
2005-12-17 16:03:37 -07:00
|
|
|
if (DEBUG_CONFIGURED) {
|
2005-04-16 16:20:36 -06:00
|
|
|
errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
|
|
|
|
if (!errbuf)
|
|
|
|
goto errbuf_failed;
|
2009-04-24 16:15:00 -06:00
|
|
|
uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);
|
2005-12-17 16:03:37 -07:00
|
|
|
if (!uhci_debugfs_root)
|
|
|
|
goto debug_failed;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
|
2007-07-19 19:11:58 -06:00
|
|
|
sizeof(struct urb_priv), 0, 0, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!uhci_up_cachep)
|
|
|
|
goto up_failed;
|
|
|
|
|
|
|
|
retval = pci_register_driver(&uhci_pci_driver);
|
|
|
|
if (retval)
|
|
|
|
goto init_failed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
init_failed:
|
2006-09-27 02:49:40 -06:00
|
|
|
kmem_cache_destroy(uhci_up_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
up_failed:
|
|
|
|
debugfs_remove(uhci_debugfs_root);
|
|
|
|
|
|
|
|
debug_failed:
|
2005-04-18 18:39:34 -06:00
|
|
|
kfree(errbuf);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
errbuf_failed:
|
|
|
|
|
2008-10-02 09:48:13 -06:00
|
|
|
clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit uhci_hcd_cleanup(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&uhci_pci_driver);
|
2006-09-27 02:49:40 -06:00
|
|
|
kmem_cache_destroy(uhci_up_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
debugfs_remove(uhci_debugfs_root);
|
2005-04-18 18:39:34 -06:00
|
|
|
kfree(errbuf);
|
2008-10-02 09:48:13 -06:00
|
|
|
clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(uhci_hcd_init);
|
|
|
|
module_exit(uhci_hcd_cleanup);
|
|
|
|
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_LICENSE("GPL");
|