2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2011-06-15 20:32:46 +00:00
|
|
|
* Enhanced Host Controller Interface (EHCI) driver for USB.
|
|
|
|
|
*
|
|
|
|
|
* Maintainer: Alan Stern <stern@rowland.harvard.edu>
|
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Copyright (c) 2000-2004 by David Brownell
|
2006-08-30 21:50:06 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
|
* option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
* for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
|
* Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/pci.h>
|
|
|
|
|
#include <linux/dmapool.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
|
#include <linux/sched.h>
|
2008-09-18 15:06:21 +00:00
|
|
|
#include <linux/vmalloc.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/timer.h>
|
2009-11-27 14:17:59 +00:00
|
|
|
#include <linux/ktime.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/usb.h>
|
2010-04-24 21:21:52 +00:00
|
|
|
#include <linux/usb/hcd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
|
#include <linux/dma-mapping.h>
|
2007-09-11 21:07:31 +00:00
|
|
|
#include <linux/debugfs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2010-06-04 07:47:54 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
|
2011-12-01 00:40:57 +00:00
|
|
|
#if defined(CONFIG_PPC_PS3)
|
|
|
|
|
#include <asm/firmware.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* EHCI hc_driver implementation ... experimental, incomplete.
|
|
|
|
|
* Based on the final 1.0 register interface specification.
|
|
|
|
|
*
|
|
|
|
|
* USB 2.0 shows up in upcoming www.pcmcia.org technology.
|
|
|
|
|
* First was PCMCIA, like ISA; then CardBus, which is PCI.
|
|
|
|
|
* Next comes "CardBay", using USB 2.0 signals.
|
|
|
|
|
*
|
|
|
|
|
* Contains additional contributions by Brad Hards, Rory Bolt, and others.
|
|
|
|
|
* Special thanks to Intel and VIA for providing host controllers to
|
|
|
|
|
* test this driver on, and Cypress (including In-System Design) for
|
|
|
|
|
* providing early devices for those host controllers to talk to!
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define DRIVER_AUTHOR "David Brownell"
|
|
|
|
|
#define DRIVER_DESC "USB 2.0 'Enhanced' Host Controller (EHCI) Driver"
|
|
|
|
|
|
|
|
|
|
static const char hcd_name [] = "ehci_hcd";
|
|
|
|
|
|
|
|
|
|
|
2008-02-01 19:42:05 +00:00
|
|
|
#undef VERBOSE_DEBUG
|
2005-04-16 22:20:36 +00:00
|
|
|
#undef EHCI_URB_TRACE
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
#define EHCI_STATS
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* magic numbers that can affect system performance */
|
|
|
|
|
#define EHCI_TUNE_CERR 3 /* 0-3 qtd retries; 0 == don't stop */
|
|
|
|
|
#define EHCI_TUNE_RL_HS 4 /* nak throttle; see 4.9 */
|
|
|
|
|
#define EHCI_TUNE_RL_TT 0
|
|
|
|
|
#define EHCI_TUNE_MULT_HS 1 /* 1-3 transactions/uframe; 4.10.3 */
|
|
|
|
|
#define EHCI_TUNE_MULT_TT 1
|
2010-07-14 15:03:46 +00:00
|
|
|
/*
|
|
|
|
|
* Some drivers think it's safe to schedule isochronous transfers more than
|
|
|
|
|
* 256 ms into the future (partly as a result of an old bug in the scheduling
|
|
|
|
|
* code). In an attempt to avoid trouble, we will use a minimum scheduling
|
|
|
|
|
* length of 512 frames instead of 256.
|
|
|
|
|
*/
|
|
|
|
|
#define EHCI_TUNE_FLS 1 /* (medium) 512-frame schedule */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
#define EHCI_IAA_MSECS 10 /* arbitrary */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EHCI_IO_JIFFIES (HZ/10) /* io watchdog > irq_thresh */
|
|
|
|
|
#define EHCI_ASYNC_JIFFIES (HZ/20) /* async idle timeout */
|
USB: EHCI: go back to using the system clock for QH unlinks
This patch (as1477) fixes a problem affecting a few types of EHCI
controller. Contrary to what one might expect, these controllers
automatically stop their internal frame counter when no ports are
enabled. Since ehci-hcd currently relies on the frame counter for
determining when it should unlink QHs from the async schedule, those
controllers run into trouble: The frame counter stops and the QHs
never get unlinked.
Some systems have also experienced other problems traced back to
commit b963801164618e25fbdc0cd452ce49c3628b46c8 (USB: ehci-hcd unlink
speedups), which made the original switch from using the system clock
to using the frame counter. It never became clear what the reason was
for these problems, but evidently it is related to use of the frame
counter.
To fix all these problems, this patch more or less reverts that commit
and goes back to using the system clock. But this can't be done
cleanly because other changes have since been made to the scan_async()
subroutine. One of these changes involved the tricky logic that tries
to avoid rescanning QHs that have already been seen when the scanning
loop is restarted, which happens whenever an URB is given back.
Switching back to clock-based unlinks would make this logic even more
complicated.
Therefore the new code doesn't rescan the entire async list whenever a
giveback occurs. Instead it rescans only the current QH and continues
on from there. This requires the use of a separate pointer to keep
track of the next QH to scan, since the current QH may be unlinked
while the scanning is in progress. That new pointer must be global,
so that it can be adjusted forward whenever the _next_ QH gets
unlinked. (uhci-hcd uses this same trick.)
Simplification of the scanning loop removes a level of indentation,
which accounts for the size of the patch. The amount of code changed
is relatively small, and it isn't exactly a reversion of the
b963801164 commit.
This fixes Bugzilla #32432.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Tested-by: Matej Kenda <matejken@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-07-05 16:34:05 +00:00
|
|
|
#define EHCI_SHRINK_JIFFIES (DIV_ROUND_UP(HZ, 200) + 1)
|
2011-09-05 13:05:57 +00:00
|
|
|
/* 5-ms async qh unlink delay */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* Initial IRQ latency: faster than hw default */
|
|
|
|
|
static int log2_irq_thresh = 0; // 0 to 6
|
|
|
|
|
module_param (log2_irq_thresh, int, S_IRUGO);
|
|
|
|
|
MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
|
|
|
|
|
|
|
|
|
|
/* initial park setting: slower than hw default */
|
|
|
|
|
static unsigned park = 0;
|
|
|
|
|
module_param (park, uint, S_IRUGO);
|
|
|
|
|
MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets");
|
|
|
|
|
|
2006-11-17 07:34:58 +00:00
|
|
|
/* for flakey hardware, ignore overcurrent indicators */
|
2012-01-12 23:02:20 +00:00
|
|
|
static bool ignore_oc = 0;
|
2006-11-17 07:34:58 +00:00
|
|
|
module_param (ignore_oc, bool, S_IRUGO);
|
|
|
|
|
MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
|
|
|
|
|
|
2010-06-04 07:47:55 +00:00
|
|
|
/* for link power management(LPM) feature */
|
|
|
|
|
static unsigned int hird;
|
|
|
|
|
module_param(hird, int, S_IRUGO);
|
2011-05-31 22:00:10 +00:00
|
|
|
MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
|
2010-06-04 07:47:55 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
#include "ehci.h"
|
|
|
|
|
#include "ehci-dbg.c"
|
2011-03-01 06:57:05 +00:00
|
|
|
#include "pci-quirks.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
2009-02-11 19:26:38 +00:00
|
|
|
static void
|
|
|
|
|
timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
|
|
|
|
|
{
|
|
|
|
|
/* Don't override timeouts which shrink or (later) disable
|
|
|
|
|
* the async ring; just the I/O watchdog. Note that if a
|
|
|
|
|
* SHRINK were pending, OFF would never be requested.
|
|
|
|
|
*/
|
|
|
|
|
if (timer_pending(&ehci->watchdog)
|
|
|
|
|
&& ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
|
|
|
|
|
& ehci->actions))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (!test_and_set_bit(action, &ehci->actions)) {
|
|
|
|
|
unsigned long t;
|
|
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
|
case TIMER_IO_WATCHDOG:
|
2009-07-13 09:30:41 +00:00
|
|
|
if (!ehci->need_io_watchdog)
|
|
|
|
|
return;
|
2009-02-11 19:26:38 +00:00
|
|
|
t = EHCI_IO_JIFFIES;
|
|
|
|
|
break;
|
|
|
|
|
case TIMER_ASYNC_OFF:
|
|
|
|
|
t = EHCI_ASYNC_JIFFIES;
|
|
|
|
|
break;
|
|
|
|
|
/* case TIMER_ASYNC_SHRINK: */
|
|
|
|
|
default:
|
USB: EHCI: go back to using the system clock for QH unlinks
This patch (as1477) fixes a problem affecting a few types of EHCI
controller. Contrary to what one might expect, these controllers
automatically stop their internal frame counter when no ports are
enabled. Since ehci-hcd currently relies on the frame counter for
determining when it should unlink QHs from the async schedule, those
controllers run into trouble: The frame counter stops and the QHs
never get unlinked.
Some systems have also experienced other problems traced back to
commit b963801164618e25fbdc0cd452ce49c3628b46c8 (USB: ehci-hcd unlink
speedups), which made the original switch from using the system clock
to using the frame counter. It never became clear what the reason was
for these problems, but evidently it is related to use of the frame
counter.
To fix all these problems, this patch more or less reverts that commit
and goes back to using the system clock. But this can't be done
cleanly because other changes have since been made to the scan_async()
subroutine. One of these changes involved the tricky logic that tries
to avoid rescanning QHs that have already been seen when the scanning
loop is restarted, which happens whenever an URB is given back.
Switching back to clock-based unlinks would make this logic even more
complicated.
Therefore the new code doesn't rescan the entire async list whenever a
giveback occurs. Instead it rescans only the current QH and continues
on from there. This requires the use of a separate pointer to keep
track of the next QH to scan, since the current QH may be unlinked
while the scanning is in progress. That new pointer must be global,
so that it can be adjusted forward whenever the _next_ QH gets
unlinked. (uhci-hcd uses this same trick.)
Simplification of the scanning loop removes a level of indentation,
which accounts for the size of the patch. The amount of code changed
is relatively small, and it isn't exactly a reversion of the
b963801164 commit.
This fixes Bugzilla #32432.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Tested-by: Matej Kenda <matejken@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-07-05 16:34:05 +00:00
|
|
|
t = EHCI_SHRINK_JIFFIES;
|
2009-02-11 19:26:38 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
mod_timer(&ehci->watchdog, t + jiffies);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* handshake - spin reading hc until handshake completes or fails
|
|
|
|
|
* @ptr: address of hc register to be read
|
|
|
|
|
* @mask: bits to look at in result of read
|
|
|
|
|
* @done: value of those bits when handshake succeeds
|
|
|
|
|
* @usec: timeout in microseconds
|
|
|
|
|
*
|
|
|
|
|
* Returns negative errno, or zero on success
|
|
|
|
|
*
|
|
|
|
|
* Success happens when the "mask" bits have the specified value (hardware
|
|
|
|
|
* handshake done). There are two failure modes: "usec" have passed (major
|
|
|
|
|
* hardware flakeout), or the register reads as all-ones (hardware removed).
|
|
|
|
|
*
|
|
|
|
|
* That last failure should_only happen in cases like physical cardbus eject
|
|
|
|
|
* before driver shutdown. But it also seems to be caused by bugs in cardbus
|
|
|
|
|
* bridge shutdown: shutting down the bridge before the devices using it.
|
|
|
|
|
*/
|
2006-12-14 19:54:08 +00:00
|
|
|
static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
|
|
|
|
|
u32 mask, u32 done, int usec)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
|
|
do {
|
2006-12-14 19:54:08 +00:00
|
|
|
result = ehci_readl(ehci, ptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (result == ~(u32)0) /* card removed */
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
result &= mask;
|
|
|
|
|
if (result == done)
|
|
|
|
|
return 0;
|
|
|
|
|
udelay (1);
|
|
|
|
|
usec--;
|
|
|
|
|
} while (usec > 0);
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 16:26:56 +00:00
|
|
|
/* check TDI/ARC silicon is in host mode */
|
|
|
|
|
static int tdi_in_host_mode (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
u32 __iomem *reg_ptr;
|
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
|
|
reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
|
|
|
|
|
tmp = ehci_readl(ehci, reg_ptr);
|
|
|
|
|
return (tmp & 3) == USBMODE_CM_HC;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* force HC to halt state from unknown (EHCI spec section 2.3) */
|
|
|
|
|
static int ehci_halt (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
2006-12-14 19:54:08 +00:00
|
|
|
u32 temp = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-27 17:19:39 +00:00
|
|
|
/* disable any irqs left enabled by previous code */
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
2005-09-27 17:19:39 +00:00
|
|
|
|
2010-09-06 16:26:56 +00:00
|
|
|
if (ehci_is_TDI(ehci) && tdi_in_host_mode(ehci) == 0) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((temp & STS_HALT) != 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-04-23 17:54:36 +00:00
|
|
|
/*
|
|
|
|
|
* This routine gets called during probe before ehci->command
|
|
|
|
|
* has been initialized, so we can't rely on its value.
|
|
|
|
|
*/
|
|
|
|
|
ehci->command &= ~CMD_RUN;
|
2006-12-14 19:54:08 +00:00
|
|
|
temp = ehci_readl(ehci, &ehci->regs->command);
|
2012-04-23 17:54:36 +00:00
|
|
|
temp &= ~(CMD_RUN | CMD_IAAD);
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, temp, &ehci->regs->command);
|
|
|
|
|
return handshake (ehci, &ehci->regs->status,
|
|
|
|
|
STS_HALT, STS_HALT, 16 * 125);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2011-12-01 00:40:57 +00:00
|
|
|
#if defined(CONFIG_USB_SUSPEND) && defined(CONFIG_PPC_PS3)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The EHCI controller of the Cell Super Companion Chip used in the
|
|
|
|
|
* PS3 will stop the root hub after all root hub ports are suspended.
|
|
|
|
|
* When in this condition handshake will return -ETIMEDOUT. The
|
|
|
|
|
* STS_HLT bit will not be set, so inspection of the frame index is
|
|
|
|
|
* used here to test for the condition. If the condition is found
|
|
|
|
|
* return success to allow the USB suspend to complete.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
|
|
|
|
|
void __iomem *ptr, u32 mask, u32 done,
|
|
|
|
|
int usec)
|
|
|
|
|
{
|
|
|
|
|
unsigned int old_index;
|
|
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
|
|
|
|
|
old_index = ehci_read_frame_index(ehci);
|
|
|
|
|
|
|
|
|
|
error = handshake(ehci, ptr, mask, done, usec);
|
|
|
|
|
|
|
|
|
|
if (error == -ETIMEDOUT && ehci_read_frame_index(ehci) == old_index)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
|
|
|
|
|
void __iomem *ptr, u32 mask, u32 done,
|
|
|
|
|
int usec)
|
|
|
|
|
{
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-08-26 21:43:46 +00:00
|
|
|
static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
|
|
|
|
|
u32 mask, u32 done, int usec)
|
|
|
|
|
{
|
|
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
error = handshake(ehci, ptr, mask, done, usec);
|
2011-12-01 00:40:57 +00:00
|
|
|
if (error == -ETIMEDOUT)
|
|
|
|
|
error = handshake_for_broken_root_hub(ehci, ptr, mask, done,
|
|
|
|
|
usec);
|
|
|
|
|
|
2008-08-26 21:43:46 +00:00
|
|
|
if (error) {
|
|
|
|
|
ehci_halt(ehci);
|
2011-08-18 20:31:30 +00:00
|
|
|
ehci->rh_state = EHCI_RH_HALTED;
|
2009-10-13 05:37:09 +00:00
|
|
|
ehci_err(ehci, "force halt; handshake %p %08x %08x -> %d\n",
|
2008-08-26 21:43:46 +00:00
|
|
|
ptr, mask, done, error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* put TDI/ARC silicon into EHCI mode */
|
|
|
|
|
static void tdi_reset (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
u32 __iomem *reg_ptr;
|
|
|
|
|
u32 tmp;
|
|
|
|
|
|
2007-05-23 16:07:48 +00:00
|
|
|
reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
|
2006-12-14 19:54:08 +00:00
|
|
|
tmp = ehci_readl(ehci, reg_ptr);
|
2007-05-23 16:07:48 +00:00
|
|
|
tmp |= USBMODE_CM_HC;
|
|
|
|
|
/* The default byte access to MMR space is LE after
|
|
|
|
|
* controller reset. Set the required endian mode
|
|
|
|
|
* for transfer buffers to match the host microprocessor
|
|
|
|
|
*/
|
|
|
|
|
if (ehci_big_endian_mmio(ehci))
|
|
|
|
|
tmp |= USBMODE_BE;
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, tmp, reg_ptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* reset a non-running (STS_HALT == 1) controller */
|
|
|
|
|
static int ehci_reset (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
int retval;
|
2006-12-14 19:54:08 +00:00
|
|
|
u32 command = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-08-20 20:39:54 +00:00
|
|
|
/* If the EHCI debug controller is active, special care must be
|
|
|
|
|
* taken before and after a host controller reset */
|
|
|
|
|
if (ehci->debug && !dbgp_reset_prep())
|
|
|
|
|
ehci->debug = NULL;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
command |= CMD_RESET;
|
|
|
|
|
dbg_cmd (ehci, "reset", command);
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, command, &ehci->regs->command);
|
2011-08-18 20:31:30 +00:00
|
|
|
ehci->rh_state = EHCI_RH_HALTED;
|
2005-04-16 22:20:36 +00:00
|
|
|
ehci->next_statechange = jiffies;
|
2006-12-14 19:54:08 +00:00
|
|
|
retval = handshake (ehci, &ehci->regs->command,
|
|
|
|
|
CMD_RESET, 0, 250 * 1000);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-13 04:41:20 +00:00
|
|
|
if (ehci->has_hostpc) {
|
|
|
|
|
ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
|
|
|
|
|
(u32 __iomem *)(((u8 *)ehci->regs) + USBMODE_EX));
|
|
|
|
|
ehci_writel(ehci, TXFIFO_DEFAULT,
|
|
|
|
|
(u32 __iomem *)(((u8 *)ehci->regs) + TXFILLTUNING));
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
if (ehci_is_TDI(ehci))
|
|
|
|
|
tdi_reset (ehci);
|
|
|
|
|
|
2009-08-20 20:39:54 +00:00
|
|
|
if (ehci->debug)
|
|
|
|
|
dbgp_external_startup();
|
|
|
|
|
|
2012-04-03 19:24:30 +00:00
|
|
|
ehci->port_c_suspend = ehci->suspended_ports =
|
|
|
|
|
ehci->resuming_ports = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* idle the controller (from running) */
|
|
|
|
|
static void ehci_quiesce (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2011-08-18 20:31:30 +00:00
|
|
|
if (ehci->rh_state != EHCI_RH_RUNNING)
|
2005-04-16 22:20:36 +00:00
|
|
|
BUG ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* wait for any schedule enables/disables to take effect */
|
2012-04-23 17:54:36 +00:00
|
|
|
temp = (ehci->command << 10) & (STS_ASS | STS_PSS);
|
2008-02-16 21:44:42 +00:00
|
|
|
if (handshake_on_error_set_halt(ehci, &ehci->regs->status,
|
|
|
|
|
STS_ASS | STS_PSS, temp, 16 * 125))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* then disable anything that's still active */
|
2012-04-23 17:54:36 +00:00
|
|
|
ehci->command &= ~(CMD_ASE | CMD_PSE);
|
|
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* hardware can take 16 microframes to turn off ... */
|
2008-02-16 21:44:42 +00:00
|
|
|
handshake_on_error_set_halt(ehci, &ehci->regs->status,
|
|
|
|
|
STS_ASS | STS_PSS, 0, 16 * 125);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
static void end_unlink_async(struct ehci_hcd *ehci);
|
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 void ehci_work(struct ehci_hcd *ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#include "ehci-hub.c"
|
2010-06-04 07:47:55 +00:00
|
|
|
#include "ehci-lpm.c"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ehci-mem.c"
|
|
|
|
|
#include "ehci-q.c"
|
|
|
|
|
#include "ehci-sched.c"
|
2011-07-03 16:36:56 +00:00
|
|
|
#include "ehci-sysfs.c"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
static void ehci_iaa_watchdog(unsigned long param)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = (struct ehci_hcd *) param;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
|
|
|
|
|
2008-03-07 21:49:42 +00:00
|
|
|
/* Lost IAA irqs wedge things badly; seen first with a vt8235.
|
|
|
|
|
* So we need this watchdog, but must protect it against both
|
|
|
|
|
* (a) SMP races against real IAA firing and retriggering, and
|
|
|
|
|
* (b) clean HC shutdown, when IAA watchdog was pending.
|
|
|
|
|
*/
|
|
|
|
|
if (ehci->reclaim
|
|
|
|
|
&& !timer_pending(&ehci->iaa_watchdog)
|
2011-08-18 20:31:30 +00:00
|
|
|
&& ehci->rh_state == EHCI_RH_RUNNING) {
|
2008-03-07 21:49:42 +00:00
|
|
|
u32 cmd, status;
|
|
|
|
|
|
|
|
|
|
/* If we get here, IAA is *REALLY* late. It's barely
|
|
|
|
|
* conceivable that the system is so busy that CMD_IAAD
|
|
|
|
|
* is still legitimately set, so let's be sure it's
|
|
|
|
|
* clear before we read STS_IAA. (The HC should clear
|
|
|
|
|
* CMD_IAAD when it sets STS_IAA.)
|
|
|
|
|
*/
|
|
|
|
|
cmd = ehci_readl(ehci, &ehci->regs->command);
|
|
|
|
|
|
|
|
|
|
/* If IAA is set here it either legitimately triggered
|
|
|
|
|
* before we cleared IAAD above (but _way_ late, so we'll
|
|
|
|
|
* still count it as lost) ... or a silicon erratum:
|
|
|
|
|
* - VIA seems to set IAA without triggering the IRQ;
|
|
|
|
|
* - IAAD potentially cleared without setting IAA.
|
|
|
|
|
*/
|
|
|
|
|
status = ehci_readl(ehci, &ehci->regs->status);
|
|
|
|
|
if ((status & STS_IAA) || !(cmd & CMD_IAAD)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
COUNT (ehci->stats.lost_iaa);
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, STS_IAA, &ehci->regs->status);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-03-07 21:49:42 +00:00
|
|
|
|
|
|
|
|
ehci_vdbg(ehci, "IAA watchdog: status %x cmd %x\n",
|
|
|
|
|
status, cmd);
|
2007-12-11 21:05:30 +00:00
|
|
|
end_unlink_async(ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
spin_unlock_irqrestore(&ehci->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void ehci_watchdog(unsigned long param)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = (struct ehci_hcd *) param;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ehci->lock, flags);
|
|
|
|
|
|
|
|
|
|
/* stop async processing after it's idled a bit */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
|
2006-09-19 00:03:16 +00:00
|
|
|
start_unlink_async (ehci, ehci->async);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* ehci could run by timer, without IRQs ... */
|
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
|
|
|
ehci_work (ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-13 19:55:27 +00:00
|
|
|
/* On some systems, leaving remote wakeup enabled prevents system shutdown.
|
|
|
|
|
* The firmware seems to think that powering off is a wakeup event!
|
|
|
|
|
* This routine turns off remote wakeup and everything else, on all ports.
|
|
|
|
|
*/
|
|
|
|
|
static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
int port = HCS_N_PORTS(ehci->hcs_params);
|
|
|
|
|
|
|
|
|
|
while (port--)
|
|
|
|
|
ehci_writel(ehci, PORT_RWC_BITS,
|
|
|
|
|
&ehci->regs->port_status[port]);
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-08 21:30:18 +00:00
|
|
|
/*
|
|
|
|
|
* Halt HC, turn off all ports, and let the BIOS use the companion controllers.
|
|
|
|
|
* Should be called with ehci->lock held.
|
2005-09-27 17:19:39 +00:00
|
|
|
*/
|
2008-04-08 21:30:18 +00:00
|
|
|
static void ehci_silence_controller(struct ehci_hcd *ehci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-08 21:30:18 +00:00
|
|
|
ehci_halt(ehci);
|
2007-02-13 19:55:27 +00:00
|
|
|
ehci_turn_off_all_ports(ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* make BIOS/etc use companion controller during reboot */
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2007-02-13 19:55:27 +00:00
|
|
|
|
|
|
|
|
/* unblock posted writes */
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->configured_flag);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2008-04-08 21:30:18 +00:00
|
|
|
/* ehci_shutdown kick in for silicon on any bus (not just pci, etc).
|
|
|
|
|
* This forcibly disables dma and IRQs, helping kexec and other cases
|
|
|
|
|
* where the next system software may expect clean state.
|
|
|
|
|
*/
|
|
|
|
|
static void ehci_shutdown(struct usb_hcd *hcd)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
|
|
|
|
|
del_timer_sync(&ehci->watchdog);
|
|
|
|
|
del_timer_sync(&ehci->iaa_watchdog);
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
|
ehci_silence_controller(ehci);
|
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-09 16:00:29 +00:00
|
|
|
static void ehci_port_power (struct ehci_hcd *ehci, int is_on)
|
|
|
|
|
{
|
|
|
|
|
unsigned port;
|
|
|
|
|
|
|
|
|
|
if (!HCS_PPC (ehci->hcs_params))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ehci_dbg (ehci, "...power%s ports...\n", is_on ? "up" : "down");
|
|
|
|
|
for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; )
|
|
|
|
|
(void) ehci_hub_control(ehci_to_hcd(ehci),
|
|
|
|
|
is_on ? SetPortFeature : ClearPortFeature,
|
|
|
|
|
USB_PORT_FEAT_POWER,
|
|
|
|
|
port--, NULL, 0);
|
2007-05-04 15:52:40 +00:00
|
|
|
/* Flush those writes */
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->command);
|
2005-04-09 16:00:29 +00:00
|
|
|
msleep(20);
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
/*
|
|
|
|
|
* ehci_work is called from some interrupts, timers, and so on.
|
|
|
|
|
* it calls driver completion functions, after dropping ehci->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
|
|
|
static void ehci_work (struct ehci_hcd *ehci)
|
2005-09-23 05:31:15 +00:00
|
|
|
{
|
|
|
|
|
timer_action_done (ehci, TIMER_IO_WATCHDOG);
|
|
|
|
|
|
|
|
|
|
/* another CPU may drop ehci->lock during a schedule scan while
|
|
|
|
|
* it reports urb completions. this flag guards against bogus
|
|
|
|
|
* attempts at re-entrant schedule scanning.
|
|
|
|
|
*/
|
|
|
|
|
if (ehci->scanning)
|
|
|
|
|
return;
|
|
|
|
|
ehci->scanning = 1;
|
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
|
|
|
scan_async (ehci);
|
2005-09-23 05:31:15 +00:00
|
|
|
if (ehci->next_uframe != -1)
|
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
|
|
|
scan_periodic (ehci);
|
2005-09-23 05:31:15 +00:00
|
|
|
ehci->scanning = 0;
|
|
|
|
|
|
|
|
|
|
/* the IO watchdog guards against hardware or driver bugs that
|
|
|
|
|
* misplace IRQs, and should let us run completely without IRQs.
|
|
|
|
|
* such lossage has been observed on both VT6202 and VT8235.
|
|
|
|
|
*/
|
2011-08-18 20:31:30 +00:00
|
|
|
if (ehci->rh_state == EHCI_RH_RUNNING &&
|
2005-09-23 05:31:15 +00:00
|
|
|
(ehci->async->qh_next.ptr != NULL ||
|
|
|
|
|
ehci->periodic_sched != 0))
|
|
|
|
|
timer_action (ehci, TIMER_IO_WATCHDOG);
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-08 21:30:18 +00:00
|
|
|
/*
|
|
|
|
|
* Called when the ehci_hcd module is removed.
|
|
|
|
|
*/
|
2005-09-23 05:31:15 +00:00
|
|
|
static void ehci_stop (struct usb_hcd *hcd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
ehci_dbg (ehci, "stop\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
/* no more interrupts ... */
|
|
|
|
|
del_timer_sync (&ehci->watchdog);
|
2007-12-11 21:05:30 +00:00
|
|
|
del_timer_sync(&ehci->iaa_watchdog);
|
2005-04-09 16:00:29 +00:00
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
spin_lock_irq(&ehci->lock);
|
2011-08-18 20:31:30 +00:00
|
|
|
if (ehci->rh_state == EHCI_RH_RUNNING)
|
2005-09-23 05:31:15 +00:00
|
|
|
ehci_quiesce (ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-08 21:30:18 +00:00
|
|
|
ehci_silence_controller(ehci);
|
2005-09-23 05:31:15 +00:00
|
|
|
ehci_reset (ehci);
|
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-07-03 16:36:56 +00:00
|
|
|
remove_sysfs_files(ehci);
|
2005-09-23 05:31:15 +00:00
|
|
|
remove_debug_files (ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
/* root hub is shut down separately (first, when possible) */
|
|
|
|
|
spin_lock_irq (&ehci->lock);
|
|
|
|
|
if (ehci->async)
|
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
|
|
|
ehci_work (ehci);
|
2005-09-23 05:31:15 +00:00
|
|
|
spin_unlock_irq (&ehci->lock);
|
|
|
|
|
ehci_mem_cleanup (ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-03-01 06:57:05 +00:00
|
|
|
if (ehci->amd_pll_fix == 1)
|
|
|
|
|
usb_amd_dev_put();
|
2010-12-07 02:10:08 +00:00
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
#ifdef EHCI_STATS
|
|
|
|
|
ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
|
|
|
|
|
ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
|
|
|
|
|
ehci->stats.lost_iaa);
|
|
|
|
|
ehci_dbg (ehci, "complete %ld unlink %ld\n",
|
|
|
|
|
ehci->stats.complete, ehci->stats.unlink);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
2006-12-14 19:54:08 +00:00
|
|
|
dbg_status (ehci, "ehci_stop completed",
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->status));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2005-11-23 23:45:37 +00:00
|
|
|
/* one-time init, only for memory state */
|
|
|
|
|
static int ehci_init(struct usb_hcd *hcd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-23 23:45:37 +00:00
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 temp;
|
|
|
|
|
int retval;
|
|
|
|
|
u32 hcc_params;
|
2009-07-13 23:23:29 +00:00
|
|
|
struct ehci_qh_hw *hw;
|
2005-11-23 23:45:37 +00:00
|
|
|
|
|
|
|
|
spin_lock_init(&ehci->lock);
|
|
|
|
|
|
2009-07-13 09:30:41 +00:00
|
|
|
/*
|
|
|
|
|
* keep io watchdog by default, those good HCDs could turn off it later
|
|
|
|
|
*/
|
|
|
|
|
ehci->need_io_watchdog = 1;
|
2005-11-23 23:45:37 +00:00
|
|
|
init_timer(&ehci->watchdog);
|
|
|
|
|
ehci->watchdog.function = ehci_watchdog;
|
|
|
|
|
ehci->watchdog.data = (unsigned long) ehci;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
init_timer(&ehci->iaa_watchdog);
|
|
|
|
|
ehci->iaa_watchdog.function = ehci_iaa_watchdog;
|
|
|
|
|
ehci->iaa_watchdog.data = (unsigned long) ehci;
|
|
|
|
|
|
2011-01-06 15:17:09 +00:00
|
|
|
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
|
|
|
|
|
|
USB: EHCI: Allow users to override 80% max periodic bandwidth
There are cases, when 80% max isochronous bandwidth is too limiting.
For example I have two USB video capture cards which stream uncompressed
video, and to stream full NTSC + PAL videos we'd need
NTSC 640x480 YUV422 @30fps ~17.6 MB/s
PAL 720x576 YUV422 @25fps ~19.7 MB/s
isoc bandwidth.
Now, due to limited alt settings in capture devices NTSC one ends up
streaming with max_pkt_size=2688 and PAL with max_pkt_size=2892, both
with interval=1. In terms of microframe time allocation this gives
NTSC ~53us
PAL ~57us
and together
~110us > 100us == 80% of 125us uframe time.
So those two devices can't work together simultaneously because the'd
over allocate isochronous bandwidth.
80% seemed a bit arbitrary to me, and I've tried to raise it to 90% and
both devices started to work together, so I though sometimes it would be
a good idea for users to override hardcoded default of max 80% isoc
bandwidth.
After all, isn't it a user who should decide how to load the bus? If I
can live with 10% or even 5% bulk bandwidth that should be ok. I'm a USB
newcomer, but that 80% set in stone by USB 2.0 specification seems to be
chosen pretty arbitrary to me, just to serve as a reasonable default.
NOTE 1
~~~~~~
for two streams with max_pkt_size=3072 (worst case) both time
allocation would be 60us+60us=120us which is 96% periodic bandwidth
leaving 4% for bulk and control. Alan Stern suggested that bulk then
would be problematic (less than 300*8 bittimes left per microframe), but
I think that is still enough for control traffic.
NOTE 2
~~~~~~
Sarah Sharp expressed concern that maxing out periodic bandwidth
could lead to vendor-specific hardware bugs on host controllers, because
> It's entirely possible that you'll run into
> vendor-specific bugs if you try to pack the schedule with isochronous
> transfers. I don't think any hardware designer would seriously test or
> validate their hardware with a schedule that is basically a violation of
> the USB bus spec (more than 80% for periodic transfers).
So far I've only tested this patch on my HP Mini 5103 with N10 chipset
kirr@mini:~$ lspci
00:00.0 Host bridge: Intel Corporation N10 Family DMI Bridge
00:02.0 VGA compatible controller: Intel Corporation N10 Family Integrated Graphics Controller
00:02.1 Display controller: Intel Corporation N10 Family Integrated Graphics Controller
00:1b.0 Audio device: Intel Corporation N10/ICH 7 Family High Definition Audio Controller (rev 02)
00:1c.0 PCI bridge: Intel Corporation N10/ICH 7 Family PCI Express Port 1 (rev 02)
00:1c.3 PCI bridge: Intel Corporation N10/ICH 7 Family PCI Express Port 4 (rev 02)
00:1d.0 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #1 (rev 02)
00:1d.1 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #2 (rev 02)
00:1d.2 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #3 (rev 02)
00:1d.3 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #4 (rev 02)
00:1d.7 USB Controller: Intel Corporation N10/ICH 7 Family USB2 EHCI Controller (rev 02)
00:1e.0 PCI bridge: Intel Corporation 82801 Mobile PCI Bridge (rev e2)
00:1f.0 ISA bridge: Intel Corporation NM10 Family LPC Controller (rev 02)
00:1f.2 SATA controller: Intel Corporation N10/ICH7 Family SATA AHCI Controller (rev 02)
01:00.0 Network controller: Broadcom Corporation BCM4313 802.11b/g/n Wireless LAN Controller (rev 01)
02:00.0 Ethernet controller: Marvell Technology Group Ltd. 88E8059 PCI-E Gigabit Ethernet Controller (rev 11)
and the system works stable with 110us/uframe (~88%) isoc bandwith allocated for
above-mentioned isochronous transfers.
NOTE 3
~~~~~~
This feature is off by default. I mean max periodic bandwidth is set to
100us/uframe by default exactly as it was before the patch. So only those of us
who need the extreme settings are taking the risk - normal users who do not
alter uframe_periodic_max sysfs attribute should not see any change at all.
NOTE 4
~~~~~~
I've tried to update documentation in Documentation/ABI/ thoroughly, but
only "TBD" was put into Documentation/usb/ehci.txt -- the text there seems
to be outdated and much needing refreshing, before it could be amended.
Cc: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-07-03 16:36:57 +00:00
|
|
|
/*
|
|
|
|
|
* by default set standard 80% (== 100 usec/uframe) max periodic
|
|
|
|
|
* bandwidth as required by USB 2.0
|
|
|
|
|
*/
|
|
|
|
|
ehci->uframe_periodic_max = 100;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* hw default: 1K periodic list heads, one per frame.
|
|
|
|
|
* periodic_size can shrink by USBCMD update if hcc_params allows.
|
|
|
|
|
*/
|
|
|
|
|
ehci->periodic_size = DEFAULT_I_TDPS;
|
2009-02-09 00:07:58 +00:00
|
|
|
INIT_LIST_HEAD(&ehci->cached_itd_list);
|
2010-04-08 20:56:37 +00:00
|
|
|
INIT_LIST_HEAD(&ehci->cached_sitd_list);
|
2011-01-06 15:17:09 +00:00
|
|
|
|
2012-05-21 15:54:43 +00:00
|
|
|
if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
|
2011-01-06 15:17:09 +00:00
|
|
|
/* periodic schedule size can be smaller than default */
|
|
|
|
|
switch (EHCI_TUNE_FLS) {
|
|
|
|
|
case 0: ehci->periodic_size = 1024; break;
|
|
|
|
|
case 1: ehci->periodic_size = 512; break;
|
|
|
|
|
case 2: ehci->periodic_size = 256; break;
|
|
|
|
|
default: BUG();
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-11-23 23:45:37 +00:00
|
|
|
if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
/* controllers may cache some of the periodic schedule ... */
|
2006-08-30 21:50:06 +00:00
|
|
|
if (HCC_ISOC_CACHE(hcc_params)) // full frame cache
|
USB: ehci: Respect IST when scheduling new split iTDs.
The EHCI specification says that an EHCI host controller may cache part of
the isochronous schedule. The EHCI controller must advertise how much it
caches in the schedule through the HCCPARAMS register isochronous
scheduling threshold (IST) bits.
In theory, adding new iTDs within the IST should be harmless. The HW will
follow the old cached linked list and miss the new iTD. SW will notice HW
missed the iTD and return 0 for the transfer length.
However, Intel ICH9 chipsets (and some later chipsets) have issues when SW
attempts to schedule a split transaction within the IST. All transfers
will cease being sent out that port, and the drivers will see isochronous
packets complete with a length of zero. Start of frames may or may not
also disappear, causing the device to go into auto-suspend. This "bus
stall" will continue until a control or bulk transfer is queued to a
device under that roothub.
Most drivers will never cause this behavior, because they use multiple
URBs with multiple packets to keep the bus busy. If you limit the number
of URBs to one, you may be able to hit this bug.
Make sure the EHCI driver does not schedule full-speed transfers within
the IST under an Intel chipset. Make sure that when we fall behind the
current microframe plus IST, we schedule the new transfer at the next
periodic interval after the IST.
Don't change the scheduling for new transfers, since the schedule slop will
always be greater than the IST. Allow high speed isochronous transfers to
be scheduled within the IST, since this doesn't trigger the Intel chipset
bug.
Make sure that if the host caches the full frame, the EHCI driver's
internal isochronous threshold (ehci->i_thresh) is set to
8 microframes + 2 microframes wiggle room. This is similar to what is done in
the case where the host caches less than the full frame.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Cc: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-10-27 17:55:05 +00:00
|
|
|
ehci->i_thresh = 2 + 8;
|
2005-04-16 22:20:36 +00:00
|
|
|
else // N microframes cached
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
ehci->reclaim = NULL;
|
|
|
|
|
ehci->next_uframe = -1;
|
2009-02-09 00:07:58 +00:00
|
|
|
ehci->clock_frame = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* dedicate a qh for the async ring head, since we couldn't unlink
|
|
|
|
|
* a 'real' qh without stopping the async schedule [4.8]. use it
|
|
|
|
|
* as the 'reclamation list head' too.
|
|
|
|
|
* its dummy is used in hw_alt_next of many tds, to prevent the qh
|
|
|
|
|
* from automatically advancing to the next td after short reads.
|
|
|
|
|
*/
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci->async->qh_next.qh = NULL;
|
2009-07-13 23:23:29 +00:00
|
|
|
hw = ehci->async->hw;
|
|
|
|
|
hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
|
|
|
|
|
hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
|
2011-11-09 00:01:18 +00:00
|
|
|
hw->hw_info1 |= cpu_to_hc32(ehci, (1 << 7)); /* I = 1 */
|
2009-07-13 23:23:29 +00:00
|
|
|
hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
|
|
|
|
|
hw->hw_qtd_next = EHCI_LIST_END(ehci);
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci->async->qh_state = QH_STATE_LINKED;
|
2009-07-13 23:23:29 +00:00
|
|
|
hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* clear interrupt enables, set irq latency */
|
|
|
|
|
if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
|
|
|
|
|
log2_irq_thresh = 0;
|
|
|
|
|
temp = 1 << (16 + log2_irq_thresh);
|
2010-06-04 07:47:56 +00:00
|
|
|
if (HCC_PER_PORT_CHANGE_EVENT(hcc_params)) {
|
|
|
|
|
ehci->has_ppcd = 1;
|
|
|
|
|
ehci_dbg(ehci, "enable per-port change event\n");
|
|
|
|
|
temp |= CMD_PPCEE;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (HCC_CANPARK(hcc_params)) {
|
|
|
|
|
/* HW default park == 3, on hardware that supports it (like
|
|
|
|
|
* NVidia and ALI silicon), maximizes throughput on the async
|
|
|
|
|
* schedule by avoiding QH fetches between transfers.
|
|
|
|
|
*
|
|
|
|
|
* With fast usb storage devices and NForce2, "park" seems to
|
|
|
|
|
* make problems: throughput reduction (!), data errors...
|
|
|
|
|
*/
|
|
|
|
|
if (park) {
|
2005-11-23 23:45:37 +00:00
|
|
|
park = min(park, (unsigned) 3);
|
2005-04-16 22:20:36 +00:00
|
|
|
temp |= CMD_PARK;
|
|
|
|
|
temp |= park << 8;
|
|
|
|
|
}
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci_dbg(ehci, "park %d\n", park);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-11-23 23:45:37 +00:00
|
|
|
if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* periodic schedule size can be smaller than default */
|
|
|
|
|
temp &= ~(3 << 2);
|
|
|
|
|
temp |= (EHCI_TUNE_FLS << 2);
|
|
|
|
|
}
|
2010-06-04 07:47:55 +00:00
|
|
|
if (HCC_LPM(hcc_params)) {
|
|
|
|
|
/* support link power management EHCI 1.1 addendum */
|
|
|
|
|
ehci_dbg(ehci, "support lpm\n");
|
|
|
|
|
ehci->has_lpm = 1;
|
|
|
|
|
if (hird > 0xf) {
|
|
|
|
|
ehci_dbg(ehci, "hird %d invalid, use default 0",
|
|
|
|
|
hird);
|
|
|
|
|
hird = 0;
|
|
|
|
|
}
|
|
|
|
|
temp |= hird << 24;
|
|
|
|
|
}
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci->command = temp;
|
|
|
|
|
|
2009-11-06 17:29:40 +00:00
|
|
|
/* Accept arbitrarily long scatter-gather lists */
|
2010-06-28 14:56:45 +00:00
|
|
|
if (!(hcd->driver->flags & HCD_LOCAL_MEM))
|
|
|
|
|
hcd->self.sg_tablesize = ~0;
|
2005-11-23 23:45:37 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* start HC running; it's halted, ehci_init() has been run (once) */
|
|
|
|
|
static int ehci_run (struct usb_hcd *hcd)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
u32 temp;
|
|
|
|
|
u32 hcc_params;
|
|
|
|
|
|
2007-01-21 21:45:59 +00:00
|
|
|
hcd->uses_new_polling = 1;
|
|
|
|
|
|
2005-11-23 23:45:37 +00:00
|
|
|
/* EHCI spec section 4.1 */
|
2011-11-23 02:04:45 +00:00
|
|
|
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
|
|
|
|
|
ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
|
2005-11-23 23:45:37 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* hcc_params controls whether ehci->regs->segment must (!!!)
|
|
|
|
|
* be used; it constrains QH/ITD/SITD and QTD locations.
|
|
|
|
|
* pci_pool consistent memory always uses segment zero.
|
|
|
|
|
* streaming mappings for I/O buffers, like pci_map_single(),
|
|
|
|
|
* can return segments above 4GB, if the device allows.
|
|
|
|
|
*
|
|
|
|
|
* NOTE: the dma mask is visible through dma_supported(), so
|
|
|
|
|
* drivers can pass this info along ... like NETIF_F_HIGHDMA,
|
|
|
|
|
* Scsi_Host.highmem_io, and so forth. It's readonly to all
|
|
|
|
|
* host side drivers though.
|
|
|
|
|
*/
|
2006-12-14 19:54:08 +00:00
|
|
|
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
|
2005-11-23 23:45:37 +00:00
|
|
|
if (HCC_64BIT_ADDR(hcc_params)) {
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->segment);
|
2005-11-23 23:45:37 +00:00
|
|
|
#if 0
|
|
|
|
|
// this is deeply broken on almost all architectures
|
2009-04-07 02:01:13 +00:00
|
|
|
if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci_info(ehci, "enabled 64bit DMA\n");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
// Philips, Intel, and maybe others need CMD_RUN before the
|
|
|
|
|
// root hub will detect new devices (why?); NEC doesn't
|
2005-11-23 23:45:37 +00:00
|
|
|
ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
|
|
|
|
|
ehci->command |= CMD_RUN;
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
2005-11-23 23:45:37 +00:00
|
|
|
dbg_cmd (ehci, "init", ehci->command);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Start, enabling full USB 2.0 functionality ... usb 1.1 devices
|
|
|
|
|
* are explicitly handed to companion controller(s), so no TT is
|
|
|
|
|
* involved with the root hub. (Except where one is integrated,
|
|
|
|
|
* and there's no companion controller unless maybe for USB OTG.)
|
2007-10-10 20:27:07 +00:00
|
|
|
*
|
|
|
|
|
* Turning on the CF flag will transfer ownership of all ports
|
|
|
|
|
* from the companions to the EHCI controller. If any of the
|
|
|
|
|
* companions are in the middle of a port reset at the time, it
|
|
|
|
|
* could cause trouble. Write-locking ehci_cf_port_reset_rwsem
|
2007-11-14 00:22:30 +00:00
|
|
|
* guarantees that no resets are in progress. After we set CF,
|
|
|
|
|
* a short delay lets the hardware catch up; new resets shouldn't
|
|
|
|
|
* be started before the port switching actions could complete.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-10-10 20:27:07 +00:00
|
|
|
down_write(&ehci_cf_port_reset_rwsem);
|
2011-08-18 20:31:30 +00:00
|
|
|
ehci->rh_state = EHCI_RH_RUNNING;
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
|
2007-11-14 00:22:30 +00:00
|
|
|
msleep(5);
|
2007-10-10 20:27:07 +00:00
|
|
|
up_write(&ehci_cf_port_reset_rwsem);
|
2009-11-27 14:17:59 +00:00
|
|
|
ehci->last_periodic_enable = ktime_get_real();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-03 18:11:57 +00:00
|
|
|
temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
|
2005-04-16 22:20:36 +00:00
|
|
|
ehci_info (ehci,
|
2008-10-02 15:47:15 +00:00
|
|
|
"USB %x.%x started, EHCI %x.%02x%s\n",
|
2005-09-23 05:31:15 +00:00
|
|
|
((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
|
2008-10-02 15:47:15 +00:00
|
|
|
temp >> 8, temp & 0xff,
|
2006-11-17 07:34:58 +00:00
|
|
|
ignore_oc ? ", overcurrent ignored" : "");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_writel(ehci, INTR_MASK,
|
|
|
|
|
&ehci->regs->intr_enable); /* Turn On Interrupts */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-23 23:45:37 +00:00
|
|
|
/* GRR this is run-once init(), being done every time the HC starts.
|
|
|
|
|
* So long as they're part of class devices, we can't do it init()
|
|
|
|
|
* since the class device isn't created that early.
|
|
|
|
|
*/
|
|
|
|
|
create_debug_files(ehci);
|
2011-07-03 16:36:56 +00:00
|
|
|
create_sysfs_files(ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-02 17:47:33 +00:00
|
|
|
static int __maybe_unused ehci_setup (struct usb_hcd *hcd)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
ehci->regs = (void __iomem *)ehci->caps +
|
|
|
|
|
HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
|
|
|
|
|
dbg_hcs_params(ehci, "reset");
|
|
|
|
|
dbg_hcc_params(ehci, "reset");
|
|
|
|
|
|
|
|
|
|
/* cache this readonly data; minimize chip reads */
|
|
|
|
|
ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
|
|
|
|
|
|
|
|
|
|
ehci->sbrn = HCD_USB2;
|
|
|
|
|
|
|
|
|
|
retval = ehci_halt(ehci);
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
/* data structure init */
|
|
|
|
|
retval = ehci_init(hcd);
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
ehci_reset(ehci);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
static irqreturn_t ehci_irq (struct usb_hcd *hcd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2008-11-12 22:04:53 +00:00
|
|
|
u32 status, masked_status, pcd_status = 0, cmd;
|
2005-04-16 22:20:36 +00:00
|
|
|
int bh;
|
|
|
|
|
|
|
|
|
|
spin_lock (&ehci->lock);
|
|
|
|
|
|
2006-12-14 19:54:08 +00:00
|
|
|
status = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* e.g. cardbus physical eject */
|
|
|
|
|
if (status == ~(u32) 0) {
|
|
|
|
|
ehci_dbg (ehci, "device removed\n");
|
|
|
|
|
goto dead;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-18 15:33:00 +00:00
|
|
|
/*
|
|
|
|
|
* We don't use STS_FLR, but some controllers don't like it to
|
|
|
|
|
* remain on, so mask it out along with the other status bits.
|
|
|
|
|
*/
|
|
|
|
|
masked_status = status & (INTR_MASK | STS_FLR);
|
|
|
|
|
|
2011-05-17 21:27:12 +00:00
|
|
|
/* Shared IRQ? */
|
2011-08-18 20:31:30 +00:00
|
|
|
if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock(&ehci->lock);
|
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* clear (just) interrupts */
|
2008-11-12 22:04:53 +00:00
|
|
|
ehci_writel(ehci, masked_status, &ehci->regs->status);
|
2008-03-07 21:49:42 +00:00
|
|
|
cmd = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-16 22:20:36 +00:00
|
|
|
bh = 0;
|
|
|
|
|
|
2008-02-01 19:42:05 +00:00
|
|
|
#ifdef VERBOSE_DEBUG
|
2005-04-16 22:20:36 +00:00
|
|
|
/* unrequested/ignored: Frame List Rollover */
|
|
|
|
|
dbg_status (ehci, "irq", status);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* INT, ERR, and IAA interrupt rates can be throttled */
|
|
|
|
|
|
|
|
|
|
/* normal [4.15.1.2] or error [4.15.1.1] completion */
|
|
|
|
|
if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
|
|
|
|
|
if (likely ((status & STS_ERR) == 0))
|
|
|
|
|
COUNT (ehci->stats.normal);
|
|
|
|
|
else
|
|
|
|
|
COUNT (ehci->stats.error);
|
|
|
|
|
bh = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* complete the unlinking of some qh [4.15.2.3] */
|
|
|
|
|
if (status & STS_IAA) {
|
2008-03-07 21:49:42 +00:00
|
|
|
/* guard against (alleged) silicon errata */
|
2012-04-17 19:23:25 +00:00
|
|
|
if (cmd & CMD_IAAD)
|
2008-03-07 21:49:42 +00:00
|
|
|
ehci_dbg(ehci, "IAA with IAAD still set?\n");
|
|
|
|
|
if (ehci->reclaim) {
|
|
|
|
|
COUNT(ehci->stats.reclaim);
|
|
|
|
|
end_unlink_async(ehci);
|
|
|
|
|
} else
|
|
|
|
|
ehci_dbg(ehci, "IAA with nothing to reclaim?\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* remote wakeup [4.3.1] */
|
2005-12-23 01:05:18 +00:00
|
|
|
if (status & STS_PCD) {
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned i = HCS_N_PORTS (ehci->hcs_params);
|
2010-06-04 07:47:56 +00:00
|
|
|
u32 ppcd = 0;
|
2008-03-06 07:37:52 +00:00
|
|
|
|
|
|
|
|
/* kick root hub later */
|
2007-01-21 21:45:59 +00:00
|
|
|
pcd_status = status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* resume root hub? */
|
2012-04-17 19:24:15 +00:00
|
|
|
if (ehci->rh_state == EHCI_RH_SUSPENDED)
|
2006-11-09 19:42:16 +00:00
|
|
|
usb_hcd_resume_root_hub(hcd);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-04 07:47:56 +00:00
|
|
|
/* get per-port change detect bits */
|
|
|
|
|
if (ehci->has_ppcd)
|
|
|
|
|
ppcd = status >> 16;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
while (i--) {
|
2010-06-04 07:47:56 +00:00
|
|
|
int pstatus;
|
|
|
|
|
|
|
|
|
|
/* leverage per-port change bits feature */
|
|
|
|
|
if (ehci->has_ppcd && !(ppcd & (1 << i)))
|
|
|
|
|
continue;
|
|
|
|
|
pstatus = ehci_readl(ehci,
|
|
|
|
|
&ehci->regs->port_status[i]);
|
2006-06-30 09:34:42 +00:00
|
|
|
|
|
|
|
|
if (pstatus & PORT_OWNER)
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
2008-10-06 15:25:53 +00:00
|
|
|
if (!(test_bit(i, &ehci->suspended_ports) &&
|
|
|
|
|
((pstatus & PORT_RESUME) ||
|
|
|
|
|
!(pstatus & PORT_SUSPEND)) &&
|
|
|
|
|
(pstatus & PORT_PE) &&
|
|
|
|
|
ehci->reset_done[i] == 0))
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* start 20 msec resume signaling from this port,
|
|
|
|
|
* and make khubd collect PORT_STAT_C_SUSPEND to
|
2010-01-08 16:18:38 +00:00
|
|
|
* stop that signaling. Use 5 ms extra for safety,
|
|
|
|
|
* like usb_port_resume() does.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-01-08 16:18:38 +00:00
|
|
|
ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
|
2012-04-03 19:24:30 +00:00
|
|
|
set_bit(i, &ehci->resuming_ports);
|
2005-04-16 22:20:36 +00:00
|
|
|
ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
|
2007-04-09 15:52:31 +00:00
|
|
|
mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* PCI errors [4.15.2.4] */
|
|
|
|
|
if (unlikely ((status & STS_FATAL) != 0)) {
|
2008-11-12 22:04:53 +00:00
|
|
|
ehci_err(ehci, "fatal error\n");
|
2008-10-06 15:25:53 +00:00
|
|
|
dbg_cmd(ehci, "fatal", cmd);
|
|
|
|
|
dbg_status(ehci, "fatal", status);
|
2008-11-12 22:04:53 +00:00
|
|
|
ehci_halt(ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
dead:
|
2008-11-12 22:04:53 +00:00
|
|
|
ehci_reset(ehci);
|
|
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2011-05-17 21:27:12 +00:00
|
|
|
usb_hc_died(hcd);
|
2008-11-12 22:04:53 +00:00
|
|
|
/* generic layer kills/unlinks all urbs, then
|
|
|
|
|
* uses ehci_stop to clean up the rest
|
|
|
|
|
*/
|
|
|
|
|
bh = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bh)
|
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
|
|
|
ehci_work (ehci);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock (&ehci->lock);
|
2008-03-06 07:37:52 +00:00
|
|
|
if (pcd_status)
|
2007-01-21 21:45:59 +00:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* non-error returns are a promise to giveback() the urb later
|
|
|
|
|
* we drop ownership so next owner (or urb unlink) can get it
|
|
|
|
|
*
|
|
|
|
|
* urb + dev is in hcd.self.controller.urb_list
|
|
|
|
|
* we're queueing TDs onto software and hardware lists
|
|
|
|
|
*
|
|
|
|
|
* hcd-specific init for hcpriv hasn't been done yet
|
|
|
|
|
*
|
|
|
|
|
* NOTE: control, bulk, and interrupt share the same code to append TDs
|
|
|
|
|
* to a (possibly active) QH, and the same QH scanning code.
|
|
|
|
|
*/
|
|
|
|
|
static int ehci_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 ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
struct list_head qtd_list;
|
|
|
|
|
|
|
|
|
|
INIT_LIST_HEAD (&qtd_list);
|
|
|
|
|
|
|
|
|
|
switch (usb_pipetype (urb->pipe)) {
|
2008-03-04 23:11:07 +00:00
|
|
|
case PIPE_CONTROL:
|
|
|
|
|
/* qh_completions() code doesn't handle all the fault cases
|
|
|
|
|
* in multi-TD control transfers. Even 1KB is rare anyway.
|
|
|
|
|
*/
|
|
|
|
|
if (urb->transfer_buffer_length > (16 * 1024))
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
/* case PIPE_BULK: */
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
|
return -ENOMEM;
|
2007-08-08 15:48:02 +00:00
|
|
|
return submit_async(ehci, urb, &qtd_list, mem_flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
|
return -ENOMEM;
|
2007-08-08 15:48:02 +00:00
|
|
|
return intr_submit(ehci, urb, &qtd_list, mem_flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
case PIPE_ISOCHRONOUS:
|
|
|
|
|
if (urb->dev->speed == USB_SPEED_HIGH)
|
|
|
|
|
return itd_submit (ehci, urb, mem_flags);
|
|
|
|
|
else
|
|
|
|
|
return sitd_submit (ehci, urb, mem_flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
|
|
|
|
|
{
|
2007-12-11 21:05:30 +00:00
|
|
|
/* failfast */
|
2011-08-18 20:31:30 +00:00
|
|
|
if (ehci->rh_state != EHCI_RH_RUNNING && ehci->reclaim)
|
2007-12-11 21:05:30 +00:00
|
|
|
end_unlink_async(ehci);
|
|
|
|
|
|
2009-08-19 16:22:06 +00:00
|
|
|
/* If the QH isn't linked then there's nothing we can do
|
|
|
|
|
* unless we were called during a giveback, in which case
|
|
|
|
|
* qh_completions() has to deal with it.
|
|
|
|
|
*/
|
|
|
|
|
if (qh->qh_state != QH_STATE_LINKED) {
|
|
|
|
|
if (qh->qh_state == QH_STATE_COMPLETING)
|
|
|
|
|
qh->needs_rescan = 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2007-12-11 21:05:30 +00:00
|
|
|
|
|
|
|
|
/* defer till later if busy */
|
2009-08-19 16:22:06 +00:00
|
|
|
if (ehci->reclaim) {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ehci_qh *last;
|
|
|
|
|
|
|
|
|
|
for (last = ehci->reclaim;
|
|
|
|
|
last->reclaim;
|
|
|
|
|
last = last->reclaim)
|
|
|
|
|
continue;
|
|
|
|
|
qh->qh_state = QH_STATE_UNLINK_WAIT;
|
|
|
|
|
last->reclaim = qh;
|
|
|
|
|
|
2007-12-11 21:05:30 +00:00
|
|
|
/* start IAA cycle */
|
|
|
|
|
} else
|
2005-04-16 22:20:36 +00:00
|
|
|
start_unlink_async (ehci, qh);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* remove from hardware lists
|
|
|
|
|
* completions normally happen asynchronously
|
|
|
|
|
*/
|
|
|
|
|
|
2007-08-08 15:48:02 +00:00
|
|
|
static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
struct ehci_qh *qh;
|
|
|
|
|
unsigned long flags;
|
2007-08-08 15:48:02 +00:00
|
|
|
int rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
2007-08-08 15:48:02 +00:00
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto done;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (usb_pipetype (urb->pipe)) {
|
|
|
|
|
// case PIPE_CONTROL:
|
|
|
|
|
// case PIPE_BULK:
|
|
|
|
|
default:
|
|
|
|
|
qh = (struct ehci_qh *) urb->hcpriv;
|
|
|
|
|
if (!qh)
|
|
|
|
|
break;
|
2007-12-11 21:05:30 +00:00
|
|
|
switch (qh->qh_state) {
|
|
|
|
|
case QH_STATE_LINKED:
|
|
|
|
|
case QH_STATE_COMPLETING:
|
|
|
|
|
unlink_async(ehci, qh);
|
|
|
|
|
break;
|
|
|
|
|
case QH_STATE_UNLINK:
|
|
|
|
|
case QH_STATE_UNLINK_WAIT:
|
|
|
|
|
/* already started */
|
|
|
|
|
break;
|
|
|
|
|
case QH_STATE_IDLE:
|
2009-07-31 14:40:22 +00:00
|
|
|
/* QH might be waiting for a Clear-TT-Buffer */
|
|
|
|
|
qh_completions(ehci, qh);
|
2007-12-11 21:05:30 +00:00
|
|
|
break;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
|
qh = (struct ehci_qh *) urb->hcpriv;
|
|
|
|
|
if (!qh)
|
|
|
|
|
break;
|
|
|
|
|
switch (qh->qh_state) {
|
|
|
|
|
case QH_STATE_LINKED:
|
2009-08-19 16:22:44 +00:00
|
|
|
case QH_STATE_COMPLETING:
|
2005-04-16 22:20:36 +00:00
|
|
|
intr_deschedule (ehci, qh);
|
2009-08-19 16:22:44 +00:00
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case QH_STATE_IDLE:
|
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
|
|
|
qh_completions (ehci, qh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ehci_dbg (ehci, "bogus qh %p state %d\n",
|
|
|
|
|
qh, qh->qh_state);
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PIPE_ISOCHRONOUS:
|
|
|
|
|
// itd or sitd ...
|
|
|
|
|
|
|
|
|
|
// wait till next completion, do it then.
|
|
|
|
|
// completion irqs can wait up to 1024 msec,
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
done:
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
2007-08-08 15:48:02 +00:00
|
|
|
return rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
// bulk qh holds the data toggle
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
ehci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
struct ehci_qh *qh, *tmp;
|
|
|
|
|
|
|
|
|
|
/* ASSERT: any requests/urbs are being unlinked */
|
|
|
|
|
/* ASSERT: nobody can be submitting urbs for this any more */
|
|
|
|
|
|
|
|
|
|
rescan:
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
|
|
|
|
qh = ep->hcpriv;
|
|
|
|
|
if (!qh)
|
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
|
|
/* endpoints can be iso streams. for now, we don't
|
|
|
|
|
* accelerate iso completions ... so spin a while.
|
|
|
|
|
*/
|
2010-03-01 16:18:56 +00:00
|
|
|
if (qh->hw == NULL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
ehci_vdbg (ehci, "iso delay\n");
|
|
|
|
|
goto idle_timeout;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-18 20:31:30 +00:00
|
|
|
if (ehci->rh_state != EHCI_RH_RUNNING)
|
2005-04-16 22:20:36 +00:00
|
|
|
qh->qh_state = QH_STATE_IDLE;
|
|
|
|
|
switch (qh->qh_state) {
|
|
|
|
|
case QH_STATE_LINKED:
|
2009-08-19 16:22:06 +00:00
|
|
|
case QH_STATE_COMPLETING:
|
2005-04-16 22:20:36 +00:00
|
|
|
for (tmp = ehci->async->qh_next.qh;
|
|
|
|
|
tmp && tmp != qh;
|
|
|
|
|
tmp = tmp->qh_next.qh)
|
|
|
|
|
continue;
|
2010-11-16 15:57:37 +00:00
|
|
|
/* periodic qh self-unlinks on empty, and a COMPLETING qh
|
|
|
|
|
* may already be unlinked.
|
|
|
|
|
*/
|
|
|
|
|
if (tmp)
|
|
|
|
|
unlink_async(ehci, qh);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* FALL THROUGH */
|
|
|
|
|
case QH_STATE_UNLINK: /* wait for hw to finish? */
|
2007-12-11 21:05:30 +00:00
|
|
|
case QH_STATE_UNLINK_WAIT:
|
2005-04-16 22:20:36 +00:00
|
|
|
idle_timeout:
|
|
|
|
|
spin_unlock_irqrestore (&ehci->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 QH_STATE_IDLE: /* fully unlinked */
|
2009-06-29 14:47:30 +00:00
|
|
|
if (qh->clearing_tt)
|
|
|
|
|
goto idle_timeout;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (list_empty (&qh->qtd_list)) {
|
|
|
|
|
qh_put (qh);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* else FALL THROUGH */
|
|
|
|
|
default:
|
|
|
|
|
/* caller was supposed to have unlinked any requests;
|
|
|
|
|
* that's not our job. just leak this memory.
|
|
|
|
|
*/
|
|
|
|
|
ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
|
|
|
|
|
qh, ep->desc.bEndpointAddress, qh->qh_state,
|
|
|
|
|
list_empty (&qh->qtd_list) ? "" : "(has tds)");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
ep->hcpriv = NULL;
|
|
|
|
|
done:
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-27 22:21:56 +00:00
|
|
|
static void
|
|
|
|
|
ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
struct ehci_qh *qh;
|
|
|
|
|
int eptype = usb_endpoint_type(&ep->desc);
|
2009-06-11 18:56:22 +00:00
|
|
|
int epnum = usb_endpoint_num(&ep->desc);
|
|
|
|
|
int is_out = usb_endpoint_dir_out(&ep->desc);
|
|
|
|
|
unsigned long flags;
|
2009-05-27 22:21:56 +00:00
|
|
|
|
|
|
|
|
if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT)
|
|
|
|
|
return;
|
|
|
|
|
|
2009-06-11 18:56:22 +00:00
|
|
|
spin_lock_irqsave(&ehci->lock, flags);
|
2009-05-27 22:21:56 +00:00
|
|
|
qh = ep->hcpriv;
|
|
|
|
|
|
|
|
|
|
/* For Bulk and Interrupt endpoints we maintain the toggle state
|
|
|
|
|
* in the hardware; the toggle bits in udev aren't used at all.
|
|
|
|
|
* When an endpoint is reset by usb_clear_halt() we must reset
|
|
|
|
|
* the toggle bit in the QH.
|
|
|
|
|
*/
|
|
|
|
|
if (qh) {
|
2009-06-11 18:56:22 +00:00
|
|
|
usb_settoggle(qh->dev, epnum, is_out, 0);
|
2009-05-27 22:21:56 +00:00
|
|
|
if (!list_empty(&qh->qtd_list)) {
|
|
|
|
|
WARN_ONCE(1, "clear_halt for a busy endpoint\n");
|
2009-08-19 16:22:06 +00:00
|
|
|
} else if (qh->qh_state == QH_STATE_LINKED ||
|
|
|
|
|
qh->qh_state == QH_STATE_COMPLETING) {
|
2009-06-11 18:56:22 +00:00
|
|
|
|
|
|
|
|
/* The toggle value in the QH can't be updated
|
|
|
|
|
* while the QH is active. Unlink it now;
|
|
|
|
|
* re-linking will call qh_refresh().
|
2009-05-27 22:21:56 +00:00
|
|
|
*/
|
2009-08-19 16:22:44 +00:00
|
|
|
if (eptype == USB_ENDPOINT_XFER_BULK)
|
2009-06-11 18:56:22 +00:00
|
|
|
unlink_async(ehci, qh);
|
2009-08-19 16:22:44 +00:00
|
|
|
else
|
2009-06-11 18:56:22 +00:00
|
|
|
intr_deschedule(ehci, qh);
|
2009-05-27 22:21:56 +00:00
|
|
|
}
|
|
|
|
|
}
|
2009-06-11 18:56:22 +00:00
|
|
|
spin_unlock_irqrestore(&ehci->lock, flags);
|
2009-05-27 22:21:56 +00:00
|
|
|
}
|
|
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
static int ehci_get_frame (struct usb_hcd *hcd)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2011-10-12 14:39:14 +00:00
|
|
|
return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
|
2005-09-23 05:31:15 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
2012-05-11 14:25:54 +00:00
|
|
|
/*
|
|
|
|
|
* The EHCI in ChipIdea HDRC cannot be a separate module or device,
|
|
|
|
|
* because its registers (and irq) are shared between host/gadget/otg
|
|
|
|
|
* functions and in order to facilitate role switching we cannot
|
|
|
|
|
* give the ehci driver exclusive access to those.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef CHIPIDEA_EHCI
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-02 15:47:15 +00:00
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_AUTHOR (DRIVER_AUTHOR);
|
|
|
|
|
MODULE_LICENSE ("GPL");
|
|
|
|
|
|
2005-09-23 05:31:15 +00:00
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
|
#include "ehci-pci.c"
|
2006-04-11 15:07:16 +00:00
|
|
|
#define PCI_DRIVER ehci_pci_driver
|
2005-09-23 05:31:15 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-11 09:09:55 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_FSL
|
2006-01-20 21:53:38 +00:00
|
|
|
#include "ehci-fsl.c"
|
2006-04-11 15:07:16 +00:00
|
|
|
#define PLATFORM_DRIVER ehci_fsl_driver
|
2006-01-20 21:53:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
2009-10-28 00:14:59 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_MXC
|
|
|
|
|
#include "ehci-mxc.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_mxc_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-03-01 07:58:37 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_SH
|
2010-11-01 21:03:27 +00:00
|
|
|
#include "ehci-sh.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_sh_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-08-12 09:39:45 +00:00
|
|
|
#ifdef CONFIG_MIPS_ALCHEMY
|
2006-01-20 22:06:09 +00:00
|
|
|
#include "ehci-au1xxx.c"
|
2006-04-11 15:07:16 +00:00
|
|
|
#define PLATFORM_DRIVER ehci_hcd_au1xxx_driver
|
2006-01-20 22:06:09 +00:00
|
|
|
#endif
|
|
|
|
|
|
2010-11-21 17:53:41 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_HCD_OMAP
|
2009-10-14 08:44:14 +00:00
|
|
|
#include "ehci-omap.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_omap_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-01-16 04:11:47 +00:00
|
|
|
#ifdef CONFIG_PPC_PS3
|
|
|
|
|
#include "ehci-ps3.c"
|
2007-06-06 03:04:35 +00:00
|
|
|
#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
|
2007-01-16 04:11:47 +00:00
|
|
|
#endif
|
|
|
|
|
|
2007-12-30 23:28:50 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_HCD_PPC_OF
|
|
|
|
|
#include "ehci-ppc-of.c"
|
|
|
|
|
#define OF_PLATFORM_DRIVER ehci_hcd_ppc_of_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-09-21 22:08:19 +00:00
|
|
|
#ifdef CONFIG_XPS_USB_HCD_XILINX
|
|
|
|
|
#include "ehci-xilinx-of.c"
|
2010-06-02 19:53:17 +00:00
|
|
|
#define XILINX_OF_PLATFORM_DRIVER ehci_hcd_xilinx_of_driver
|
2009-09-21 22:08:19 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-03-27 18:51:40 +00:00
|
|
|
#ifdef CONFIG_PLAT_ORION
|
2007-12-01 16:07:04 +00:00
|
|
|
#include "ehci-orion.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_orion_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-12-30 23:21:11 +00:00
|
|
|
#ifdef CONFIG_ARCH_IXP4XX
|
|
|
|
|
#include "ehci-ixp4xx.c"
|
|
|
|
|
#define PLATFORM_DRIVER ixp4xx_ehci_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-06-13 01:14:28 +00:00
|
|
|
#ifdef CONFIG_USB_W90X900_EHCI
|
|
|
|
|
#include "ehci-w90x900.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_w90x900_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-07-27 21:47:40 +00:00
|
|
|
#ifdef CONFIG_ARCH_AT91
|
|
|
|
|
#include "ehci-atmel.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_atmel_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-10-08 21:47:52 +00:00
|
|
|
#ifdef CONFIG_USB_OCTEON_EHCI
|
|
|
|
|
#include "ehci-octeon.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_octeon_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-11-25 15:58:00 +00:00
|
|
|
#ifdef CONFIG_USB_CNS3XXX_EHCI
|
|
|
|
|
#include "ehci-cns3xxx.c"
|
|
|
|
|
#define PLATFORM_DRIVER cns3xxx_ehci_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-11-07 16:28:55 +00:00
|
|
|
#ifdef CONFIG_ARCH_VT8500
|
|
|
|
|
#include "ehci-vt8500.c"
|
|
|
|
|
#define PLATFORM_DRIVER vt8500_ehci_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-11-10 09:03:18 +00:00
|
|
|
#ifdef CONFIG_PLAT_SPEAR
|
|
|
|
|
#include "ehci-spear.c"
|
|
|
|
|
#define PLATFORM_DRIVER spear_ehci_hcd_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-12-07 12:23:56 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_MSM
|
|
|
|
|
#include "ehci-msm.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_msm_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-02-24 13:56:28 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_HCD_PMC_MSP
|
|
|
|
|
#include "ehci-pmcmsp.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_msp_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-03-10 00:28:56 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_TEGRA
|
|
|
|
|
#include "ehci-tegra.c"
|
|
|
|
|
#define PLATFORM_DRIVER tegra_ehci_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-04-08 05:08:50 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_S5P
|
|
|
|
|
#include "ehci-s5p.c"
|
|
|
|
|
#define PLATFORM_DRIVER s5p_ehci_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-05-03 18:11:58 +00:00
|
|
|
#ifdef CONFIG_SPARC_LEON
|
|
|
|
|
#include "ehci-grlib.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_grlib_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-11-18 06:42:42 +00:00
|
|
|
#ifdef CONFIG_CPU_XLR
|
2011-08-04 19:58:22 +00:00
|
|
|
#include "ehci-xls.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_xls_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-12-20 05:20:23 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_MV
|
|
|
|
|
#include "ehci-mv.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_mv_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-01-18 06:41:16 +00:00
|
|
|
#ifdef CONFIG_MACH_LOONGSON1
|
|
|
|
|
#include "ehci-ls1x.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_ls1x_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-04-19 17:57:31 +00:00
|
|
|
#ifdef CONFIG_MIPS_SEAD3
|
|
|
|
|
#include "ehci-sead3.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_sead3_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-03-13 00:04:48 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_HCD_PLATFORM
|
|
|
|
|
#include "ehci-platform.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_platform_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-01-16 04:11:47 +00:00
|
|
|
#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
|
2010-06-02 19:53:17 +00:00
|
|
|
!defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
|
|
|
|
|
!defined(XILINX_OF_PLATFORM_DRIVER)
|
2005-09-23 05:31:15 +00:00
|
|
|
#error "missing bus glue for ehci-hcd"
|
|
|
|
|
#endif
|
2006-04-11 15:07:16 +00:00
|
|
|
|
|
|
|
|
static int __init ehci_hcd_init(void)
|
|
|
|
|
{
|
|
|
|
|
int retval = 0;
|
|
|
|
|
|
2008-10-02 15:47:15 +00:00
|
|
|
if (usb_disabled())
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
|
2008-10-02 15:48:13 +00:00
|
|
|
set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
|
|
|
|
|
if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
|
|
|
|
|
test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
|
|
|
|
|
printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
|
|
|
|
|
" before uhci_hcd and ohci_hcd, not after\n");
|
|
|
|
|
|
2006-04-11 15:07:16 +00:00
|
|
|
pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
|
|
|
|
|
hcd_name,
|
|
|
|
|
sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
|
|
|
|
|
sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
|
|
|
|
|
|
2007-09-11 21:07:31 +00:00
|
|
|
#ifdef DEBUG
|
2009-04-24 22:13:18 +00:00
|
|
|
ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
|
2008-10-02 15:48:13 +00:00
|
|
|
if (!ehci_debug_root) {
|
|
|
|
|
retval = -ENOENT;
|
|
|
|
|
goto err_debug;
|
|
|
|
|
}
|
2007-09-11 21:07:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
2006-04-11 15:07:16 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
retval = platform_driver_register(&PLATFORM_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
if (retval < 0)
|
|
|
|
|
goto clean0;
|
2006-04-11 15:07:16 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
|
retval = pci_register_driver(&PCI_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
if (retval < 0)
|
|
|
|
|
goto clean1;
|
2007-01-16 04:11:47 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 03:04:35 +00:00
|
|
|
retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
if (retval < 0)
|
|
|
|
|
goto clean2;
|
2007-09-11 21:07:31 +00:00
|
|
|
#endif
|
2007-12-30 23:28:50 +00:00
|
|
|
|
|
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
retval = platform_driver_register(&OF_PLATFORM_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
if (retval < 0)
|
|
|
|
|
goto clean3;
|
|
|
|
|
#endif
|
2010-06-02 19:53:17 +00:00
|
|
|
|
|
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
retval = platform_driver_register(&XILINX_OF_PLATFORM_DRIVER);
|
2010-06-02 19:53:17 +00:00
|
|
|
if (retval < 0)
|
|
|
|
|
goto clean4;
|
|
|
|
|
#endif
|
2007-12-30 23:28:50 +00:00
|
|
|
return retval;
|
|
|
|
|
|
2010-06-02 19:53:17 +00:00
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
/* platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER); */
|
2010-06-02 19:53:17 +00:00
|
|
|
clean4:
|
|
|
|
|
#endif
|
2007-12-30 23:28:50 +00:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
clean3:
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
|
|
|
|
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
|
|
|
|
clean2:
|
2007-01-16 04:11:47 +00:00
|
|
|
#endif
|
|
|
|
|
#ifdef PCI_DRIVER
|
2007-12-30 23:28:50 +00:00
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
|
|
|
|
clean1:
|
2007-01-16 04:11:47 +00:00
|
|
|
#endif
|
2007-12-30 23:28:50 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
|
clean0:
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
debugfs_remove(ehci_debug_root);
|
|
|
|
|
ehci_debug_root = NULL;
|
2008-10-02 15:48:13 +00:00
|
|
|
err_debug:
|
2008-10-20 21:23:29 +00:00
|
|
|
#endif
|
2008-10-02 15:48:13 +00:00
|
|
|
clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
|
2006-04-11 15:07:16 +00:00
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
module_init(ehci_hcd_init);
|
|
|
|
|
|
|
|
|
|
static void __exit ehci_hcd_cleanup(void)
|
|
|
|
|
{
|
2010-06-02 19:53:17 +00:00
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER);
|
2010-06-02 19:53:17 +00:00
|
|
|
#endif
|
2007-12-30 23:28:50 +00:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-23 04:08:34 +00:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2007-12-30 23:28:50 +00:00
|
|
|
#endif
|
2006-04-11 15:07:16 +00:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
|
|
|
|
#endif
|
2007-01-16 04:11:47 +00:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 03:04:35 +00:00
|
|
|
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
2007-01-16 04:11:47 +00:00
|
|
|
#endif
|
2007-09-11 21:07:31 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
|
debugfs_remove(ehci_debug_root);
|
|
|
|
|
#endif
|
2008-10-02 15:48:13 +00:00
|
|
|
clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
|
2006-04-11 15:07:16 +00:00
|
|
|
}
|
|
|
|
|
module_exit(ehci_hcd_cleanup);
|
|
|
|
|
|
2012-05-11 14:25:54 +00:00
|
|
|
#endif /* CHIPIDEA_EHCI */
|
