2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2000-2004 by David Brownell
|
2006-08-31 05:50:06 +08:00
|
|
|
*
|
2005-04-17 06:20:36 +08: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>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/timer.h>
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
|
#include <linux/usb.h>
|
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
|
|
|
|
|
|
#include "../core/hcd.h"
|
|
|
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
#include <asm/system.h>
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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!
|
|
|
|
|
*
|
|
|
|
|
* HISTORY:
|
|
|
|
|
*
|
|
|
|
|
* 2004-05-10 Root hub and PCI suspend/resume support; remote wakeup. (db)
|
|
|
|
|
* 2004-02-24 Replace pci_* with generic dma_* API calls (dsaxena@plexity.net)
|
|
|
|
|
* 2003-12-29 Rewritten high speed iso transfer support (by Michal Sojka,
|
|
|
|
|
* <sojkam@centrum.cz>, updates by DB).
|
|
|
|
|
*
|
|
|
|
|
* 2002-11-29 Correct handling for hw async_next register.
|
|
|
|
|
* 2002-08-06 Handling for bulk and interrupt transfers is mostly shared;
|
|
|
|
|
* only scheduling is different, no arbitrary limitations.
|
|
|
|
|
* 2002-07-25 Sanity check PCI reads, mostly for better cardbus support,
|
2006-08-31 05:50:06 +08:00
|
|
|
* clean up HC run state handshaking.
|
2005-04-17 06:20:36 +08:00
|
|
|
* 2002-05-24 Preliminary FS/LS interrupts, using scheduling shortcuts
|
|
|
|
|
* 2002-05-11 Clear TT errors for FS/LS ctrl/bulk. Fill in some other
|
|
|
|
|
* missing pieces: enabling 64bit dma, handoff from BIOS/SMM.
|
|
|
|
|
* 2002-05-07 Some error path cleanups to report better errors; wmb();
|
|
|
|
|
* use non-CVS version id; better iso bandwidth claim.
|
|
|
|
|
* 2002-04-19 Control/bulk/interrupt submit no longer uses giveback() on
|
|
|
|
|
* errors in submit path. Bugfixes to interrupt scheduling/processing.
|
|
|
|
|
* 2002-03-05 Initial high-speed ISO support; reduce ITD memory; shift
|
|
|
|
|
* more checking to generic hcd framework (db). Make it work with
|
|
|
|
|
* Philips EHCI; reduce PCI traffic; shorten IRQ path (Rory Bolt).
|
|
|
|
|
* 2002-01-14 Minor cleanup; version synch.
|
|
|
|
|
* 2002-01-08 Fix roothub handoff of FS/LS to companion controllers.
|
|
|
|
|
* 2002-01-04 Control/Bulk queuing behaves.
|
|
|
|
|
*
|
|
|
|
|
* 2001-12-12 Initial patch version for Linux 2.5.1 kernel.
|
|
|
|
|
* 2001-June Works with usb-storage and NEC EHCI on 2.4
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define DRIVER_VERSION "10 Dec 2004"
|
|
|
|
|
#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_VERBOSE_DEBUG
|
|
|
|
|
#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
|
|
|
|
|
#define EHCI_TUNE_FLS 2 /* (small) 256 frame schedule */
|
|
|
|
|
|
2006-10-18 04:57:18 +08:00
|
|
|
#define EHCI_IAA_JIFFIES (HZ/100) /* arbitrary; ~10 msec */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EHCI_IO_JIFFIES (HZ/10) /* io watchdog > irq_thresh */
|
|
|
|
|
#define EHCI_ASYNC_JIFFIES (HZ/20) /* async idle timeout */
|
|
|
|
|
#define EHCI_SHRINK_JIFFIES (HZ/200) /* async qh unlink delay */
|
|
|
|
|
|
|
|
|
|
/* 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 15:34:58 +08:00
|
|
|
/* for flakey hardware, ignore overcurrent indicators */
|
|
|
|
|
static int ignore_oc = 0;
|
|
|
|
|
module_param (ignore_oc, bool, S_IRUGO);
|
|
|
|
|
MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
#include "ehci.h"
|
|
|
|
|
#include "ehci-dbg.c"
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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-15 03:54:08 +08:00
|
|
|
static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
|
|
|
|
|
u32 mask, u32 done, int usec)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
|
|
do {
|
2006-12-15 03:54:08 +08:00
|
|
|
result = ehci_readl(ehci, ptr);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result == ~(u32)0) /* card removed */
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
result &= mask;
|
|
|
|
|
if (result == done)
|
|
|
|
|
return 0;
|
|
|
|
|
udelay (1);
|
|
|
|
|
usec--;
|
|
|
|
|
} while (usec > 0);
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* force HC to halt state from unknown (EHCI spec section 2.3) */
|
|
|
|
|
static int ehci_halt (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
2006-12-15 03:54:08 +08:00
|
|
|
u32 temp = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-28 01:19:39 +08:00
|
|
|
/* disable any irqs left enabled by previous code */
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
2005-09-28 01:19:39 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((temp & STS_HALT) != 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-12-15 03:54:08 +08:00
|
|
|
temp = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-17 06:20:36 +08:00
|
|
|
temp &= ~CMD_RUN;
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, temp, &ehci->regs->command);
|
|
|
|
|
return handshake (ehci, &ehci->regs->status,
|
|
|
|
|
STS_HALT, STS_HALT, 16 * 125);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* put TDI/ARC silicon into EHCI mode */
|
|
|
|
|
static void tdi_reset (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
u32 __iomem *reg_ptr;
|
|
|
|
|
u32 tmp;
|
|
|
|
|
|
2007-05-24 00:07:48 +08:00
|
|
|
reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
|
2006-12-15 03:54:08 +08:00
|
|
|
tmp = ehci_readl(ehci, reg_ptr);
|
2007-05-24 00:07:48 +08: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-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, tmp, reg_ptr);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* reset a non-running (STS_HALT == 1) controller */
|
|
|
|
|
static int ehci_reset (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
int retval;
|
2006-12-15 03:54:08 +08:00
|
|
|
u32 command = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
command |= CMD_RESET;
|
|
|
|
|
dbg_cmd (ehci, "reset", command);
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, command, &ehci->regs->command);
|
2005-04-17 06:20:36 +08:00
|
|
|
ehci_to_hcd(ehci)->state = HC_STATE_HALT;
|
|
|
|
|
ehci->next_statechange = jiffies;
|
2006-12-15 03:54:08 +08:00
|
|
|
retval = handshake (ehci, &ehci->regs->command,
|
|
|
|
|
CMD_RESET, 0, 250 * 1000);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
if (ehci_is_TDI(ehci))
|
|
|
|
|
tdi_reset (ehci);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* idle the controller (from running) */
|
|
|
|
|
static void ehci_quiesce (struct ehci_hcd *ehci)
|
|
|
|
|
{
|
|
|
|
|
u32 temp;
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
|
|
|
|
|
BUG ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* wait for any schedule enables/disables to take effect */
|
2006-12-15 03:54:08 +08:00
|
|
|
temp = ehci_readl(ehci, &ehci->regs->command) << 10;
|
2005-04-17 06:20:36 +08:00
|
|
|
temp &= STS_ASS | STS_PSS;
|
2006-12-15 03:54:08 +08:00
|
|
|
if (handshake (ehci, &ehci->regs->status, STS_ASS | STS_PSS,
|
2005-04-17 06:20:36 +08:00
|
|
|
temp, 16 * 125) != 0) {
|
|
|
|
|
ehci_to_hcd(ehci)->state = HC_STATE_HALT;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* then disable anything that's still active */
|
2006-12-15 03:54:08 +08:00
|
|
|
temp = ehci_readl(ehci, &ehci->regs->command);
|
2005-04-17 06:20:36 +08:00
|
|
|
temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, temp, &ehci->regs->command);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* hardware can take 16 microframes to turn off ... */
|
2006-12-15 03:54:08 +08:00
|
|
|
if (handshake (ehci, &ehci->regs->status, STS_ASS | STS_PSS,
|
2005-04-17 06:20:36 +08:00
|
|
|
0, 16 * 125) != 0) {
|
|
|
|
|
ehci_to_hcd(ehci)->state = HC_STATE_HALT;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void ehci_work(struct ehci_hcd *ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#include "ehci-hub.c"
|
|
|
|
|
#include "ehci-mem.c"
|
|
|
|
|
#include "ehci-q.c"
|
|
|
|
|
#include "ehci-sched.c"
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
2006-10-18 04:57:18 +08:00
|
|
|
static void ehci_watchdog (unsigned long param)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = (struct ehci_hcd *) param;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
|
|
|
|
|
2006-10-18 04:57:18 +08:00
|
|
|
/* lost IAA irqs wedge things badly; seen with a vt8235 */
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ehci->reclaim) {
|
2006-12-15 03:54:08 +08:00
|
|
|
u32 status = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status & STS_IAA) {
|
|
|
|
|
ehci_vdbg (ehci, "lost IAA\n");
|
|
|
|
|
COUNT (ehci->stats.lost_iaa);
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, STS_IAA, &ehci->regs->status);
|
2006-10-18 04:57:18 +08:00
|
|
|
ehci->reclaim_ready = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-18 04:57:18 +08:00
|
|
|
/* stop async processing after it's idled a bit */
|
2005-04-17 06:20:36 +08:00
|
|
|
if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
|
2006-09-19 08:03:16 +08:00
|
|
|
start_unlink_async (ehci, ehci->async);
|
2005-04-17 06:20:36 +08: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 21:55:46 +08:00
|
|
|
ehci_work (ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-14 03:55:27 +08: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]);
|
|
|
|
|
}
|
|
|
|
|
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 08:24:08 +08:00
|
|
|
/* ehci_shutdown kick in for silicon on any bus (not just pci, etc).
|
2005-09-28 01:19:39 +08:00
|
|
|
* This forcibly disables dma and IRQs, helping kexec and other cases
|
|
|
|
|
* where the next system software may expect clean state.
|
|
|
|
|
*/
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 08:24:08 +08:00
|
|
|
static void
|
|
|
|
|
ehci_shutdown (struct usb_hcd *hcd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 08:24:08 +08:00
|
|
|
struct ehci_hcd *ehci;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 08:24:08 +08:00
|
|
|
ehci = hcd_to_ehci (hcd);
|
2005-09-28 01:19:39 +08:00
|
|
|
(void) ehci_halt (ehci);
|
2007-02-14 03:55:27 +08:00
|
|
|
ehci_turn_off_all_ports(ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* make BIOS/etc use companion controller during reboot */
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2007-02-14 03:55:27 +08:00
|
|
|
|
|
|
|
|
/* unblock posted writes */
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->configured_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-04-10 00:00:29 +08: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 23:52:40 +08:00
|
|
|
/* Flush those writes */
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->command);
|
2005-04-10 00:00:29 +08:00
|
|
|
msleep(20);
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
/*-------------------------------------------------------------------------*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08: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 21:55:46 +08:00
|
|
|
static void ehci_work (struct ehci_hcd *ehci)
|
2005-09-23 13:31:15 +08:00
|
|
|
{
|
|
|
|
|
timer_action_done (ehci, TIMER_IO_WATCHDOG);
|
2006-10-18 04:57:18 +08:00
|
|
|
if (ehci->reclaim_ready)
|
|
|
|
|
end_unlink_async (ehci);
|
2005-09-23 13:31:15 +08: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.
|
|
|
|
|
*/
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
scan_async (ehci);
|
2005-09-23 13:31:15 +08: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 21:55:46 +08:00
|
|
|
scan_periodic (ehci);
|
2005-09-23 13:31:15 +08: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.
|
|
|
|
|
*/
|
|
|
|
|
if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
|
|
|
|
|
(ehci->async->qh_next.ptr != NULL ||
|
|
|
|
|
ehci->periodic_sched != 0))
|
|
|
|
|
timer_action (ehci, TIMER_IO_WATCHDOG);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
static void ehci_stop (struct usb_hcd *hcd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
ehci_dbg (ehci, "stop\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
/* Turn off port power on all root hub ports. */
|
|
|
|
|
ehci_port_power (ehci, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
/* no more interrupts ... */
|
|
|
|
|
del_timer_sync (&ehci->watchdog);
|
2005-04-10 00:00:29 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
spin_lock_irq(&ehci->lock);
|
|
|
|
|
if (HC_IS_RUNNING (hcd->state))
|
|
|
|
|
ehci_quiesce (ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
ehci_reset (ehci);
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->intr_enable);
|
2005-09-23 13:31:15 +08:00
|
|
|
spin_unlock_irq(&ehci->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
/* let companion controllers work when we aren't */
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2005-04-10 00:00:29 +08:00
|
|
|
|
2007-01-17 00:59:45 +08:00
|
|
|
remove_companion_file(ehci);
|
2005-09-23 13:31:15 +08:00
|
|
|
remove_debug_files (ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08: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 21:55:46 +08:00
|
|
|
ehci_work (ehci);
|
2005-09-23 13:31:15 +08:00
|
|
|
spin_unlock_irq (&ehci->lock);
|
|
|
|
|
ehci_mem_cleanup (ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-23 13:31:15 +08: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-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
2006-12-15 03:54:08 +08:00
|
|
|
dbg_status (ehci, "ehci_stop completed",
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->status));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-24 07:45:37 +08:00
|
|
|
/* one-time init, only for memory state */
|
|
|
|
|
static int ehci_init(struct usb_hcd *hcd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-24 07:45:37 +08:00
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 temp;
|
|
|
|
|
int retval;
|
|
|
|
|
u32 hcc_params;
|
2005-11-24 07:45:37 +08:00
|
|
|
|
|
|
|
|
spin_lock_init(&ehci->lock);
|
|
|
|
|
|
|
|
|
|
init_timer(&ehci->watchdog);
|
|
|
|
|
ehci->watchdog.function = ehci_watchdog;
|
|
|
|
|
ehci->watchdog.data = (unsigned long) ehci;
|
2005-04-17 06:20:36 +08: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;
|
2005-11-24 07:45:37 +08:00
|
|
|
if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
/* controllers may cache some of the periodic schedule ... */
|
2006-12-15 03:54:08 +08:00
|
|
|
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
|
2006-08-31 05:50:06 +08:00
|
|
|
if (HCC_ISOC_CACHE(hcc_params)) // full frame cache
|
2005-04-17 06:20:36 +08:00
|
|
|
ehci->i_thresh = 8;
|
|
|
|
|
else // N microframes cached
|
2005-11-24 07:45:37 +08:00
|
|
|
ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
ehci->reclaim = NULL;
|
2006-10-18 04:57:18 +08:00
|
|
|
ehci->reclaim_ready = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
ehci->next_uframe = -1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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-24 07:45:37 +08:00
|
|
|
ehci->async->qh_next.qh = NULL;
|
2007-05-02 00:29:37 +08:00
|
|
|
ehci->async->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
|
|
|
|
|
ehci->async->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
|
|
|
|
|
ehci->async->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
|
|
|
|
|
ehci->async->hw_qtd_next = EHCI_LIST_END(ehci);
|
2005-11-24 07:45:37 +08:00
|
|
|
ehci->async->qh_state = QH_STATE_LINKED;
|
2007-05-02 00:29:37 +08:00
|
|
|
ehci->async->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
|
2005-04-17 06:20:36 +08: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);
|
|
|
|
|
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-24 07:45:37 +08:00
|
|
|
park = min(park, (unsigned) 3);
|
2005-04-17 06:20:36 +08:00
|
|
|
temp |= CMD_PARK;
|
|
|
|
|
temp |= park << 8;
|
|
|
|
|
}
|
2005-11-24 07:45:37 +08:00
|
|
|
ehci_dbg(ehci, "park %d\n", park);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-11-24 07:45:37 +08:00
|
|
|
if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* periodic schedule size can be smaller than default */
|
|
|
|
|
temp &= ~(3 << 2);
|
|
|
|
|
temp |= (EHCI_TUNE_FLS << 2);
|
|
|
|
|
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;
|
2005-11-24 07:45:37 +08:00
|
|
|
default: BUG();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
2005-11-24 07:45:37 +08:00
|
|
|
ehci->command = temp;
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
int retval;
|
|
|
|
|
u32 temp;
|
|
|
|
|
u32 hcc_params;
|
|
|
|
|
|
2007-01-22 05:45:59 +08:00
|
|
|
hcd->uses_new_polling = 1;
|
|
|
|
|
hcd->poll_rh = 0;
|
|
|
|
|
|
2005-11-24 07:45:37 +08:00
|
|
|
/* EHCI spec section 4.1 */
|
|
|
|
|
if ((retval = ehci_reset(ehci)) != 0) {
|
|
|
|
|
ehci_mem_cleanup(ehci);
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
2006-12-15 03:54:08 +08: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-24 07:45:37 +08: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-15 03:54:08 +08:00
|
|
|
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
|
2005-11-24 07:45:37 +08:00
|
|
|
if (HCC_64BIT_ADDR(hcc_params)) {
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->segment);
|
2005-11-24 07:45:37 +08:00
|
|
|
#if 0
|
|
|
|
|
// this is deeply broken on almost all architectures
|
|
|
|
|
if (!dma_set_mask(hcd->self.controller, DMA_64BIT_MASK))
|
|
|
|
|
ehci_info(ehci, "enabled 64bit DMA\n");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
// Philips, Intel, and maybe others need CMD_RUN before the
|
|
|
|
|
// root hub will detect new devices (why?); NEC doesn't
|
2005-11-24 07:45:37 +08:00
|
|
|
ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
|
|
|
|
|
ehci->command |= CMD_RUN;
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, ehci->command, &ehci->regs->command);
|
2005-11-24 07:45:37 +08:00
|
|
|
dbg_cmd (ehci, "init", ehci->command);
|
2005-04-17 06:20:36 +08: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-11 04:27:07 +08: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 08:22:30 +08: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-17 06:20:36 +08:00
|
|
|
*/
|
2007-10-11 04:27:07 +08:00
|
|
|
down_write(&ehci_cf_port_reset_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
hcd->state = HC_STATE_RUNNING;
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
|
2007-11-14 08:22:30 +08:00
|
|
|
msleep(5);
|
2007-10-11 04:27:07 +08:00
|
|
|
up_write(&ehci_cf_port_reset_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-12-15 03:54:08 +08:00
|
|
|
temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
|
2005-04-17 06:20:36 +08:00
|
|
|
ehci_info (ehci,
|
2006-11-17 15:34:58 +08:00
|
|
|
"USB %x.%x started, EHCI %x.%02x, driver %s%s\n",
|
2005-09-23 13:31:15 +08:00
|
|
|
((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
|
2006-11-17 15:34:58 +08:00
|
|
|
temp >> 8, temp & 0xff, DRIVER_VERSION,
|
|
|
|
|
ignore_oc ? ", overcurrent ignored" : "");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, INTR_MASK,
|
|
|
|
|
&ehci->regs->intr_enable); /* Turn On Interrupts */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-24 07:45:37 +08: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);
|
2007-01-17 00:59:45 +08:00
|
|
|
create_companion_file(ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static irqreturn_t ehci_irq (struct usb_hcd *hcd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2007-01-22 05:45:59 +08:00
|
|
|
u32 status, pcd_status = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
int bh;
|
|
|
|
|
|
|
|
|
|
spin_lock (&ehci->lock);
|
|
|
|
|
|
2006-12-15 03:54:08 +08:00
|
|
|
status = ehci_readl(ehci, &ehci->regs->status);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* e.g. cardbus physical eject */
|
|
|
|
|
if (status == ~(u32) 0) {
|
|
|
|
|
ehci_dbg (ehci, "device removed\n");
|
|
|
|
|
goto dead;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status &= INTR_MASK;
|
|
|
|
|
if (!status) { /* irq sharing? */
|
|
|
|
|
spin_unlock(&ehci->lock);
|
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* clear (just) interrupts */
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, status, &ehci->regs->status);
|
|
|
|
|
ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
|
2005-04-17 06:20:36 +08:00
|
|
|
bh = 0;
|
|
|
|
|
|
|
|
|
|
#ifdef EHCI_VERBOSE_DEBUG
|
|
|
|
|
/* 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) {
|
|
|
|
|
COUNT (ehci->stats.reclaim);
|
2006-10-18 04:57:18 +08:00
|
|
|
ehci->reclaim_ready = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
bh = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* remote wakeup [4.3.1] */
|
2005-12-23 09:05:18 +08:00
|
|
|
if (status & STS_PCD) {
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned i = HCS_N_PORTS (ehci->hcs_params);
|
2007-01-22 05:45:59 +08:00
|
|
|
pcd_status = status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* resume root hub? */
|
2006-12-15 03:54:08 +08:00
|
|
|
if (!(ehci_readl(ehci, &ehci->regs->command) & CMD_RUN))
|
2006-11-10 03:42:16 +08:00
|
|
|
usb_hcd_resume_root_hub(hcd);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
while (i--) {
|
2006-12-15 03:54:08 +08:00
|
|
|
int pstatus = ehci_readl(ehci,
|
|
|
|
|
&ehci->regs->port_status [i]);
|
2006-06-30 17:34:42 +08:00
|
|
|
|
|
|
|
|
if (pstatus & PORT_OWNER)
|
2005-04-17 06:20:36 +08:00
|
|
|
continue;
|
2006-06-30 17:34:42 +08:00
|
|
|
if (!(pstatus & PORT_RESUME)
|
2005-04-17 06:20:36 +08:00
|
|
|
|| ehci->reset_done [i] != 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* start 20 msec resume signaling from this port,
|
|
|
|
|
* and make khubd collect PORT_STAT_C_SUSPEND to
|
|
|
|
|
* stop that signaling.
|
|
|
|
|
*/
|
|
|
|
|
ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
|
|
|
|
|
ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
|
2007-04-09 23:52:31 +08:00
|
|
|
mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* PCI errors [4.15.2.4] */
|
|
|
|
|
if (unlikely ((status & STS_FATAL) != 0)) {
|
|
|
|
|
/* bogus "fatal" IRQs appear on some chips... why? */
|
2006-12-15 03:54:08 +08:00
|
|
|
status = ehci_readl(ehci, &ehci->regs->status);
|
|
|
|
|
dbg_cmd (ehci, "fatal", ehci_readl(ehci,
|
|
|
|
|
&ehci->regs->command));
|
2005-04-17 06:20:36 +08:00
|
|
|
dbg_status (ehci, "fatal", status);
|
|
|
|
|
if (status & STS_HALT) {
|
|
|
|
|
ehci_err (ehci, "fatal error\n");
|
|
|
|
|
dead:
|
|
|
|
|
ehci_reset (ehci);
|
2006-12-15 03:54:08 +08:00
|
|
|
ehci_writel(ehci, 0, &ehci->regs->configured_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* generic layer kills/unlinks all urbs, then
|
|
|
|
|
* uses ehci_stop to clean up the rest
|
|
|
|
|
*/
|
|
|
|
|
bh = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
ehci_work (ehci);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock (&ehci->lock);
|
2007-01-22 05:45:59 +08:00
|
|
|
if (pcd_status & STS_PCD)
|
|
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-04-17 06:20:36 +08: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 15:21:58 +08:00
|
|
|
gfp_t mem_flags
|
2005-04-17 06:20:36 +08:00
|
|
|
) {
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
struct list_head qtd_list;
|
|
|
|
|
|
|
|
|
|
INIT_LIST_HEAD (&qtd_list);
|
|
|
|
|
|
|
|
|
|
switch (usb_pipetype (urb->pipe)) {
|
|
|
|
|
// case PIPE_CONTROL:
|
|
|
|
|
// case PIPE_BULK:
|
|
|
|
|
default:
|
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
|
return -ENOMEM;
|
2007-08-08 23:48:02 +08:00
|
|
|
return submit_async(ehci, urb, &qtd_list, mem_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
|
if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
|
|
|
|
|
return -ENOMEM;
|
2007-08-08 23:48:02 +08:00
|
|
|
return intr_submit(ehci, urb, &qtd_list, mem_flags);
|
2005-04-17 06:20:36 +08: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)
|
|
|
|
|
{
|
2006-10-18 04:57:18 +08:00
|
|
|
/* if we need to use IAA and it's busy, defer */
|
|
|
|
|
if (qh->qh_state == QH_STATE_LINKED
|
|
|
|
|
&& ehci->reclaim
|
|
|
|
|
&& HC_IS_RUNNING (ehci_to_hcd(ehci)->state)) {
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
|
|
2006-10-18 04:57:18 +08:00
|
|
|
/* bypass IAA if the hc can't care */
|
|
|
|
|
} else if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state) && ehci->reclaim)
|
|
|
|
|
end_unlink_async (ehci);
|
|
|
|
|
|
|
|
|
|
/* something else might have unlinked the qh by now */
|
|
|
|
|
if (qh->qh_state == QH_STATE_LINKED)
|
2005-04-17 06:20:36 +08:00
|
|
|
start_unlink_async (ehci, qh);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* remove from hardware lists
|
|
|
|
|
* completions normally happen asynchronously
|
|
|
|
|
*/
|
|
|
|
|
|
2007-08-08 23:48:02 +08:00
|
|
|
static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
|
|
|
|
struct ehci_qh *qh;
|
|
|
|
|
unsigned long flags;
|
2007-08-08 23:48:02 +08:00
|
|
|
int rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
spin_lock_irqsave (&ehci->lock, flags);
|
2007-08-08 23:48:02 +08:00
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto done;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (usb_pipetype (urb->pipe)) {
|
|
|
|
|
// case PIPE_CONTROL:
|
|
|
|
|
// case PIPE_BULK:
|
|
|
|
|
default:
|
|
|
|
|
qh = (struct ehci_qh *) urb->hcpriv;
|
|
|
|
|
if (!qh)
|
|
|
|
|
break;
|
2006-10-18 04:57:18 +08:00
|
|
|
unlink_async (ehci, qh);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
|
qh = (struct ehci_qh *) urb->hcpriv;
|
|
|
|
|
if (!qh)
|
|
|
|
|
break;
|
|
|
|
|
switch (qh->qh_state) {
|
|
|
|
|
case QH_STATE_LINKED:
|
|
|
|
|
intr_deschedule (ehci, qh);
|
|
|
|
|
/* FALL THROUGH */
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
qh_completions (ehci, qh);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ehci_dbg (ehci, "bogus qh %p state %d\n",
|
|
|
|
|
qh, qh->qh_state);
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* reschedule QH iff another request is queued */
|
|
|
|
|
if (!list_empty (&qh->qtd_list)
|
|
|
|
|
&& HC_IS_RUNNING (hcd->state)) {
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
status = qh_schedule (ehci, qh);
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
|
|
|
|
|
|
|
|
|
if (status != 0) {
|
|
|
|
|
// shouldn't happen often, but ...
|
|
|
|
|
// FIXME kill those tds' urbs
|
|
|
|
|
err ("can't reschedule qh %p, err %d",
|
|
|
|
|
qh, status);
|
|
|
|
|
}
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
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 23:48:02 +08:00
|
|
|
return rc;
|
2005-04-17 06:20:36 +08: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.
|
|
|
|
|
*/
|
|
|
|
|
if (qh->hw_info1 == 0) {
|
|
|
|
|
ehci_vdbg (ehci, "iso delay\n");
|
|
|
|
|
goto idle_timeout;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!HC_IS_RUNNING (hcd->state))
|
|
|
|
|
qh->qh_state = QH_STATE_IDLE;
|
|
|
|
|
switch (qh->qh_state) {
|
|
|
|
|
case QH_STATE_LINKED:
|
|
|
|
|
for (tmp = ehci->async->qh_next.qh;
|
|
|
|
|
tmp && tmp != qh;
|
|
|
|
|
tmp = tmp->qh_next.qh)
|
|
|
|
|
continue;
|
|
|
|
|
/* periodic qh self-unlinks on empty */
|
|
|
|
|
if (!tmp)
|
|
|
|
|
goto nogood;
|
|
|
|
|
unlink_async (ehci, qh);
|
|
|
|
|
/* FALL THROUGH */
|
|
|
|
|
case QH_STATE_UNLINK: /* wait for hw to finish? */
|
|
|
|
|
idle_timeout:
|
|
|
|
|
spin_unlock_irqrestore (&ehci->lock, flags);
|
2005-08-16 02:30:11 +08:00
|
|
|
schedule_timeout_uninterruptible(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto rescan;
|
|
|
|
|
case QH_STATE_IDLE: /* fully unlinked */
|
|
|
|
|
if (list_empty (&qh->qtd_list)) {
|
|
|
|
|
qh_put (qh);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* else FALL THROUGH */
|
|
|
|
|
default:
|
|
|
|
|
nogood:
|
|
|
|
|
/* 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);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
static int ehci_get_frame (struct usb_hcd *hcd)
|
|
|
|
|
{
|
|
|
|
|
struct ehci_hcd *ehci = hcd_to_ehci (hcd);
|
2006-12-15 03:54:08 +08:00
|
|
|
return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
|
|
|
|
|
ehci->periodic_size;
|
2005-09-23 13:31:15 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
#define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
|
|
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION (DRIVER_INFO);
|
|
|
|
|
MODULE_AUTHOR (DRIVER_AUTHOR);
|
|
|
|
|
MODULE_LICENSE ("GPL");
|
|
|
|
|
|
2005-09-23 13:31:15 +08:00
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
|
#include "ehci-pci.c"
|
2006-04-11 23:07:16 +08:00
|
|
|
#define PCI_DRIVER ehci_pci_driver
|
2005-09-23 13:31:15 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-11 17:09:55 +08:00
|
|
|
#ifdef CONFIG_USB_EHCI_FSL
|
2006-01-21 05:53:38 +08:00
|
|
|
#include "ehci-fsl.c"
|
2006-04-11 23:07:16 +08:00
|
|
|
#define PLATFORM_DRIVER ehci_fsl_driver
|
2006-01-21 05:53:38 +08:00
|
|
|
#endif
|
|
|
|
|
|
2006-06-04 06:58:55 +08:00
|
|
|
#ifdef CONFIG_SOC_AU1200
|
2006-01-21 06:06:09 +08:00
|
|
|
#include "ehci-au1xxx.c"
|
2006-04-11 23:07:16 +08:00
|
|
|
#define PLATFORM_DRIVER ehci_hcd_au1xxx_driver
|
2006-01-21 06:06:09 +08:00
|
|
|
#endif
|
|
|
|
|
|
2007-01-16 12:11:47 +08:00
|
|
|
#ifdef CONFIG_PPC_PS3
|
|
|
|
|
#include "ehci-ps3.c"
|
2007-06-06 11:04:35 +08:00
|
|
|
#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
|
2007-01-16 12:11:47 +08:00
|
|
|
#endif
|
|
|
|
|
|
2007-05-05 02:38:17 +08:00
|
|
|
#ifdef CONFIG_440EPX
|
|
|
|
|
#include "ehci-ppc-soc.c"
|
|
|
|
|
#define PLATFORM_DRIVER ehci_ppc_soc_driver
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-01-16 12:11:47 +08:00
|
|
|
#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
|
|
|
|
|
!defined(PS3_SYSTEM_BUS_DRIVER)
|
2005-09-23 13:31:15 +08:00
|
|
|
#error "missing bus glue for ehci-hcd"
|
|
|
|
|
#endif
|
2006-04-11 23:07:16 +08:00
|
|
|
|
|
|
|
|
static int __init ehci_hcd_init(void)
|
|
|
|
|
{
|
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
retval = platform_driver_register(&PLATFORM_DRIVER);
|
|
|
|
|
if (retval < 0)
|
|
|
|
|
return retval;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
|
retval = pci_register_driver(&PCI_DRIVER);
|
|
|
|
|
if (retval < 0) {
|
|
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
|
#endif
|
2007-01-16 12:11:47 +08:00
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 11:04:35 +08:00
|
|
|
retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
|
|
|
|
|
if (retval < 0) {
|
2007-01-16 12:11:47 +08:00
|
|
|
#ifdef PLATFORM_DRIVER
|
2007-06-06 11:04:35 +08:00
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
2007-01-16 12:11:47 +08:00
|
|
|
#endif
|
|
|
|
|
#ifdef PCI_DRIVER
|
2007-06-06 11:04:35 +08:00
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
2007-01-16 12:11:47 +08:00
|
|
|
#endif
|
2007-06-06 11:04:35 +08:00
|
|
|
return retval;
|
2006-04-11 23:07:16 +08:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
module_init(ehci_hcd_init);
|
|
|
|
|
|
|
|
|
|
static void __exit ehci_hcd_cleanup(void)
|
|
|
|
|
{
|
|
|
|
|
#ifdef PLATFORM_DRIVER
|
|
|
|
|
platform_driver_unregister(&PLATFORM_DRIVER);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef PCI_DRIVER
|
|
|
|
|
pci_unregister_driver(&PCI_DRIVER);
|
|
|
|
|
#endif
|
2007-01-16 12:11:47 +08:00
|
|
|
#ifdef PS3_SYSTEM_BUS_DRIVER
|
2007-06-06 11:04:35 +08:00
|
|
|
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
|
2007-01-16 12:11:47 +08:00
|
|
|
#endif
|
2006-04-11 23:07:16 +08:00
|
|
|
}
|
|
|
|
|
module_exit(ehci_hcd_cleanup);
|
|
|
|
|
|
