2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2011-06-15 14:32:46 -06:00
|
|
|
* Enhanced Host Controller Interface (EHCI) driver for USB.
|
|
|
|
*
|
|
|
|
* Maintainer: Alan Stern <stern@rowland.harvard.edu>
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (c) 2000-2004 by David Brownell
|
2006-08-30 15:50:06 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06: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 09:06:21 -06:00
|
|
|
#include <linux/vmalloc.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
2012-07-11 09:21:54 -06:00
|
|
|
#include <linux/hrtimer.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/usb.h>
|
2010-04-24 15:21:52 -06:00
|
|
|
#include <linux/usb/hcd.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
2007-09-11 15:07:31 -06: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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
2011-11-30 17:40:57 -07:00
|
|
|
#if defined(CONFIG_PPC_PS3)
|
|
|
|
#include <asm/firmware.h>
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06: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";
|
|
|
|
|
|
|
|
|
|
|
|
#undef EHCI_URB_TRACE
|
|
|
|
|
|
|
|
/* 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 09:03:46 -06: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 16:20:36 -06: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 00:34:58 -07:00
|
|
|
/* for flakey hardware, ignore overcurrent indicators */
|
2012-01-12 16:02:20 -07:00
|
|
|
static bool ignore_oc = 0;
|
2006-11-17 00:34:58 -07:00
|
|
|
module_param (ignore_oc, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#include "ehci.h"
|
2011-02-28 23:57:05 -07:00
|
|
|
#include "pci-quirks.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-10-11 20:16:21 -06:00
|
|
|
static void compute_tt_budget(u8 budget_table[EHCI_BANDWIDTH_SIZE],
|
|
|
|
struct ehci_tt *tt);
|
|
|
|
|
2012-10-10 13:07:39 -06:00
|
|
|
/*
|
|
|
|
* The MosChip MCS9990 controller updates its microframe counter
|
|
|
|
* a little before the frame counter, and occasionally we will read
|
|
|
|
* the invalid intermediate value. Avoid problems by checking the
|
|
|
|
* microframe number (the low-order 3 bits); if they are 0 then
|
|
|
|
* re-read the register to get the correct value.
|
|
|
|
*/
|
|
|
|
static unsigned ehci_moschip_read_frame_index(struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
unsigned uf;
|
|
|
|
|
|
|
|
uf = ehci_readl(ehci, &ehci->regs->frame_index);
|
|
|
|
if (unlikely((uf & 7) == 0))
|
|
|
|
uf = ehci_readl(ehci, &ehci->regs->frame_index);
|
|
|
|
return uf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
if (ehci->frame_index_bug)
|
|
|
|
return ehci_moschip_read_frame_index(ehci);
|
|
|
|
return ehci_readl(ehci, &ehci->regs->frame_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "ehci-dbg.c"
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
2013-06-13 11:24:09 -06:00
|
|
|
* ehci_handshake - spin reading hc until handshake completes or fails
|
2005-04-16 16:20:36 -06:00
|
|
|
* @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.
|
|
|
|
*/
|
2013-06-13 11:24:09 -06:00
|
|
|
int ehci_handshake(struct ehci_hcd *ehci, void __iomem *ptr,
|
|
|
|
u32 mask, u32 done, int usec)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
do {
|
2006-12-14 12:54:08 -07:00
|
|
|
result = ehci_readl(ehci, ptr);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (result == ~(u32)0) /* card removed */
|
|
|
|
return -ENODEV;
|
|
|
|
result &= mask;
|
|
|
|
if (result == done)
|
|
|
|
return 0;
|
|
|
|
udelay (1);
|
|
|
|
usec--;
|
|
|
|
} while (usec > 0);
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
2013-06-13 11:24:09 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ehci_handshake);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-09-06 10:26:56 -06:00
|
|
|
/* check TDI/ARC silicon is in host mode */
|
|
|
|
static int tdi_in_host_mode (struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
u32 tmp;
|
|
|
|
|
2012-06-25 10:19:03 -06:00
|
|
|
tmp = ehci_readl(ehci, &ehci->regs->usbmode);
|
2010-09-06 10:26:56 -06:00
|
|
|
return (tmp & 3) == USBMODE_CM_HC;
|
|
|
|
}
|
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
/*
|
|
|
|
* Force HC to halt state from unknown (EHCI spec section 2.3).
|
|
|
|
* Must be called with interrupts enabled and the lock not held.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static int ehci_halt (struct ehci_hcd *ehci)
|
|
|
|
{
|
2012-07-11 09:23:10 -06:00
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-27 11:19:39 -06:00
|
|
|
/* disable any irqs left enabled by previous code */
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
2005-09-27 11:19:39 -06:00
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
if (ehci_is_TDI(ehci) && !tdi_in_host_mode(ehci)) {
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
2010-09-06 10:26:56 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-23 11:54:36 -06: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 12:54:08 -07:00
|
|
|
temp = ehci_readl(ehci, &ehci->regs->command);
|
2012-04-23 11:54:36 -06:00
|
|
|
temp &= ~(CMD_RUN | CMD_IAAD);
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, temp, &ehci->regs->command);
|
2011-11-30 17:40:57 -07:00
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
|
|
|
synchronize_irq(ehci_to_hcd(ehci)->irq);
|
2008-08-26 15:43:46 -06:00
|
|
|
|
2013-06-13 11:24:09 -06:00
|
|
|
return ehci_handshake(ehci, &ehci->regs->status,
|
2006-12-14 12:54:08 -07:00
|
|
|
STS_HALT, STS_HALT, 16 * 125);
|
2008-08-26 15:43:46 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* put TDI/ARC silicon into EHCI mode */
|
|
|
|
static void tdi_reset (struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
u32 tmp;
|
|
|
|
|
2012-06-25 10:19:03 -06:00
|
|
|
tmp = ehci_readl(ehci, &ehci->regs->usbmode);
|
2007-05-23 10:07:48 -06: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;
|
2012-06-25 10:19:03 -06:00
|
|
|
ehci_writel(ehci, tmp, &ehci->regs->usbmode);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
/*
|
|
|
|
* Reset a non-running (STS_HALT == 1) controller.
|
|
|
|
* Must be called with interrupts enabled and the lock not held.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static int ehci_reset (struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
int retval;
|
2006-12-14 12:54:08 -07:00
|
|
|
u32 command = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-20 14:39:54 -06:00
|
|
|
/* If the EHCI debug controller is active, special care must be
|
|
|
|
* taken before and after a host controller reset */
|
2012-09-18 05:23:02 -06:00
|
|
|
if (ehci->debug && !dbgp_reset_prep(ehci_to_hcd(ehci)))
|
2009-08-20 14:39:54 -06:00
|
|
|
ehci->debug = NULL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
command |= CMD_RESET;
|
|
|
|
dbg_cmd (ehci, "reset", command);
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, command, &ehci->regs->command);
|
2011-08-18 14:31:30 -06:00
|
|
|
ehci->rh_state = EHCI_RH_HALTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
ehci->next_statechange = jiffies;
|
2013-06-13 11:24:09 -06:00
|
|
|
retval = ehci_handshake(ehci, &ehci->regs->command,
|
2006-12-14 12:54:08 -07:00
|
|
|
CMD_RESET, 0, 250 * 1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-12 22:41:20 -06:00
|
|
|
if (ehci->has_hostpc) {
|
|
|
|
ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
|
2012-06-25 10:19:03 -06:00
|
|
|
&ehci->regs->usbmode_ex);
|
|
|
|
ehci_writel(ehci, TXFIFO_DEFAULT, &ehci->regs->txfill_tuning);
|
2009-07-12 22:41:20 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (ehci_is_TDI(ehci))
|
|
|
|
tdi_reset (ehci);
|
|
|
|
|
2009-08-20 14:39:54 -06:00
|
|
|
if (ehci->debug)
|
2012-09-18 05:23:02 -06:00
|
|
|
dbgp_external_startup(ehci_to_hcd(ehci));
|
2009-08-20 14:39:54 -06:00
|
|
|
|
2012-04-03 13:24:30 -06:00
|
|
|
ehci->port_c_suspend = ehci->suspended_ports =
|
|
|
|
ehci->resuming_ports = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
/*
|
|
|
|
* Idle the controller (turn off the schedules).
|
|
|
|
* Must be called with interrupts enabled and the lock not held.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static void ehci_quiesce (struct ehci_hcd *ehci)
|
|
|
|
{
|
|
|
|
u32 temp;
|
|
|
|
|
2011-08-18 14:31:30 -06:00
|
|
|
if (ehci->rh_state != EHCI_RH_RUNNING)
|
2012-07-11 09:21:48 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* wait for any schedule enables/disables to take effect */
|
2012-04-23 11:54:36 -06:00
|
|
|
temp = (ehci->command << 10) & (STS_ASS | STS_PSS);
|
2013-06-13 11:24:09 -06:00
|
|
|
ehci_handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, temp,
|
|
|
|
16 * 125);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* then disable anything that's still active */
|
2012-07-11 09:23:10 -06:00
|
|
|
spin_lock_irq(&ehci->lock);
|
2012-04-23 11:54:36 -06:00
|
|
|
ehci->command &= ~(CMD_ASE | CMD_PSE);
|
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
2012-07-11 09:23:10 -06:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* hardware can take 16 microframes to turn off ... */
|
2013-06-13 11:24:09 -06:00
|
|
|
ehci_handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, 0,
|
|
|
|
16 * 125);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-12-11 14:05:30 -07:00
|
|
|
static void end_unlink_async(struct ehci_hcd *ehci);
|
2012-07-11 09:22:53 -06:00
|
|
|
static void unlink_empty_async(struct ehci_hcd *ehci);
|
2013-03-15 12:40:26 -06:00
|
|
|
static void unlink_empty_async_suspended(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 07:55:46 -06:00
|
|
|
static void ehci_work(struct ehci_hcd *ehci);
|
2012-07-11 09:22:26 -06:00
|
|
|
static void start_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
|
|
|
|
static void end_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-11 09:21:54 -06:00
|
|
|
#include "ehci-timer.c"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "ehci-hub.c"
|
|
|
|
#include "ehci-mem.c"
|
|
|
|
#include "ehci-q.c"
|
|
|
|
#include "ehci-sched.c"
|
2011-07-03 10:36:56 -06:00
|
|
|
#include "ehci-sysfs.c"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-02-13 12:55:27 -07: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 15:30:18 -06:00
|
|
|
/*
|
|
|
|
* Halt HC, turn off all ports, and let the BIOS use the companion controllers.
|
2012-07-11 09:23:10 -06:00
|
|
|
* Must be called with interrupts enabled and the lock not held.
|
2005-09-27 11:19:39 -06:00
|
|
|
*/
|
2008-04-08 15:30:18 -06:00
|
|
|
static void ehci_silence_controller(struct ehci_hcd *ehci)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-08 15:30:18 -06:00
|
|
|
ehci_halt(ehci);
|
2012-07-11 09:23:10 -06:00
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
ehci->rh_state = EHCI_RH_HALTED;
|
2007-02-13 12:55:27 -07:00
|
|
|
ehci_turn_off_all_ports(ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* make BIOS/etc use companion controller during reboot */
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2007-02-13 12:55:27 -07:00
|
|
|
|
|
|
|
/* unblock posted writes */
|
|
|
|
ehci_readl(ehci, &ehci->regs->configured_flag);
|
2012-07-11 09:23:10 -06:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-04-08 15:30:18 -06: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);
|
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
2012-07-11 09:23:16 -06:00
|
|
|
ehci->shutdown = true;
|
2012-07-11 09:21:48 -06:00
|
|
|
ehci->rh_state = EHCI_RH_STOPPING;
|
2012-07-11 09:21:54 -06:00
|
|
|
ehci->enabled_hrtimer_events = 0;
|
2008-04-08 15:30:18 -06:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
2012-07-11 09:21:54 -06:00
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
ehci_silence_controller(ehci);
|
|
|
|
|
2012-07-11 09:21:54 -06:00
|
|
|
hrtimer_cancel(&ehci->hrtimer);
|
2008-04-08 15:30:18 -06:00
|
|
|
}
|
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
/*-------------------------------------------------------------------------*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-22 23:31:15 -06: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 07:55:46 -06:00
|
|
|
static void ehci_work (struct ehci_hcd *ehci)
|
2005-09-22 23:31:15 -06:00
|
|
|
{
|
|
|
|
/* 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.
|
|
|
|
*/
|
2012-07-11 09:22:57 -06:00
|
|
|
if (ehci->scanning) {
|
|
|
|
ehci->need_rescan = true;
|
2005-09-22 23:31:15 -06:00
|
|
|
return;
|
2012-07-11 09:22:57 -06:00
|
|
|
}
|
|
|
|
ehci->scanning = true;
|
|
|
|
|
|
|
|
rescan:
|
|
|
|
ehci->need_rescan = false;
|
2012-07-11 09:22:21 -06:00
|
|
|
if (ehci->async_count)
|
|
|
|
scan_async(ehci);
|
2012-07-11 09:23:00 -06:00
|
|
|
if (ehci->intr_count > 0)
|
|
|
|
scan_intr(ehci);
|
|
|
|
if (ehci->isoc_count > 0)
|
|
|
|
scan_isoc(ehci);
|
2012-07-11 09:22:57 -06:00
|
|
|
if (ehci->need_rescan)
|
|
|
|
goto rescan;
|
|
|
|
ehci->scanning = false;
|
2005-09-22 23:31:15 -06:00
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2012-07-11 09:23:04 -06:00
|
|
|
turn_on_io_watchdog(ehci);
|
2005-09-22 23:31:15 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-08 15:30:18 -06:00
|
|
|
/*
|
|
|
|
* Called when the ehci_hcd module is removed.
|
|
|
|
*/
|
2005-09-22 23:31:15 -06:00
|
|
|
static void ehci_stop (struct usb_hcd *hcd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
ehci_dbg (ehci, "stop\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
/* no more interrupts ... */
|
2005-04-09 10:00:29 -06:00
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
spin_lock_irq(&ehci->lock);
|
2012-07-11 09:21:54 -06:00
|
|
|
ehci->enabled_hrtimer_events = 0;
|
2012-07-11 09:23:10 -06:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-11 09:23:10 -06:00
|
|
|
ehci_quiesce(ehci);
|
2008-04-08 15:30:18 -06:00
|
|
|
ehci_silence_controller(ehci);
|
2005-09-22 23:31:15 -06:00
|
|
|
ehci_reset (ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-11 09:21:54 -06:00
|
|
|
hrtimer_cancel(&ehci->hrtimer);
|
2011-07-03 10:36:56 -06:00
|
|
|
remove_sysfs_files(ehci);
|
2005-09-22 23:31:15 -06:00
|
|
|
remove_debug_files (ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
/* root hub is shut down separately (first, when possible) */
|
|
|
|
spin_lock_irq (&ehci->lock);
|
2012-07-11 09:22:35 -06:00
|
|
|
end_free_itds(ehci);
|
2005-09-22 23:31:15 -06:00
|
|
|
spin_unlock_irq (&ehci->lock);
|
|
|
|
ehci_mem_cleanup (ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-02-28 23:57:05 -07:00
|
|
|
if (ehci->amd_pll_fix == 1)
|
|
|
|
usb_amd_dev_put();
|
2010-12-06 19:10:08 -07:00
|
|
|
|
2006-12-14 12:54:08 -07:00
|
|
|
dbg_status (ehci, "ehci_stop completed",
|
|
|
|
ehci_readl(ehci, &ehci->regs->status));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-11-23 16:45:37 -07:00
|
|
|
/* one-time init, only for memory state */
|
|
|
|
static int ehci_init(struct usb_hcd *hcd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-23 16:45:37 -07:00
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 temp;
|
|
|
|
int retval;
|
|
|
|
u32 hcc_params;
|
2009-07-13 17:23:29 -06:00
|
|
|
struct ehci_qh_hw *hw;
|
2005-11-23 16:45:37 -07:00
|
|
|
|
|
|
|
spin_lock_init(&ehci->lock);
|
|
|
|
|
2009-07-13 03:30:41 -06:00
|
|
|
/*
|
|
|
|
* keep io watchdog by default, those good HCDs could turn off it later
|
|
|
|
*/
|
|
|
|
ehci->need_io_watchdog = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-11 09:21:54 -06:00
|
|
|
hrtimer_init(&ehci->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
|
|
|
|
ehci->hrtimer.function = ehci_hrtimer_func;
|
|
|
|
ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
|
2007-12-11 14:05:30 -07:00
|
|
|
|
2011-01-06 08:17:09 -07: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 10:36:57 -06: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 16:20:36 -06: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;
|
2013-03-22 11:31:45 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->async_unlink);
|
2013-03-22 11:31:58 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->async_idle);
|
2013-07-03 08:53:10 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->intr_unlink_wait);
|
2013-03-22 11:31:45 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->intr_unlink);
|
2012-07-11 09:23:00 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->intr_qh_list);
|
2009-02-08 17:07:58 -07:00
|
|
|
INIT_LIST_HEAD(&ehci->cached_itd_list);
|
2010-04-08 14:56:37 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->cached_sitd_list);
|
2013-10-11 20:16:21 -06:00
|
|
|
INIT_LIST_HEAD(&ehci->tt_list);
|
2011-01-06 08:17:09 -07:00
|
|
|
|
2012-05-21 09:54:43 -06:00
|
|
|
if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
|
2011-01-06 08:17:09 -07: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 16:45:37 -07:00
|
|
|
if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
|
|
|
|
/* controllers may cache some of the periodic schedule ... */
|
2006-08-30 15:50:06 -06:00
|
|
|
if (HCC_ISOC_CACHE(hcc_params)) // full frame cache
|
2012-09-28 14:01:34 -06:00
|
|
|
ehci->i_thresh = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
else // N microframes cached
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
|
2005-04-16 16:20:36 -06: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 16:45:37 -07:00
|
|
|
ehci->async->qh_next.qh = NULL;
|
2009-07-13 17:23:29 -06:00
|
|
|
hw = ehci->async->hw;
|
|
|
|
hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
|
|
|
|
hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
|
2012-05-22 11:02:03 -06:00
|
|
|
#if defined(CONFIG_PPC_PS3)
|
2012-07-11 09:21:32 -06:00
|
|
|
hw->hw_info1 |= cpu_to_hc32(ehci, QH_INACTIVATE);
|
2012-05-22 11:02:03 -06:00
|
|
|
#endif
|
2009-07-13 17:23:29 -06:00
|
|
|
hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
|
|
|
|
hw->hw_qtd_next = EHCI_LIST_END(ehci);
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci->async->qh_state = QH_STATE_LINKED;
|
2009-07-13 17:23:29 -06:00
|
|
|
hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
|
2005-04-16 16:20:36 -06: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 01:47:56 -06: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 16:20:36 -06: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 16:45:37 -07:00
|
|
|
park = min(park, (unsigned) 3);
|
2005-04-16 16:20:36 -06:00
|
|
|
temp |= CMD_PARK;
|
|
|
|
temp |= park << 8;
|
|
|
|
}
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci_dbg(ehci, "park %d\n", park);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-11-23 16:45:37 -07:00
|
|
|
if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* periodic schedule size can be smaller than default */
|
|
|
|
temp &= ~(3 << 2);
|
|
|
|
temp |= (EHCI_TUNE_FLS << 2);
|
|
|
|
}
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci->command = temp;
|
|
|
|
|
2009-11-06 10:29:40 -07:00
|
|
|
/* Accept arbitrarily long scatter-gather lists */
|
2010-06-28 08:56:45 -06:00
|
|
|
if (!(hcd->driver->flags & HCD_LOCAL_MEM))
|
|
|
|
hcd->self.sg_tablesize = ~0;
|
2005-11-23 16:45:37 -07: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 14:45:59 -07:00
|
|
|
hcd->uses_new_polling = 1;
|
|
|
|
|
2005-11-23 16:45:37 -07:00
|
|
|
/* EHCI spec section 4.1 */
|
2011-11-22 19:04:45 -07:00
|
|
|
|
2006-12-14 12:54:08 -07: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 16:45:37 -07: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 12:54:08 -07:00
|
|
|
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
|
2005-11-23 16:45:37 -07:00
|
|
|
if (HCC_64BIT_ADDR(hcc_params)) {
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->segment);
|
2005-11-23 16:45:37 -07:00
|
|
|
#if 0
|
|
|
|
// this is deeply broken on almost all architectures
|
2009-04-06 20:01:13 -06:00
|
|
|
if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci_info(ehci, "enabled 64bit DMA\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
// Philips, Intel, and maybe others need CMD_RUN before the
|
|
|
|
// root hub will detect new devices (why?); NEC doesn't
|
2005-11-23 16:45:37 -07:00
|
|
|
ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
|
|
|
|
ehci->command |= CMD_RUN;
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
2005-11-23 16:45:37 -07:00
|
|
|
dbg_cmd (ehci, "init", ehci->command);
|
2005-04-16 16:20:36 -06: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 14:27:07 -06: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-13 17:22:30 -07: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 16:20:36 -06:00
|
|
|
*/
|
2007-10-10 14:27:07 -06:00
|
|
|
down_write(&ehci_cf_port_reset_rwsem);
|
2011-08-18 14:31:30 -06:00
|
|
|
ehci->rh_state = EHCI_RH_RUNNING;
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
|
|
|
|
ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
|
2007-11-13 17:22:30 -07:00
|
|
|
msleep(5);
|
2007-10-10 14:27:07 -06:00
|
|
|
up_write(&ehci_cf_port_reset_rwsem);
|
2009-11-27 07:17:59 -07:00
|
|
|
ehci->last_periodic_enable = ktime_get_real();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-03 12:11:57 -06:00
|
|
|
temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
|
2005-04-16 16:20:36 -06:00
|
|
|
ehci_info (ehci,
|
2008-10-02 09:47:15 -06:00
|
|
|
"USB %x.%x started, EHCI %x.%02x%s\n",
|
2005-09-22 23:31:15 -06:00
|
|
|
((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
|
2008-10-02 09:47:15 -06:00
|
|
|
temp >> 8, temp & 0xff,
|
2006-11-17 00:34:58 -07:00
|
|
|
ignore_oc ? ", overcurrent ignored" : "");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-14 12:54:08 -07:00
|
|
|
ehci_writel(ehci, INTR_MASK,
|
|
|
|
&ehci->regs->intr_enable); /* Turn On Interrupts */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-23 16:45:37 -07: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 10:36:56 -06:00
|
|
|
create_sysfs_files(ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-01 09:12:58 -06:00
|
|
|
int ehci_setup(struct usb_hcd *hcd)
|
2011-07-02 11:47:33 -06:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2012-07-11 09:21:09 -06:00
|
|
|
/* data structure init */
|
|
|
|
retval = ehci_init(hcd);
|
2011-07-02 11:47:33 -06:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2012-07-11 09:21:09 -06:00
|
|
|
retval = ehci_halt(ehci);
|
2011-07-02 11:47:33 -06:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
ehci_reset(ehci);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2012-11-01 09:12:58 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ehci_setup);
|
2011-07-02 11:47:33 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
static irqreturn_t ehci_irq (struct usb_hcd *hcd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2008-11-12 15:04:53 -07:00
|
|
|
u32 status, masked_status, pcd_status = 0, cmd;
|
2005-04-16 16:20:36 -06:00
|
|
|
int bh;
|
2014-02-19 02:29:01 -07:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-02-19 02:29:01 -07:00
|
|
|
/*
|
|
|
|
* For threadirqs option we use spin_lock_irqsave() variant to prevent
|
|
|
|
* deadlock with ehci hrtimer callback, because hrtimer callbacks run
|
|
|
|
* in interrupt context even when threadirqs is specified. We can go
|
|
|
|
* back to spin_lock() variant when hrtimer callbacks become threaded.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&ehci->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-14 12:54:08 -07:00
|
|
|
status = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* e.g. cardbus physical eject */
|
|
|
|
if (status == ~(u32) 0) {
|
|
|
|
ehci_dbg (ehci, "device removed\n");
|
|
|
|
goto dead;
|
|
|
|
}
|
|
|
|
|
2012-04-18 09:33:00 -06: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 15:27:12 -06:00
|
|
|
/* Shared IRQ? */
|
2011-08-18 14:31:30 -06:00
|
|
|
if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
|
2014-02-19 02:29:01 -07:00
|
|
|
spin_unlock_irqrestore(&ehci->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear (just) interrupts */
|
2008-11-12 15:04:53 -07:00
|
|
|
ehci_writel(ehci, masked_status, &ehci->regs->status);
|
2008-03-07 14:49:42 -07:00
|
|
|
cmd = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-16 16:20:36 -06:00
|
|
|
bh = 0;
|
|
|
|
|
|
|
|
/* 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) {
|
2012-07-11 09:22:44 -06:00
|
|
|
|
|
|
|
/* Turn off the IAA watchdog */
|
|
|
|
ehci->enabled_hrtimer_events &= ~BIT(EHCI_HRTIMER_IAA_WATCHDOG);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mild optimization: Allow another IAAD to reset the
|
|
|
|
* hrtimer, if one occurs before the next expiration.
|
|
|
|
* In theory we could always cancel the hrtimer, but
|
|
|
|
* tests show that about half the time it will be reset
|
|
|
|
* for some other event anyway.
|
|
|
|
*/
|
|
|
|
if (ehci->next_hrtimer_event == EHCI_HRTIMER_IAA_WATCHDOG)
|
|
|
|
++ehci->next_hrtimer_event;
|
|
|
|
|
2008-03-07 14:49:42 -07:00
|
|
|
/* guard against (alleged) silicon errata */
|
2012-04-17 13:23:25 -06:00
|
|
|
if (cmd & CMD_IAAD)
|
2008-03-07 14:49:42 -07:00
|
|
|
ehci_dbg(ehci, "IAA with IAAD still set?\n");
|
2013-03-22 11:31:58 -06:00
|
|
|
if (ehci->iaa_in_progress)
|
2012-07-11 09:21:38 -06:00
|
|
|
COUNT(ehci->stats.iaa);
|
2013-03-01 08:50:08 -07:00
|
|
|
end_unlink_async(ehci);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* remote wakeup [4.3.1] */
|
2005-12-22 18:05:18 -07:00
|
|
|
if (status & STS_PCD) {
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned i = HCS_N_PORTS (ehci->hcs_params);
|
2013-03-18 10:05:08 -06:00
|
|
|
u32 ppcd = ~0;
|
2008-03-06 00:37:52 -07:00
|
|
|
|
|
|
|
/* kick root hub later */
|
2007-01-21 14:45:59 -07:00
|
|
|
pcd_status = status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* resume root hub? */
|
2012-04-17 13:24:15 -06:00
|
|
|
if (ehci->rh_state == EHCI_RH_SUSPENDED)
|
2006-11-09 12:42:16 -07:00
|
|
|
usb_hcd_resume_root_hub(hcd);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:47:56 -06:00
|
|
|
/* get per-port change detect bits */
|
|
|
|
if (ehci->has_ppcd)
|
|
|
|
ppcd = status >> 16;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
while (i--) {
|
2010-06-04 01:47:56 -06:00
|
|
|
int pstatus;
|
|
|
|
|
|
|
|
/* leverage per-port change bits feature */
|
2013-03-18 10:05:08 -06:00
|
|
|
if (!(ppcd & (1 << i)))
|
2010-06-04 01:47:56 -06:00
|
|
|
continue;
|
|
|
|
pstatus = ehci_readl(ehci,
|
|
|
|
&ehci->regs->port_status[i]);
|
2006-06-30 03:34:42 -06:00
|
|
|
|
|
|
|
if (pstatus & PORT_OWNER)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2008-10-06 09:25:53 -06: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 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* start 20 msec resume signaling from this port,
|
2014-09-19 09:32:23 -06:00
|
|
|
* and make hub_wq collect PORT_STAT_C_SUSPEND to
|
2010-01-08 09:18:38 -07:00
|
|
|
* stop that signaling. Use 5 ms extra for safety,
|
|
|
|
* like usb_port_resume() does.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-01-08 09:18:38 -07:00
|
|
|
ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
|
2012-04-03 13:24:30 -06:00
|
|
|
set_bit(i, &ehci->resuming_ports);
|
2005-04-16 16:20:36 -06:00
|
|
|
ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
|
2013-01-25 15:09:49 -07:00
|
|
|
usb_hcd_start_port_resume(&hcd->self, i);
|
2007-04-09 09:52:31 -06:00
|
|
|
mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PCI errors [4.15.2.4] */
|
|
|
|
if (unlikely ((status & STS_FATAL) != 0)) {
|
2008-11-12 15:04:53 -07:00
|
|
|
ehci_err(ehci, "fatal error\n");
|
2008-10-06 09:25:53 -06:00
|
|
|
dbg_cmd(ehci, "fatal", cmd);
|
|
|
|
dbg_status(ehci, "fatal", status);
|
2005-04-16 16:20:36 -06:00
|
|
|
dead:
|
2011-05-17 15:27:12 -06:00
|
|
|
usb_hc_died(hcd);
|
2012-07-11 09:22:31 -06:00
|
|
|
|
|
|
|
/* Don't let the controller do anything more */
|
2012-07-11 09:23:16 -06:00
|
|
|
ehci->shutdown = true;
|
2012-07-11 09:22:31 -06:00
|
|
|
ehci->rh_state = EHCI_RH_STOPPING;
|
|
|
|
ehci->command &= ~(CMD_RUN | CMD_ASE | CMD_PSE);
|
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
|
|
|
ehci_handle_controller_death(ehci);
|
|
|
|
|
|
|
|
/* Handle completions when the controller stops */
|
|
|
|
bh = 0;
|
2005-04-16 16:20:36 -06: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 07:55:46 -06:00
|
|
|
ehci_work (ehci);
|
2014-02-19 02:29:01 -07:00
|
|
|
spin_unlock_irqrestore(&ehci->lock, flags);
|
2008-03-06 00:37:52 -07:00
|
|
|
if (pcd_status)
|
2007-01-21 14:45:59 -07:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-04-16 16:20:36 -06: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 01:21:58 -06:00
|
|
|
gfp_t mem_flags
|
2005-04-16 16:20:36 -06: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 16:11:07 -07: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 16:20:36 -06:00
|
|
|
default:
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
return -ENOMEM;
|
2007-08-08 09:48:02 -06:00
|
|
|
return submit_async(ehci, urb, &qtd_list, mem_flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
return -ENOMEM;
|
2007-08-08 09:48:02 -06:00
|
|
|
return intr_submit(ehci, urb, &qtd_list, mem_flags);
|
2005-04-16 16:20:36 -06: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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove from hardware lists
|
|
|
|
* completions normally happen asynchronously
|
|
|
|
*/
|
|
|
|
|
2007-08-08 09:48:02 -06:00
|
|
|
static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
struct ehci_qh *qh;
|
|
|
|
unsigned long flags;
|
2007-08-08 09:48:02 -06:00
|
|
|
int rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
2007-08-08 09:48:02 -06:00
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
if (rc)
|
|
|
|
goto done;
|
|
|
|
|
2013-03-22 11:31:29 -06:00
|
|
|
if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
|
|
|
|
/*
|
|
|
|
* We don't expedite dequeue for isochronous URBs.
|
|
|
|
* Just wait until they complete normally or their
|
|
|
|
* time slot expires.
|
|
|
|
*/
|
|
|
|
} else {
|
2005-04-16 16:20:36 -06:00
|
|
|
qh = (struct ehci_qh *) urb->hcpriv;
|
2013-03-22 11:31:11 -06:00
|
|
|
qh->exception = 1;
|
2007-12-11 14:05:30 -07:00
|
|
|
switch (qh->qh_state) {
|
|
|
|
case QH_STATE_LINKED:
|
2013-03-22 11:31:29 -06:00
|
|
|
if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)
|
|
|
|
start_unlink_intr(ehci, qh);
|
|
|
|
else
|
|
|
|
start_unlink_async(ehci, qh);
|
2007-12-11 14:05:30 -07:00
|
|
|
break;
|
2013-03-22 11:31:11 -06:00
|
|
|
case QH_STATE_COMPLETING:
|
|
|
|
qh->dequeue_during_giveback = 1;
|
|
|
|
break;
|
2007-12-11 14:05:30 -07:00
|
|
|
case QH_STATE_UNLINK:
|
|
|
|
case QH_STATE_UNLINK_WAIT:
|
|
|
|
/* already started */
|
|
|
|
break;
|
|
|
|
case QH_STATE_IDLE:
|
2009-07-31 08:40:22 -06:00
|
|
|
/* QH might be waiting for a Clear-TT-Buffer */
|
|
|
|
qh_completions(ehci, qh);
|
2007-12-11 14:05:30 -07:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
done:
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
2007-08-08 09:48:02 -06:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06: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;
|
2013-07-03 08:53:09 -06:00
|
|
|
struct ehci_qh *qh;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* 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 09:18:56 -07:00
|
|
|
if (qh->hw == NULL) {
|
2012-07-11 09:22:39 -06:00
|
|
|
struct ehci_iso_stream *stream = ep->hcpriv;
|
|
|
|
|
|
|
|
if (!list_empty(&stream->td_list))
|
|
|
|
goto idle_timeout;
|
|
|
|
|
|
|
|
/* BUG_ON(!list_empty(&stream->free_list)); */
|
2013-10-11 09:29:13 -06:00
|
|
|
reserve_release_iso_bandwidth(ehci, stream, -1);
|
2012-07-11 09:22:39 -06:00
|
|
|
kfree(stream);
|
|
|
|
goto done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-03-22 11:31:11 -06:00
|
|
|
qh->exception = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (qh->qh_state) {
|
|
|
|
case QH_STATE_LINKED:
|
2013-07-03 08:53:09 -06:00
|
|
|
WARN_ON(!list_empty(&qh->qtd_list));
|
|
|
|
if (usb_endpoint_type(&ep->desc) != USB_ENDPOINT_XFER_INT)
|
2012-07-11 09:22:49 -06:00
|
|
|
start_unlink_async(ehci, qh);
|
2013-07-03 08:53:09 -06:00
|
|
|
else
|
|
|
|
start_unlink_intr(ehci, qh);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* FALL THROUGH */
|
2013-07-03 08:53:09 -06:00
|
|
|
case QH_STATE_COMPLETING: /* already in unlinking */
|
2005-04-16 16:20:36 -06:00
|
|
|
case QH_STATE_UNLINK: /* wait for hw to finish? */
|
2007-12-11 14:05:30 -07:00
|
|
|
case QH_STATE_UNLINK_WAIT:
|
2005-04-16 16:20:36 -06:00
|
|
|
idle_timeout:
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
2005-08-15 12:30:11 -06:00
|
|
|
schedule_timeout_uninterruptible(1);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto rescan;
|
|
|
|
case QH_STATE_IDLE: /* fully unlinked */
|
2009-06-29 08:47:30 -06:00
|
|
|
if (qh->clearing_tt)
|
|
|
|
goto idle_timeout;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (list_empty (&qh->qtd_list)) {
|
2013-10-11 09:29:13 -06:00
|
|
|
if (qh->ps.bw_uperiod)
|
|
|
|
reserve_release_intr_bandwidth(ehci, qh, -1);
|
2012-07-11 09:21:25 -06:00
|
|
|
qh_destroy(ehci, qh);
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
|
|
|
}
|
2012-07-11 09:22:39 -06:00
|
|
|
done:
|
2005-04-16 16:20:36 -06:00
|
|
|
ep->hcpriv = NULL;
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
|
|
|
}
|
|
|
|
|
2009-05-27 16:21:56 -06: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 12:56:22 -06:00
|
|
|
int epnum = usb_endpoint_num(&ep->desc);
|
|
|
|
int is_out = usb_endpoint_dir_out(&ep->desc);
|
|
|
|
unsigned long flags;
|
2009-05-27 16:21:56 -06:00
|
|
|
|
|
|
|
if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT)
|
|
|
|
return;
|
|
|
|
|
2009-06-11 12:56:22 -06:00
|
|
|
spin_lock_irqsave(&ehci->lock, flags);
|
2009-05-27 16:21:56 -06: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) {
|
|
|
|
if (!list_empty(&qh->qtd_list)) {
|
|
|
|
WARN_ONCE(1, "clear_halt for a busy endpoint\n");
|
2013-03-22 11:31:11 -06:00
|
|
|
} else {
|
2009-06-11 12:56:22 -06: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 16:21:56 -06:00
|
|
|
*/
|
2013-10-11 09:29:03 -06:00
|
|
|
usb_settoggle(qh->ps.udev, epnum, is_out, 0);
|
2013-03-22 11:31:11 -06:00
|
|
|
qh->exception = 1;
|
2009-08-19 10:22:44 -06:00
|
|
|
if (eptype == USB_ENDPOINT_XFER_BULK)
|
2012-07-11 09:22:49 -06:00
|
|
|
start_unlink_async(ehci, qh);
|
2009-08-19 10:22:44 -06:00
|
|
|
else
|
2012-07-11 09:22:26 -06:00
|
|
|
start_unlink_intr(ehci, qh);
|
2009-05-27 16:21:56 -06:00
|
|
|
}
|
|
|
|
}
|
2009-06-11 12:56:22 -06:00
|
|
|
spin_unlock_irqrestore(&ehci->lock, flags);
|
2009-05-27 16:21:56 -06:00
|
|
|
}
|
|
|
|
|
2005-09-22 23:31:15 -06:00
|
|
|
static int ehci_get_frame (struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2011-10-12 08:39:14 -06:00
|
|
|
return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
|
2005-09-22 23:31:15 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
2012-06-28 09:19:02 -06:00
|
|
|
|
2013-10-11 20:16:21 -06:00
|
|
|
/* Device addition and removal */
|
|
|
|
|
|
|
|
static void ehci_remove_device(struct usb_hcd *hcd, struct usb_device *udev)
|
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
drop_tt(udev);
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
|
|
|
/* suspend/resume, section 4.3 */
|
|
|
|
|
|
|
|
/* These routines handle the generic parts of controller suspend/resume */
|
|
|
|
|
2012-11-01 09:12:58 -06:00
|
|
|
int ehci_suspend(struct usb_hcd *hcd, bool do_wakeup)
|
2012-06-28 09:19:02 -06:00
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
|
|
|
if (time_before(jiffies, ehci->next_statechange))
|
|
|
|
msleep(10);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Root hub was already suspended. Disable IRQ emission and
|
|
|
|
* mark HW unaccessible. The PM and USB cores make sure that
|
|
|
|
* the root hub is either suspended or stopped.
|
|
|
|
*/
|
|
|
|
ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup);
|
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
|
|
|
(void) ehci_readl(ehci, &ehci->regs->intr_enable);
|
|
|
|
|
|
|
|
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
|
|
|
|
2013-10-18 09:18:21 -06:00
|
|
|
synchronize_irq(hcd->irq);
|
|
|
|
|
|
|
|
/* Check for race with a wakeup request */
|
|
|
|
if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
|
|
|
|
ehci_resume(hcd, false);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2012-11-01 09:12:58 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ehci_suspend);
|
2012-06-28 09:19:02 -06:00
|
|
|
|
|
|
|
/* Returns 0 if power was preserved, 1 if power was lost */
|
2012-11-01 09:12:58 -06:00
|
|
|
int ehci_resume(struct usb_hcd *hcd, bool hibernated)
|
2012-06-28 09:19:02 -06:00
|
|
|
{
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
|
|
|
|
|
|
|
if (time_before(jiffies, ehci->next_statechange))
|
|
|
|
msleep(100);
|
|
|
|
|
|
|
|
/* Mark hardware accessible again as we are back to full power by now */
|
|
|
|
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
|
|
|
|
2012-07-11 09:23:16 -06:00
|
|
|
if (ehci->shutdown)
|
|
|
|
return 0; /* Controller is dead */
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
/*
|
|
|
|
* If CF is still set and we aren't resuming from hibernation
|
|
|
|
* then we maintained suspend power.
|
|
|
|
* Just undo the effect of ehci_suspend().
|
|
|
|
*/
|
|
|
|
if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF &&
|
|
|
|
!hibernated) {
|
|
|
|
int mask = INTR_MASK;
|
|
|
|
|
|
|
|
ehci_prepare_ports_for_controller_resume(ehci);
|
2012-07-11 09:23:16 -06:00
|
|
|
|
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
if (ehci->shutdown)
|
|
|
|
goto skip;
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
if (!hcd->self.root_hub->do_remote_wakeup)
|
|
|
|
mask &= ~STS_PCD;
|
|
|
|
ehci_writel(ehci, mask, &ehci->regs->intr_enable);
|
|
|
|
ehci_readl(ehci, &ehci->regs->intr_enable);
|
2012-07-11 09:23:16 -06:00
|
|
|
skip:
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
2012-06-28 09:19:02 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Else reset, to cope with power loss or resume from hibernation
|
|
|
|
* having let the firmware kick in during reboot.
|
|
|
|
*/
|
|
|
|
usb_root_hub_lost_power(hcd->self.root_hub);
|
|
|
|
(void) ehci_halt(ehci);
|
|
|
|
(void) ehci_reset(ehci);
|
|
|
|
|
2012-07-11 09:23:16 -06:00
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
if (ehci->shutdown)
|
|
|
|
goto skip;
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
|
|
|
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
|
|
|
|
ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
|
|
|
|
|
2012-07-11 09:23:16 -06:00
|
|
|
ehci->rh_state = EHCI_RH_SUSPENDED;
|
|
|
|
spin_unlock_irq(&ehci->lock);
|
|
|
|
|
2012-06-28 09:19:02 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2012-11-01 09:12:58 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ehci_resume);
|
2012-06-28 09:19:02 -06:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2012-11-01 09:12:58 -06:00
|
|
|
/*
|
|
|
|
* Generic structure: This gets copied for platform drivers so that
|
|
|
|
* individual entries can be overridden as needed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static const struct hc_driver ehci_hc_driver = {
|
|
|
|
.description = hcd_name,
|
|
|
|
.product_desc = "EHCI Host Controller",
|
|
|
|
.hcd_priv_size = sizeof(struct ehci_hcd),
|
|
|
|
|
|
|
|
/*
|
|
|
|
* generic hardware linkage
|
|
|
|
*/
|
|
|
|
.irq = ehci_irq,
|
2013-09-23 14:32:51 -06:00
|
|
|
.flags = HCD_MEMORY | HCD_USB2 | HCD_BH,
|
2012-11-01 09:12:58 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* basic lifecycle operations
|
|
|
|
*/
|
|
|
|
.reset = ehci_setup,
|
|
|
|
.start = ehci_run,
|
|
|
|
.stop = ehci_stop,
|
|
|
|
.shutdown = ehci_shutdown,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* managing i/o requests and associated device resources
|
|
|
|
*/
|
|
|
|
.urb_enqueue = ehci_urb_enqueue,
|
|
|
|
.urb_dequeue = ehci_urb_dequeue,
|
|
|
|
.endpoint_disable = ehci_endpoint_disable,
|
|
|
|
.endpoint_reset = ehci_endpoint_reset,
|
|
|
|
.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* scheduling support
|
|
|
|
*/
|
|
|
|
.get_frame_number = ehci_get_frame,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* root hub support
|
|
|
|
*/
|
|
|
|
.hub_status_data = ehci_hub_status_data,
|
|
|
|
.hub_control = ehci_hub_control,
|
|
|
|
.bus_suspend = ehci_bus_suspend,
|
|
|
|
.bus_resume = ehci_bus_resume,
|
|
|
|
.relinquish_port = ehci_relinquish_port,
|
|
|
|
.port_handed_over = ehci_port_handed_over,
|
2013-10-11 20:16:21 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* device support
|
|
|
|
*/
|
|
|
|
.free_dev = ehci_remove_device,
|
2012-11-01 09:12:58 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
void ehci_init_driver(struct hc_driver *drv,
|
|
|
|
const struct ehci_driver_overrides *over)
|
|
|
|
{
|
|
|
|
/* Copy the generic table to drv and then apply the overrides */
|
|
|
|
*drv = ehci_hc_driver;
|
|
|
|
|
2012-11-07 14:12:47 -07:00
|
|
|
if (over) {
|
|
|
|
drv->hcd_priv_size += over->extra_priv_size;
|
|
|
|
if (over->reset)
|
|
|
|
drv->reset = over->reset;
|
|
|
|
}
|
2012-11-01 09:12:58 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ehci_init_driver);
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-10-02 09:47:15 -06:00
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_AUTHOR (DRIVER_AUTHOR);
|
|
|
|
MODULE_LICENSE ("GPL");
|
|
|
|
|
2007-05-11 03:09:55 -06:00
|
|
|
#ifdef CONFIG_USB_EHCI_FSL
|
2006-01-20 14:53:38 -07:00
|
|
|
#include "ehci-fsl.c"
|
2006-04-11 09:07:16 -06:00
|
|
|
#define PLATFORM_DRIVER ehci_fsl_driver
|
2006-01-20 14:53:38 -07:00
|
|
|
#endif
|
|
|
|
|
2011-03-01 00:58:37 -07:00
|
|
|
#ifdef CONFIG_USB_EHCI_SH
|
2010-11-01 15:03:27 -06:00
|
|
|
#include "ehci-sh.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_sh_driver
|
|
|
|
#endif
|
|
|
|
|
2007-01-15 21:11:47 -07:00
|
|
|
#ifdef CONFIG_PPC_PS3
|
|
|
|
#include "ehci-ps3.c"
|
2007-06-05 21:04:35 -06:00
|
|
|
#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
|
2007-01-15 21:11:47 -07:00
|
|
|
#endif
|
|
|
|
|
2007-12-30 16:28:50 -07: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 16:08:19 -06:00
|
|
|
#ifdef CONFIG_XPS_USB_HCD_XILINX
|
|
|
|
#include "ehci-xilinx-of.c"
|
2010-06-02 13:53:17 -06:00
|
|
|
#define XILINX_OF_PLATFORM_DRIVER ehci_hcd_xilinx_of_driver
|
2009-09-21 16:08:19 -06:00
|
|
|
#endif
|
|
|
|
|
2010-10-08 15:47:52 -06:00
|
|
|
#ifdef CONFIG_USB_OCTEON_EHCI
|
|
|
|
#include "ehci-octeon.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_octeon_driver
|
|
|
|
#endif
|
|
|
|
|
2012-05-09 11:58:14 -06:00
|
|
|
#ifdef CONFIG_TILE_USB
|
|
|
|
#include "ehci-tilegx.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_tilegx_driver
|
|
|
|
#endif
|
|
|
|
|
2011-02-24 06:56:28 -07:00
|
|
|
#ifdef CONFIG_USB_EHCI_HCD_PMC_MSP
|
|
|
|
#include "ehci-pmcmsp.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_msp_driver
|
|
|
|
#endif
|
|
|
|
|
2011-05-03 12:11:58 -06:00
|
|
|
#ifdef CONFIG_SPARC_LEON
|
|
|
|
#include "ehci-grlib.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_grlib_driver
|
|
|
|
#endif
|
|
|
|
|
2011-12-19 22:20:23 -07:00
|
|
|
#ifdef CONFIG_USB_EHCI_MV
|
|
|
|
#include "ehci-mv.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_mv_driver
|
|
|
|
#endif
|
2012-01-17 23:41:16 -07:00
|
|
|
|
2012-04-19 11:57:31 -06:00
|
|
|
#ifdef CONFIG_MIPS_SEAD3
|
|
|
|
#include "ehci-sead3.c"
|
|
|
|
#define PLATFORM_DRIVER ehci_hcd_sead3_driver
|
|
|
|
#endif
|
|
|
|
|
2006-04-11 09:07:16 -06:00
|
|
|
static int __init ehci_hcd_init(void)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
2008-10-02 09:47:15 -06:00
|
|
|
if (usb_disabled())
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
|
2008-10-02 09:48:13 -06: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 09:07:16 -06: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));
|
|
|
|
|
2013-11-18 05:23:16 -07:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2009-04-24 16:13:18 -06:00
|
|
|
ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
|
2008-10-02 09:48:13 -06:00
|
|
|
if (!ehci_debug_root) {
|
|
|
|
retval = -ENOENT;
|
|
|
|
goto err_debug;
|
|
|
|
}
|
2007-09-11 15:07:31 -06:00
|
|
|
#endif
|
|
|
|
|
2006-04-11 09:07:16 -06:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
retval = platform_driver_register(&PLATFORM_DRIVER);
|
2007-12-30 16:28:50 -07:00
|
|
|
if (retval < 0)
|
|
|
|
goto clean0;
|
2006-04-11 09:07:16 -06:00
|
|
|
#endif
|
|
|
|
|
2007-01-15 21:11:47 -07:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-05 21:04:35 -06:00
|
|
|
retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
|
2007-12-30 16:28:50 -07:00
|
|
|
if (retval < 0)
|
|
|
|
goto clean2;
|
2007-09-11 15:07:31 -06:00
|
|
|
#endif
|
2007-12-30 16:28:50 -07:00
|
|
|
|
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
retval = platform_driver_register(&OF_PLATFORM_DRIVER);
|
2007-12-30 16:28:50 -07:00
|
|
|
if (retval < 0)
|
|
|
|
goto clean3;
|
|
|
|
#endif
|
2010-06-02 13:53:17 -06:00
|
|
|
|
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
retval = platform_driver_register(&XILINX_OF_PLATFORM_DRIVER);
|
2010-06-02 13:53:17 -06:00
|
|
|
if (retval < 0)
|
|
|
|
goto clean4;
|
|
|
|
#endif
|
2007-12-30 16:28:50 -07:00
|
|
|
return retval;
|
|
|
|
|
2010-06-02 13:53:17 -06:00
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
/* platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER); */
|
2010-06-02 13:53:17 -06:00
|
|
|
clean4:
|
|
|
|
#endif
|
2007-12-30 16:28:50 -07:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2007-12-30 16:28:50 -07:00
|
|
|
clean3:
|
|
|
|
#endif
|
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
|
|
|
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
|
|
|
clean2:
|
2007-01-15 21:11:47 -07:00
|
|
|
#endif
|
2007-12-30 16:28:50 -07:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
clean0:
|
|
|
|
#endif
|
2013-11-18 05:23:16 -07:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2007-12-30 16:28:50 -07:00
|
|
|
debugfs_remove(ehci_debug_root);
|
|
|
|
ehci_debug_root = NULL;
|
2008-10-02 09:48:13 -06:00
|
|
|
err_debug:
|
2008-10-20 15:23:29 -06:00
|
|
|
#endif
|
2008-10-02 09:48:13 -06:00
|
|
|
clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
|
2006-04-11 09:07:16 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
module_init(ehci_hcd_init);
|
|
|
|
|
|
|
|
static void __exit ehci_hcd_cleanup(void)
|
|
|
|
{
|
2010-06-02 13:53:17 -06:00
|
|
|
#ifdef XILINX_OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER);
|
2010-06-02 13:53:17 -06:00
|
|
|
#endif
|
2007-12-30 16:28:50 -07:00
|
|
|
#ifdef OF_PLATFORM_DRIVER
|
2011-02-22 21:08:34 -07:00
|
|
|
platform_driver_unregister(&OF_PLATFORM_DRIVER);
|
2007-12-30 16:28:50 -07:00
|
|
|
#endif
|
2006-04-11 09:07:16 -06:00
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
#endif
|
2007-01-15 21:11:47 -07:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-05 21:04:35 -06:00
|
|
|
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
2007-01-15 21:11:47 -07:00
|
|
|
#endif
|
2013-11-18 05:23:16 -07:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2007-09-11 15:07:31 -06:00
|
|
|
debugfs_remove(ehci_debug_root);
|
|
|
|
#endif
|
2008-10-02 09:48:13 -06:00
|
|
|
clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
|
2006-04-11 09:07:16 -06:00
|
|
|
}
|
|
|
|
module_exit(ehci_hcd_cleanup);
|