ehci-hcd.c 28.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
/*
 * Copyright (c) 2000-2004 by David Brownell
3
 *
Linus Torvalds's avatar
Linus Torvalds committed
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 * 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,
71
 *	clean up HC run state handshaking.
Linus Torvalds's avatar
Linus Torvalds committed
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 * 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 */

112
#define EHCI_IAA_JIFFIES	(HZ/100)	/* arbitrary; ~10 msec */
Linus Torvalds's avatar
Linus Torvalds committed
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#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");

127
128
129
130
131
/* 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");

Linus Torvalds's avatar
Linus Torvalds committed
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#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.
 */
158
159
static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
		      u32 mask, u32 done, int usec)
Linus Torvalds's avatar
Linus Torvalds committed
160
161
162
163
{
	u32	result;

	do {
164
		result = ehci_readl(ehci, ptr);
Linus Torvalds's avatar
Linus Torvalds committed
165
166
167
168
169
170
171
172
173
174
175
176
177
178
		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)
{
179
	u32	temp = ehci_readl(ehci, &ehci->regs->status);
Linus Torvalds's avatar
Linus Torvalds committed
180

181
	/* disable any irqs left enabled by previous code */
182
	ehci_writel(ehci, 0, &ehci->regs->intr_enable);
183

Linus Torvalds's avatar
Linus Torvalds committed
184
185
186
	if ((temp & STS_HALT) != 0)
		return 0;

187
	temp = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds's avatar
Linus Torvalds committed
188
	temp &= ~CMD_RUN;
189
190
191
	ehci_writel(ehci, temp, &ehci->regs->command);
	return handshake (ehci, &ehci->regs->status,
			  STS_HALT, STS_HALT, 16 * 125);
Linus Torvalds's avatar
Linus Torvalds committed
192
193
194
195
196
197
198
199
}

/* put TDI/ARC silicon into EHCI mode */
static void tdi_reset (struct ehci_hcd *ehci)
{
	u32 __iomem	*reg_ptr;
	u32		tmp;

200
	reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
201
	tmp = ehci_readl(ehci, reg_ptr);
202
203
204
205
206
207
208
	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;
209
	ehci_writel(ehci, tmp, reg_ptr);
Linus Torvalds's avatar
Linus Torvalds committed
210
211
212
213
214
215
}

/* reset a non-running (STS_HALT == 1) controller */
static int ehci_reset (struct ehci_hcd *ehci)
{
	int	retval;
216
	u32	command = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds's avatar
Linus Torvalds committed
217
218
219

	command |= CMD_RESET;
	dbg_cmd (ehci, "reset", command);
220
	ehci_writel(ehci, command, &ehci->regs->command);
Linus Torvalds's avatar
Linus Torvalds committed
221
222
	ehci_to_hcd(ehci)->state = HC_STATE_HALT;
	ehci->next_statechange = jiffies;
223
224
	retval = handshake (ehci, &ehci->regs->command,
			    CMD_RESET, 0, 250 * 1000);
Linus Torvalds's avatar
Linus Torvalds committed
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

	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 */
246
	temp = ehci_readl(ehci, &ehci->regs->command) << 10;
Linus Torvalds's avatar
Linus Torvalds committed
247
	temp &= STS_ASS | STS_PSS;
248
	if (handshake (ehci, &ehci->regs->status, STS_ASS | STS_PSS,
Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
252
253
254
				temp, 16 * 125) != 0) {
		ehci_to_hcd(ehci)->state = HC_STATE_HALT;
		return;
	}

	/* then disable anything that's still active */
255
	temp = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds's avatar
Linus Torvalds committed
256
	temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
257
	ehci_writel(ehci, temp, &ehci->regs->command);
Linus Torvalds's avatar
Linus Torvalds committed
258
259

	/* hardware can take 16 microframes to turn off ... */
260
	if (handshake (ehci, &ehci->regs->status, STS_ASS | STS_PSS,
Linus Torvalds's avatar
Linus Torvalds committed
261
262
263
264
265
266
267
268
				0, 16 * 125) != 0) {
		ehci_to_hcd(ehci)->state = HC_STATE_HALT;
		return;
	}
}

/*-------------------------------------------------------------------------*/

269
static void ehci_work(struct ehci_hcd *ehci);
Linus Torvalds's avatar
Linus Torvalds committed
270
271
272
273
274
275
276
277

#include "ehci-hub.c"
#include "ehci-mem.c"
#include "ehci-q.c"
#include "ehci-sched.c"

/*-------------------------------------------------------------------------*/

278
static void ehci_watchdog (unsigned long param)
Linus Torvalds's avatar
Linus Torvalds committed
279
280
281
282
283
284
{
	struct ehci_hcd		*ehci = (struct ehci_hcd *) param;
	unsigned long		flags;

	spin_lock_irqsave (&ehci->lock, flags);

285
	/* lost IAA irqs wedge things badly; seen with a vt8235 */
Linus Torvalds's avatar
Linus Torvalds committed
286
	if (ehci->reclaim) {
287
		u32		status = ehci_readl(ehci, &ehci->regs->status);
Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
		if (status & STS_IAA) {
			ehci_vdbg (ehci, "lost IAA\n");
			COUNT (ehci->stats.lost_iaa);
291
			ehci_writel(ehci, STS_IAA, &ehci->regs->status);
292
			ehci->reclaim_ready = 1;
Linus Torvalds's avatar
Linus Torvalds committed
293
294
295
		}
	}

296
 	/* stop async processing after it's idled a bit */
Linus Torvalds's avatar
Linus Torvalds committed
297
	if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
298
		start_unlink_async (ehci, ehci->async);
Linus Torvalds's avatar
Linus Torvalds committed
299
300

	/* ehci could run by timer, without IRQs ... */
301
	ehci_work (ehci);
Linus Torvalds's avatar
Linus Torvalds committed
302
303
304
305

	spin_unlock_irqrestore (&ehci->lock, flags);
}

306
307
308
309
310
311
312
313
314
315
316
317
318
/* 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]);
}

319
/* ehci_shutdown kick in for silicon on any bus (not just pci, etc).
320
321
322
 * This forcibly disables dma and IRQs, helping kexec and other cases
 * where the next system software may expect clean state.
 */
323
324
static void
ehci_shutdown (struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
325
{
326
	struct ehci_hcd	*ehci;
Linus Torvalds's avatar
Linus Torvalds committed
327

328
	ehci = hcd_to_ehci (hcd);
329
	(void) ehci_halt (ehci);
330
	ehci_turn_off_all_ports(ehci);
Linus Torvalds's avatar
Linus Torvalds committed
331
332

	/* make BIOS/etc use companion controller during reboot */
333
	ehci_writel(ehci, 0, &ehci->regs->configured_flag);
334
335
336

	/* unblock posted writes */
	ehci_readl(ehci, &ehci->regs->configured_flag);
Linus Torvalds's avatar
Linus Torvalds committed
337
338
}

David Brownell's avatar
David Brownell committed
339
340
341
342
343
344
345
346
347
348
349
350
351
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);
Alan Stern's avatar
Alan Stern committed
352
353
	/* Flush those writes */
	ehci_readl(ehci, &ehci->regs->command);
David Brownell's avatar
David Brownell committed
354
355
356
	msleep(20);
}

Matt Porter's avatar
Matt Porter committed
357
/*-------------------------------------------------------------------------*/
Linus Torvalds's avatar
Linus Torvalds committed
358

Matt Porter's avatar
Matt Porter committed
359
360
361
362
/*
 * ehci_work is called from some interrupts, timers, and so on.
 * it calls driver completion functions, after dropping ehci->lock.
 */
363
static void ehci_work (struct ehci_hcd *ehci)
Matt Porter's avatar
Matt Porter committed
364
365
{
	timer_action_done (ehci, TIMER_IO_WATCHDOG);
366
367
	if (ehci->reclaim_ready)
		end_unlink_async (ehci);
Matt Porter's avatar
Matt Porter committed
368
369
370
371
372
373
374
375

	/* 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;
376
	scan_async (ehci);
Matt Porter's avatar
Matt Porter committed
377
	if (ehci->next_uframe != -1)
378
		scan_periodic (ehci);
Matt Porter's avatar
Matt Porter committed
379
380
381
382
383
384
385
386
387
388
389
	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);
}
Linus Torvalds's avatar
Linus Torvalds committed
390

Matt Porter's avatar
Matt Porter committed
391
static void ehci_stop (struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
392
393
394
{
	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);

Matt Porter's avatar
Matt Porter committed
395
	ehci_dbg (ehci, "stop\n");
Linus Torvalds's avatar
Linus Torvalds committed
396

Matt Porter's avatar
Matt Porter committed
397
398
	/* Turn off port power on all root hub ports. */
	ehci_port_power (ehci, 0);
Linus Torvalds's avatar
Linus Torvalds committed
399

Matt Porter's avatar
Matt Porter committed
400
401
	/* no more interrupts ... */
	del_timer_sync (&ehci->watchdog);
David Brownell's avatar
David Brownell committed
402

Matt Porter's avatar
Matt Porter committed
403
404
405
	spin_lock_irq(&ehci->lock);
	if (HC_IS_RUNNING (hcd->state))
		ehci_quiesce (ehci);
Linus Torvalds's avatar
Linus Torvalds committed
406

Matt Porter's avatar
Matt Porter committed
407
	ehci_reset (ehci);
408
	ehci_writel(ehci, 0, &ehci->regs->intr_enable);
Matt Porter's avatar
Matt Porter committed
409
	spin_unlock_irq(&ehci->lock);
Linus Torvalds's avatar
Linus Torvalds committed
410

Matt Porter's avatar
Matt Porter committed
411
	/* let companion controllers work when we aren't */
412
	ehci_writel(ehci, 0, &ehci->regs->configured_flag);
David Brownell's avatar
David Brownell committed
413

414
	remove_companion_file(ehci);
Matt Porter's avatar
Matt Porter committed
415
	remove_debug_files (ehci);
Linus Torvalds's avatar
Linus Torvalds committed
416

Matt Porter's avatar
Matt Porter committed
417
418
419
	/* root hub is shut down separately (first, when possible) */
	spin_lock_irq (&ehci->lock);
	if (ehci->async)
420
		ehci_work (ehci);
Matt Porter's avatar
Matt Porter committed
421
422
	spin_unlock_irq (&ehci->lock);
	ehci_mem_cleanup (ehci);
Linus Torvalds's avatar
Linus Torvalds committed
423

Matt Porter's avatar
Matt Porter committed
424
425
426
427
428
429
#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);
Linus Torvalds's avatar
Linus Torvalds committed
430
431
#endif

432
433
	dbg_status (ehci, "ehci_stop completed",
		    ehci_readl(ehci, &ehci->regs->status));
Linus Torvalds's avatar
Linus Torvalds committed
434
435
}

436
437
/* one-time init, only for memory state */
static int ehci_init(struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
438
{
439
	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
440
441
442
	u32			temp;
	int			retval;
	u32			hcc_params;
443
444
445
446
447
448

	spin_lock_init(&ehci->lock);

	init_timer(&ehci->watchdog);
	ehci->watchdog.function = ehci_watchdog;
	ehci->watchdog.data = (unsigned long) ehci;
Linus Torvalds's avatar
Linus Torvalds committed
449
450
451
452
453
454

	/*
	 * 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;
455
	if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
456
457
458
		return retval;

	/* controllers may cache some of the periodic schedule ... */
459
	hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
460
	if (HCC_ISOC_CACHE(hcc_params))		// full frame cache
Linus Torvalds's avatar
Linus Torvalds committed
461
462
		ehci->i_thresh = 8;
	else					// N microframes cached
463
		ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
Linus Torvalds's avatar
Linus Torvalds committed
464
465

	ehci->reclaim = NULL;
466
	ehci->reclaim_ready = 0;
Linus Torvalds's avatar
Linus Torvalds committed
467
468
469
470
471
472
473
474
475
	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.
	 */
476
	ehci->async->qh_next.qh = NULL;
477
478
479
480
	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);
481
	ehci->async->qh_state = QH_STATE_LINKED;
482
	ehci->async->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
Linus Torvalds's avatar
Linus Torvalds committed
483
484
485
486
487
488
489
490
491
492
493
494
495
496

	/* 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) {
497
			park = min(park, (unsigned) 3);
Linus Torvalds's avatar
Linus Torvalds committed
498
499
500
			temp |= CMD_PARK;
			temp |= park << 8;
		}
501
		ehci_dbg(ehci, "park %d\n", park);
Linus Torvalds's avatar
Linus Torvalds committed
502
	}
503
	if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
Linus Torvalds's avatar
Linus Torvalds committed
504
505
506
507
508
509
510
		/* 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;
511
		default:	BUG();
Linus Torvalds's avatar
Linus Torvalds committed
512
513
		}
	}
514
515
516
517
518
519
520
521
522
523
524
525
526
	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;

527
528
529
	hcd->uses_new_polling = 1;
	hcd->poll_rh = 0;

530
531
532
533
534
	/* EHCI spec section 4.1 */
	if ((retval = ehci_reset(ehci)) != 0) {
		ehci_mem_cleanup(ehci);
		return retval;
	}
535
536
	ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
	ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
537
538
539
540
541
542
543
544
545
546
547
548
549

	/*
	 * 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.
	 */
550
	hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
551
	if (HCC_64BIT_ADDR(hcc_params)) {
552
		ehci_writel(ehci, 0, &ehci->regs->segment);
553
554
555
556
557
558
559
560
#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
	}


Linus Torvalds's avatar
Linus Torvalds committed
561
562
	// Philips, Intel, and maybe others need CMD_RUN before the
	// root hub will detect new devices (why?); NEC doesn't
563
564
	ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
	ehci->command |= CMD_RUN;
565
	ehci_writel(ehci, ehci->command, &ehci->regs->command);
566
	dbg_cmd (ehci, "init", ehci->command);
Linus Torvalds's avatar
Linus Torvalds committed
567
568
569
570
571
572

	/*
	 * 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.)
573
574
575
576
577
578
	 *
	 * 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
	 * guarantees that no resets are in progress.
Linus Torvalds's avatar
Linus Torvalds committed
579
	 */
580
	down_write(&ehci_cf_port_reset_rwsem);
Linus Torvalds's avatar
Linus Torvalds committed
581
	hcd->state = HC_STATE_RUNNING;
582
583
	ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
	ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */
584
	up_write(&ehci_cf_port_reset_rwsem);
Linus Torvalds's avatar
Linus Torvalds committed
585

586
	temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
Linus Torvalds's avatar
Linus Torvalds committed
587
	ehci_info (ehci,
588
		"USB %x.%x started, EHCI %x.%02x, driver %s%s\n",
Matt Porter's avatar
Matt Porter committed
589
		((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
590
591
		temp >> 8, temp & 0xff, DRIVER_VERSION,
		ignore_oc ? ", overcurrent ignored" : "");
Linus Torvalds's avatar
Linus Torvalds committed
592

593
594
	ehci_writel(ehci, INTR_MASK,
		    &ehci->regs->intr_enable); /* Turn On Interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
595

596
597
598
599
600
	/* 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);
601
	create_companion_file(ehci);
Linus Torvalds's avatar
Linus Torvalds committed
602
603
604
605
606
607

	return 0;
}

/*-------------------------------------------------------------------------*/

608
static irqreturn_t ehci_irq (struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
609
610
{
	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
611
	u32			status, pcd_status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
612
613
614
615
	int			bh;

	spin_lock (&ehci->lock);

616
	status = ehci_readl(ehci, &ehci->regs->status);
Linus Torvalds's avatar
Linus Torvalds committed
617
618
619
620
621
622
623
624
625
626
627
628
629
630

	/* 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 */
631
632
	ehci_writel(ehci, status, &ehci->regs->status);
	ehci_readl(ehci, &ehci->regs->command);	/* unblock posted write */
Linus Torvalds's avatar
Linus Torvalds committed
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
	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);
654
		ehci->reclaim_ready = 1;
Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
658
		bh = 1;
	}

	/* remote wakeup [4.3.1] */
659
	if (status & STS_PCD) {
Linus Torvalds's avatar
Linus Torvalds committed
660
		unsigned	i = HCS_N_PORTS (ehci->hcs_params);
661
		pcd_status = status;
Linus Torvalds's avatar
Linus Torvalds committed
662
663

		/* resume root hub? */
664
		if (!(ehci_readl(ehci, &ehci->regs->command) & CMD_RUN))
665
			usb_hcd_resume_root_hub(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
666
667

		while (i--) {
668
669
			int pstatus = ehci_readl(ehci,
						 &ehci->regs->port_status [i]);
670
671

			if (pstatus & PORT_OWNER)
Linus Torvalds's avatar
Linus Torvalds committed
672
				continue;
673
			if (!(pstatus & PORT_RESUME)
Linus Torvalds's avatar
Linus Torvalds committed
674
675
676
677
678
679
680
681
682
					|| 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);
683
			mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
Linus Torvalds's avatar
Linus Torvalds committed
684
685
686
687
688
689
		}
	}

	/* PCI errors [4.15.2.4] */
	if (unlikely ((status & STS_FATAL) != 0)) {
		/* bogus "fatal" IRQs appear on some chips... why?  */
690
691
692
		status = ehci_readl(ehci, &ehci->regs->status);
		dbg_cmd (ehci, "fatal", ehci_readl(ehci,
						   &ehci->regs->command));
Linus Torvalds's avatar
Linus Torvalds committed
693
694
695
696
697
		dbg_status (ehci, "fatal", status);
		if (status & STS_HALT) {
			ehci_err (ehci, "fatal error\n");
dead:
			ehci_reset (ehci);
698
			ehci_writel(ehci, 0, &ehci->regs->configured_flag);
Linus Torvalds's avatar
Linus Torvalds committed
699
700
701
702
703
704
705
706
			/* generic layer kills/unlinks all urbs, then
			 * uses ehci_stop to clean up the rest
			 */
			bh = 1;
		}
	}

	if (bh)
707
		ehci_work (ehci);
Linus Torvalds's avatar
Linus Torvalds committed
708
	spin_unlock (&ehci->lock);
709
710
	if (pcd_status & STS_PCD)
		usb_hcd_poll_rh_status(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
	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,
Al Viro's avatar
Al Viro committed
731
	gfp_t		mem_flags
Linus Torvalds's avatar
Linus Torvalds committed
732
733
734
735
736
737
738
739
740
741
742
743
) {
	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;
744
		return submit_async(ehci, urb, &qtd_list, mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
745
746
747
748

	case PIPE_INTERRUPT:
		if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
			return -ENOMEM;
749
		return intr_submit(ehci, urb, &qtd_list, mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
750
751
752
753
754
755
756
757
758
759
760

	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)
{
761
762
763
764
	/* 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)) {
Linus Torvalds's avatar
Linus Torvalds committed
765
766
767
768
769
770
771
772
773
		struct ehci_qh		*last;

		for (last = ehci->reclaim;
				last->reclaim;
				last = last->reclaim)
			continue;
		qh->qh_state = QH_STATE_UNLINK_WAIT;
		last->reclaim = qh;

774
775
776
777
778
779
	/* 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)
Linus Torvalds's avatar
Linus Torvalds committed
780
781
782
783
784
785
786
		start_unlink_async (ehci, qh);
}

/* remove from hardware lists
 * completions normally happen asynchronously
 */

787
static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Linus Torvalds's avatar
Linus Torvalds committed
788
789
790
791
{
	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
	struct ehci_qh		*qh;
	unsigned long		flags;
792
	int			rc;
Linus Torvalds's avatar
Linus Torvalds committed
793
794

	spin_lock_irqsave (&ehci->lock, flags);
795
796
797
798
	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
	if (rc)
		goto done;

Linus Torvalds's avatar
Linus Torvalds committed
799
800
801
802
803
804
805
	switch (usb_pipetype (urb->pipe)) {
	// case PIPE_CONTROL:
	// case PIPE_BULK:
	default:
		qh = (struct ehci_qh *) urb->hcpriv;
		if (!qh)
			break;
806
		unlink_async (ehci, qh);
Linus Torvalds's avatar
Linus Torvalds committed
807
808
809
810
811
812
813
814
815
816
817
		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:
818
			qh_completions (ehci, qh);
Linus Torvalds's avatar
Linus Torvalds committed
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
			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);
853
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
}

/*-------------------------------------------------------------------------*/

// 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);
900
		schedule_timeout_uninterruptible(1);
Linus Torvalds's avatar
Linus Torvalds committed
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
		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;
}

Matt Porter's avatar
Matt Porter committed
924
925
926
static int ehci_get_frame (struct usb_hcd *hcd)
{
	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
927
928
	return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
		ehci->periodic_size;
Matt Porter's avatar
Matt Porter committed
929
}
Linus Torvalds's avatar
Linus Torvalds committed
930
931
932
933
934
935
936
937
938

/*-------------------------------------------------------------------------*/

#define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC

MODULE_DESCRIPTION (DRIVER_INFO);
MODULE_AUTHOR (DRIVER_AUTHOR);
MODULE_LICENSE ("GPL");

Matt Porter's avatar
Matt Porter committed
939
940
#ifdef CONFIG_PCI
#include "ehci-pci.c"
941
#define	PCI_DRIVER		ehci_pci_driver
Matt Porter's avatar
Matt Porter committed
942
#endif
Linus Torvalds's avatar
Linus Torvalds committed
943

944
#ifdef CONFIG_USB_EHCI_FSL
945
#include "ehci-fsl.c"
946
#define	PLATFORM_DRIVER		ehci_fsl_driver
947
948
#endif

949
#ifdef CONFIG_SOC_AU1200
Jordan Crouse's avatar
Jordan Crouse committed
950
#include "ehci-au1xxx.c"
951
#define	PLATFORM_DRIVER		ehci_hcd_au1xxx_driver
Jordan Crouse's avatar
Jordan Crouse committed
952
953
#endif

Geoff Levand's avatar
Geoff Levand committed
954
955
#ifdef CONFIG_PPC_PS3
#include "ehci-ps3.c"
Geoff Levand's avatar
Geoff Levand committed
956
#define	PS3_SYSTEM_BUS_DRIVER	ps3_ehci_driver
Geoff Levand's avatar
Geoff Levand committed
957
958
#endif

959
960
961
962
963
#ifdef CONFIG_440EPX
#include "ehci-ppc-soc.c"
#define	PLATFORM_DRIVER		ehci_ppc_soc_driver
#endif

Geoff Levand's avatar
Geoff Levand committed
964
965
#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
    !defined(PS3_SYSTEM_BUS_DRIVER)
Matt Porter's avatar
Matt Porter committed
966
967
#error "missing bus glue for ehci-hcd"
#endif
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989

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
Geoff Levand's avatar
Geoff Levand committed
990
991
992
993
994
		return retval;
	}
#endif

#ifdef PS3_SYSTEM_BUS_DRIVER
Geoff Levand's avatar
Geoff Levand committed
995
996
	retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
	if (retval < 0) {
Geoff Levand's avatar
Geoff Levand committed
997
#ifdef PLATFORM_DRIVER
Geoff Levand's avatar
Geoff Levand committed
998
		platform_driver_unregister(&PLATFORM_DRIVER);
Geoff Levand's avatar
Geoff Levand committed
999
1000
#endif
#ifdef PCI_DRIVER
Geoff Levand's avatar
Geoff Levand committed
1001
		pci_unregister_driver(&PCI_DRIVER);
Geoff Levand's avatar
Geoff Levand committed
1002
#endif
Geoff Levand's avatar
Geoff Levand committed
1003
		return retval;
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
	}
#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
Geoff Levand's avatar
Geoff Levand committed
1019
#ifdef PS3_SYSTEM_BUS_DRIVER
Geoff Levand's avatar
Geoff Levand committed
1020
	ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
Geoff Levand's avatar
Geoff Levand committed
1021
#endif
1022
1023
1024
}
module_exit(ehci_hcd_cleanup);