uhci-hcd.c 25.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
 * Universal Host Controller Interface driver for USB.
 *
 * Maintainer: Alan Stern <stern@rowland.harvard.edu>
 *
 * (C) Copyright 1999 Linus Torvalds
 * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
 * (C) Copyright 1999 Randy Dunlap
 * (C) Copyright 1999 Georg Acher, acher@in.tum.de
 * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
 * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
 * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
 * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
 *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
 * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
16
 * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
Linus Torvalds's avatar
Linus Torvalds committed
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 *
 * Intel documents this fairly well, and as far as I know there
 * are no royalties or anything like that, but even so there are
 * people who decided that they want to do the same thing in a
 * completely different way.
 *
 */

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/debugfs.h>
#include <linux/pm.h>
#include <linux/dmapool.h>
#include <linux/dma-mapping.h>
#include <linux/usb.h>
41
#include <linux/usb/hcd.h>
Linus Torvalds's avatar
Linus Torvalds committed
42
#include <linux/bitops.h>
43
#include <linux/dmi.h>
Linus Torvalds's avatar
Linus Torvalds committed
44
45
46
47
48
49
50
51
52
53

#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/irq.h>

#include "uhci-hcd.h"

/*
 * Version Information
 */
54
55
56
57
#define DRIVER_AUTHOR							\
	"Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, "		\
	"Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, "	\
	"Roman Weissgaerber, Alan Stern"
Linus Torvalds's avatar
Linus Torvalds committed
58
59
#define DRIVER_DESC "USB Universal Host Controller Interface driver"

60
/* for flakey hardware, ignore overcurrent indicators */
61
static bool ignore_oc;
62
63
64
module_param(ignore_oc, bool, S_IRUGO);
MODULE_PARM_DESC(ignore_oc, "ignore hardware overcurrent indications");

Linus Torvalds's avatar
Linus Torvalds committed
65
66
/*
 * debug = 0, no debugging messages
67
68
 * debug = 1, dump failed URBs except for stalls
 * debug = 2, dump all failed URBs (including stalls)
69
 *            show all queues in /sys/kernel/debug/uhci/[pci_addr]
70
 * debug = 3, show all TDs in URBs when dumping
Linus Torvalds's avatar
Linus Torvalds committed
71
72
 */
#ifdef DEBUG
73
#define DEBUG_CONFIGURED	1
Linus Torvalds's avatar
Linus Torvalds committed
74
75
76
static int debug = 1;
module_param(debug, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug level");
77
78
79
80
81
82

#else
#define DEBUG_CONFIGURED	0
#define debug			0
#endif

Linus Torvalds's avatar
Linus Torvalds committed
83
84
85
static char *errbuf;
#define ERRBUF_LEN    (32 * 1024)

86
static struct kmem_cache *uhci_up_cachep;	/* urb_priv */
Linus Torvalds's avatar
Linus Torvalds committed
87

88
89
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
static void wakeup_rh(struct uhci_hcd *uhci);
Linus Torvalds's avatar
Linus Torvalds committed
90
91
static void uhci_get_current_frame_number(struct uhci_hcd *uhci);

92
93
94
/*
 * Calculate the link pointer DMA value for the first Skeleton QH in a frame.
 */
95
static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
96
97
98
99
100
101
102
103
104
105
106
107
{
	int skelnum;

	/*
	 * The interrupt queues will be interleaved as evenly as possible.
	 * There's not much to be done about period-1 interrupts; they have
	 * to occur in every frame.  But we can schedule period-2 interrupts
	 * in odd-numbered frames, period-4 interrupts in frames congruent
	 * to 2 (mod 4), and so on.  This way each frame only has two
	 * interrupt QHs, which will help spread out bandwidth utilization.
	 *
	 * ffs (Find First bit Set) does exactly what we need:
108
109
	 * 1,3,5,...  => ffs = 0 => use period-2 QH = skelqh[8],
	 * 2,6,10,... => ffs = 1 => use period-4 QH = skelqh[7], etc.
110
	 * ffs >= 7 => not on any high-period queue, so use
111
	 *	period-1 QH = skelqh[9].
112
113
114
115
116
	 * Add in UHCI_NUMFRAMES to insure at least one bit is set.
	 */
	skelnum = 8 - (int) __ffs(frame | UHCI_NUMFRAMES);
	if (skelnum <= 1)
		skelnum = 9;
117
	return LINK_TO_QH(uhci, uhci->skelqh[skelnum]);
118
119
}

Linus Torvalds's avatar
Linus Torvalds committed
120
121
#include "uhci-debug.c"
#include "uhci-q.c"
122
#include "uhci-hub.c"
Linus Torvalds's avatar
Linus Torvalds committed
123

124
/*
125
 * Finish up a host controller reset and update the recorded state.
126
 */
127
static void finish_reset(struct uhci_hcd *uhci)
Linus Torvalds's avatar
Linus Torvalds committed
128
{
129
130
131
132
133
134
135
	int port;

	/* HCRESET doesn't affect the Suspend, Reset, and Resume Detect
	 * bits in the port status and control registers.
	 * We have to clear them by hand.
	 */
	for (port = 0; port < uhci->rh_numports; ++port)
136
		uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
137

138
	uhci->port_c_suspend = uhci->resuming_ports = 0;
139
	uhci->rh_state = UHCI_RH_RESET;
140
	uhci->is_stopped = UHCI_IS_STOPPED;
141
	clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
Linus Torvalds's avatar
Linus Torvalds committed
142
143
}

144
145
/*
 * Last rites for a defunct/nonfunctional controller
146
 * or one we don't want to use any more.
147
 */
148
static void uhci_hc_died(struct uhci_hcd *uhci)
149
{
150
	uhci_get_current_frame_number(uhci);
151
	uhci->reset_hc(uhci);
152
	finish_reset(uhci);
153
154
155
156
	uhci->dead = 1;

	/* The current frame may already be partway finished */
	++uhci->frame_number;
157
158
}

159
/*
David Brownell's avatar
David Brownell committed
160
161
162
 * Initialize a controller that was newly discovered or has lost power
 * or otherwise been reset while it was suspended.  In none of these cases
 * can we be sure of its previous state.
163
164
165
 */
static void check_and_reset_hc(struct uhci_hcd *uhci)
{
166
	if (uhci->check_and_reset_hc(uhci))
167
		finish_reset(uhci);
168
169
}

170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#if defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC)
/*
 * The two functions below are generic reset functions that are used on systems
 * that do not have keyboard and mouse legacy support. We assume that we are
 * running on such a system if CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC is defined.
 */

/*
 * Make sure the controller is completely inactive, unable to
 * generate interrupts or do DMA.
 */
static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
{
	/* Reset the HC - this will force us to get a
	 * new notification of any already connected
	 * ports due to the virtual disconnect that it
	 * implies.
	 */
	uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
	mb();
	udelay(5);
	if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
		dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");

	/* Just to be safe, disable interrupt requests and
	 * make sure the controller is stopped.
	 */
	uhci_writew(uhci, 0, USBINTR);
	uhci_writew(uhci, 0, USBCMD);
}

/*
 * Initialize a controller that was newly discovered or has just been
 * resumed.  In either case we can't be sure of its previous state.
 *
 * Returns: 1 if the controller was reset, 0 otherwise.
 */
static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
{
	unsigned int cmd, intr;

	/*
	 * When restarting a suspended controller, we expect all the
	 * settings to be the same as we left them:
	 *
	 *	Controller is stopped and configured with EGSM set;
	 *	No interrupts enabled except possibly Resume Detect.
	 *
	 * If any of these conditions are violated we do a complete reset.
	 */

	cmd = uhci_readw(uhci, USBCMD);
	if ((cmd & USBCMD_RS) || !(cmd & USBCMD_CF) || !(cmd & USBCMD_EGSM)) {
		dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
				__func__, cmd);
		goto reset_needed;
	}

	intr = uhci_readw(uhci, USBINTR);
	if (intr & (~USBINTR_RESUME)) {
		dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
				__func__, intr);
		goto reset_needed;
	}
	return 0;

reset_needed:
	dev_dbg(uhci_dev(uhci), "Performing full reset\n");
	uhci_generic_reset_hc(uhci);
	return 1;
}
#endif /* CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC */

243
244
245
246
247
248
/*
 * Store the basic register settings needed by the controller.
 */
static void configure_hc(struct uhci_hcd *uhci)
{
	/* Set the frame length to the default: 1 ms exactly */
249
	uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
250
251

	/* Store the frame list base address */
252
	uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
253
254

	/* Set the current frame number */
255
256
	uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
			USBFRNUM);
257

258
259
260
	/* perform any arch/bus specific configuration */
	if (uhci->configure_hc)
		uhci->configure_hc(uhci);
261
262
}

263
static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
Linus Torvalds's avatar
Linus Torvalds committed
264
{
265
266
267
268
269
	/* If we have to ignore overcurrent events then almost by definition
	 * we can't depend on resume-detect interrupts. */
	if (ignore_oc)
		return 1;

270
271
	return uhci->resume_detect_interrupts_are_broken ?
		uhci->resume_detect_interrupts_are_broken(uhci) : 0;
272
273
}

274
static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
275
{
276
277
	return uhci->global_suspend_mode_is_broken ?
		uhci->global_suspend_mode_is_broken(uhci) : 0;
278
279
}

280
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
281
282
283
284
__releases(uhci->lock)
__acquires(uhci->lock)
{
	int auto_stop;
285
	int int_enable, egsm_enable, wakeup_enable;
286
	struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
287
288

	auto_stop = (new_state == UHCI_RH_AUTO_STOPPED);
289
	dev_dbg(&rhdev->dev, "%s%s\n", __func__,
290
291
			(auto_stop ? " (auto-stop)" : ""));

292
293
	/* Start off by assuming Resume-Detect interrupts and EGSM work
	 * and that remote wakeups should be enabled.
294
	 */
295
	egsm_enable = USBCMD_EGSM;
296
	int_enable = USBINTR_RESUME;
297
298
	wakeup_enable = 1;

299
300
301
302
	/*
	 * In auto-stop mode, we must be able to detect new connections.
	 * The user can force us to poll by disabling remote wakeup;
	 * otherwise we will use the EGSM/RD mechanism.
303
304
305
	 */
	if (auto_stop) {
		if (!device_may_wakeup(&rhdev->dev))
306
307
			egsm_enable = int_enable = 0;
	}
308

309
#ifdef CONFIG_PM
310
311
312
313
314
	/*
	 * In bus-suspend mode, we use the wakeup setting specified
	 * for the root hub.
	 */
	else {
315
316
317
		if (!rhdev->do_remote_wakeup)
			wakeup_enable = 0;
	}
318
#endif
319

320
321
322
323
324
325
326
327
328
329
	/*
	 * UHCI doesn't distinguish between wakeup requests from downstream
	 * devices and local connect/disconnect events.  There's no way to
	 * enable one without the other; both are controlled by EGSM.  Thus
	 * if wakeups are disallowed then EGSM must be turned off -- in which
	 * case remote wakeup requests from downstream during system sleep
	 * will be lost.
	 *
	 * In addition, if EGSM is broken then we can't use it.  Likewise,
	 * if Resume-Detect interrupts are broken then we can't use them.
330
	 *
331
332
333
	 * Finally, neither EGSM nor RD is useful by itself.  Without EGSM,
	 * the RD status bit will never get set.  Without RD, the controller
	 * won't generate interrupts to tell the system about wakeup events.
334
	 */
335
336
337
	if (!wakeup_enable || global_suspend_mode_is_broken(uhci) ||
			resume_detect_interrupts_are_broken(uhci))
		egsm_enable = int_enable = 0;
338

339
	uhci->RD_enable = !!int_enable;
340
341
	uhci_writew(uhci, int_enable, USBINTR);
	uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
342
	mb();
343
344
345
346
347
348
349
	udelay(5);

	/* If we're auto-stopping then no devices have been attached
	 * for a while, so there shouldn't be any active URBs and the
	 * controller should stop after a few microseconds.  Otherwise
	 * we will give the controller one frame to stop.
	 */
350
	if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
351
352
353
354
		uhci->rh_state = UHCI_RH_SUSPENDING;
		spin_unlock_irq(&uhci->lock);
		msleep(1);
		spin_lock_irq(&uhci->lock);
355
		if (uhci->dead)
356
			return;
357
	}
358
	if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
359
		dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
Linus Torvalds's avatar
Linus Torvalds committed
360
361

	uhci_get_current_frame_number(uhci);
362
363

	uhci->rh_state = new_state;
Linus Torvalds's avatar
Linus Torvalds committed
364
	uhci->is_stopped = UHCI_IS_STOPPED;
365

366
367
368
369
	/*
	 * If remote wakeup is enabled but either EGSM or RD interrupts
	 * doesn't work, then we won't get an interrupt when a wakeup event
	 * occurs.  Thus the suspended root hub needs to be polled.
370
	 */
371
	if (wakeup_enable && (!int_enable || !egsm_enable))
372
373
374
		set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
	else
		clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
Linus Torvalds's avatar
Linus Torvalds committed
375

376
	uhci_scan_schedule(uhci);
Alan Stern's avatar
Alan Stern committed
377
	uhci_fsbr_off(uhci);
Linus Torvalds's avatar
Linus Torvalds committed
378
379
}

380
381
382
383
384
385
386
static void start_rh(struct uhci_hcd *uhci)
{
	uhci->is_stopped = 0;

	/* Mark it configured and running with a 64-byte max packet.
	 * All interrupts are enabled, even though RESUME won't do anything.
	 */
387
388
389
	uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
	uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
		USBINTR_IOC | USBINTR_SP, USBINTR);
390
	mb();
391
	uhci->rh_state = UHCI_RH_RUNNING;
392
	set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
393
394
395
}

static void wakeup_rh(struct uhci_hcd *uhci)
396
397
__releases(uhci->lock)
__acquires(uhci->lock)
Linus Torvalds's avatar
Linus Torvalds committed
398
{
David Brownell's avatar
David Brownell committed
399
	dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
400
			"%s%s\n", __func__,
401
402
			uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
				" (auto-start)" : "");
Linus Torvalds's avatar
Linus Torvalds committed
403

404
405
406
407
408
	/* If we are auto-stopped then no devices are attached so there's
	 * no need for wakeup signals.  Otherwise we send Global Resume
	 * for 20 ms.
	 */
	if (uhci->rh_state == UHCI_RH_SUSPENDED) {
409
410
411
		unsigned egsm;

		/* Keep EGSM on if it was set before */
412
		egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
413
		uhci->rh_state = UHCI_RH_RESUMING;
414
		uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
415
416
417
		spin_unlock_irq(&uhci->lock);
		msleep(20);
		spin_lock_irq(&uhci->lock);
418
		if (uhci->dead)
419
			return;
Linus Torvalds's avatar
Linus Torvalds committed
420

421
		/* End Global Resume and wait for EOP to be sent */
422
		uhci_writew(uhci, USBCMD_CF, USBCMD);
423
		mb();
424
		udelay(4);
425
		if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
426
427
			dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
	}
Linus Torvalds's avatar
Linus Torvalds committed
428

429
	start_rh(uhci);
430

431
432
	/* Restart root hub polling */
	mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
Linus Torvalds's avatar
Linus Torvalds committed
433
434
}

435
static irqreturn_t uhci_irq(struct usb_hcd *hcd)
436
437
438
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
439
440

	/*
441
442
443
	 * Read the interrupt status, and write it back to clear the
	 * interrupt cause.  Contrary to the UHCI specification, the
	 * "HC Halted" status bit is persistent: it is RO, not R/WC.
Linus Torvalds's avatar
Linus Torvalds committed
444
	 */
445
	status = uhci_readw(uhci, USBSTS);
446
447
	if (!(status & ~USBSTS_HCH))	/* shared interrupt, not mine */
		return IRQ_NONE;
448
	uhci_writew(uhci, status, USBSTS);		/* Clear it */
449

450
451
452
453
	spin_lock(&uhci->lock);
	if (unlikely(!uhci->is_initialized))	/* not yet configured */
		goto done;

454
455
456
457
458
459
460
	if (status & ~(USBSTS_USBINT | USBSTS_ERROR | USBSTS_RD)) {
		if (status & USBSTS_HSE)
			dev_err(uhci_dev(uhci), "host system error, "
					"PCI problems?\n");
		if (status & USBSTS_HCPE)
			dev_err(uhci_dev(uhci), "host controller process "
					"error, something bad happened!\n");
461
462
463
464
		if (status & USBSTS_HCH) {
			if (uhci->rh_state >= UHCI_RH_RUNNING) {
				dev_err(uhci_dev(uhci),
					"host controller halted, "
465
					"very bad!\n");
466
467
468
469
470
471
				if (debug > 1 && errbuf) {
					/* Print the schedule for debugging */
					uhci_sprint_schedule(uhci,
							errbuf, ERRBUF_LEN);
					lprintk(errbuf);
				}
472
				uhci_hc_died(uhci);
473
				usb_hc_died(hcd);
474
475
476
477

				/* Force a callback in case there are
				 * pending unlinks */
				mod_timer(&hcd->rh_timer, jiffies);
478
			}
Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
		}
	}

482
483
	if (status & USBSTS_RD) {
		spin_unlock(&uhci->lock);
484
		usb_hcd_poll_rh_status(hcd);
485
	} else {
486
		uhci_scan_schedule(uhci);
487
 done:
488
		spin_unlock(&uhci->lock);
489
	}
Linus Torvalds's avatar
Linus Torvalds committed
490

491
492
	return IRQ_HANDLED;
}
Linus Torvalds's avatar
Linus Torvalds committed
493

494
495
/*
 * Store the current frame number in uhci->frame_number if the controller
496
 * is running.  Expand from 11 bits (of which we use only 10) to a
497
498
499
500
 * full-sized integer.
 *
 * Like many other parts of the driver, this code relies on being polled
 * more than once per second as long as the controller is running.
501
502
503
 */
static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
{
504
505
506
	if (!uhci->is_stopped) {
		unsigned delta;

507
		delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
508
509
510
				(UHCI_NUMFRAMES - 1);
		uhci->frame_number += delta;
	}
Linus Torvalds's avatar
Linus Torvalds committed
511
512
513
514
515
516
517
518
519
}

/*
 * De-allocate all resources
 */
static void release_uhci(struct uhci_hcd *uhci)
{
	int i;

520
521
522
523
524
525
526
527
	if (DEBUG_CONFIGURED) {
		spin_lock_irq(&uhci->lock);
		uhci->is_initialized = 0;
		spin_unlock_irq(&uhci->lock);

		debugfs_remove(uhci->dentry);
	}

Linus Torvalds's avatar
Linus Torvalds committed
528
	for (i = 0; i < UHCI_NUM_SKELQH; i++)
529
		uhci_free_qh(uhci, uhci->skelqh[i]);
Linus Torvalds's avatar
Linus Torvalds committed
530

531
	uhci_free_td(uhci, uhci->term_td);
Linus Torvalds's avatar
Linus Torvalds committed
532

533
	dma_pool_destroy(uhci->qh_pool);
Linus Torvalds's avatar
Linus Torvalds committed
534

535
	dma_pool_destroy(uhci->td_pool);
Linus Torvalds's avatar
Linus Torvalds committed
536

537
538
539
540
541
	kfree(uhci->frame_cpu);

	dma_free_coherent(uhci_dev(uhci),
			UHCI_NUMFRAMES * sizeof(*uhci->frame),
			uhci->frame, uhci->frame_dma_handle);
Linus Torvalds's avatar
Linus Torvalds committed
542
543
544
545
546
547
548
}

/*
 * Allocate a frame list, and then setup the skeleton
 *
 * The hardware doesn't really know any difference
 * in the queues, but the order does matter for the
549
550
 * protocols higher up.  The order in which the queues
 * are encountered by the hardware is:
Linus Torvalds's avatar
Linus Torvalds committed
551
 *
552
 *  - All isochronous events are handled before any
Linus Torvalds's avatar
Linus Torvalds committed
553
554
 *    of the queues. We don't do that here, because
 *    we'll create the actual TD entries on demand.
555
556
557
558
559
560
 *  - The first queue is the high-period interrupt queue.
 *  - The second queue is the period-1 interrupt and async
 *    (low-speed control, full-speed control, then bulk) queue.
 *  - The third queue is the terminating bandwidth reclamation queue,
 *    which contains no members, loops back to itself, and is present
 *    only when FSBR is on and there are no full-speed control or bulk QHs.
Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
564
565
 */
static int uhci_start(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
	int retval = -EBUSY;
566
	int i;
567
	struct dentry __maybe_unused *dentry;
Linus Torvalds's avatar
Linus Torvalds committed
568

569
	hcd->uses_new_polling = 1;
570
571
572
	/* Accept arbitrarily long scatter-gather lists */
	if (!(hcd->driver->flags & HCD_LOCAL_MEM))
		hcd->self.sg_tablesize = ~0;
Linus Torvalds's avatar
Linus Torvalds committed
573
574

	spin_lock_init(&uhci->lock);
575
576
	setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout,
			(unsigned long) uhci);
577
	INIT_LIST_HEAD(&uhci->idle_qh_list);
Linus Torvalds's avatar
Linus Torvalds committed
578
579
	init_waitqueue_head(&uhci->waitqh);

580
581
582
583
584
585
586
#ifdef UHCI_DEBUG_OPS
	dentry = debugfs_create_file(hcd->self.bus_name,
			S_IFREG|S_IRUGO|S_IWUSR, uhci_debugfs_root,
			uhci, &uhci_debug_operations);
	if (!dentry) {
		dev_err(uhci_dev(uhci), "couldn't create uhci debugfs entry\n");
		return -ENOMEM;
587
	}
588
589
	uhci->dentry = dentry;
#endif
590

591
592
593
594
	uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
			UHCI_NUMFRAMES * sizeof(*uhci->frame),
			&uhci->frame_dma_handle, 0);
	if (!uhci->frame) {
Linus Torvalds's avatar
Linus Torvalds committed
595
596
		dev_err(uhci_dev(uhci), "unable to allocate "
				"consistent memory for frame list\n");
597
		goto err_alloc_frame;
Linus Torvalds's avatar
Linus Torvalds committed
598
	}
599
	memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
Linus Torvalds's avatar
Linus Torvalds committed
600

601
602
603
604
605
606
607
	uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
			GFP_KERNEL);
	if (!uhci->frame_cpu) {
		dev_err(uhci_dev(uhci), "unable to allocate "
				"memory for frame pointers\n");
		goto err_alloc_frame_cpu;
	}
Linus Torvalds's avatar
Linus Torvalds committed
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622

	uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
			sizeof(struct uhci_td), 16, 0);
	if (!uhci->td_pool) {
		dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
		goto err_create_td_pool;
	}

	uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
			sizeof(struct uhci_qh), 16, 0);
	if (!uhci->qh_pool) {
		dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
		goto err_create_qh_pool;
	}

623
	uhci->term_td = uhci_alloc_td(uhci);
Linus Torvalds's avatar
Linus Torvalds committed
624
625
626
627
628
629
	if (!uhci->term_td) {
		dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
		goto err_alloc_term_td;
	}

	for (i = 0; i < UHCI_NUM_SKELQH; i++) {
630
		uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
631
632
633
634
635
636
637
		if (!uhci->skelqh[i]) {
			dev_err(uhci_dev(uhci), "unable to allocate QH\n");
			goto err_alloc_skelqh;
		}
	}

	/*
638
	 * 8 Interrupt queues; link all higher int queues to int1 = async
Linus Torvalds's avatar
Linus Torvalds committed
639
	 */
640
	for (i = SKEL_ISO + 1; i < SKEL_ASYNC; ++i)
641
642
643
		uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh);
	uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci);
	uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
Linus Torvalds's avatar
Linus Torvalds committed
644
645

	/* This dummy TD is to work around a bug in Intel PIIX controllers */
646
	uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) |
647
			(0x7f << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN, 0);
648
	uhci->term_td->link = UHCI_PTR_TERM(uhci);
649
	uhci->skel_async_qh->element = uhci->skel_term_qh->element =
650
		LINK_TO_TD(uhci, uhci->term_td);
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
654
655
656
657
658

	/*
	 * Fill the frame list: make all entries point to the proper
	 * interrupt queue.
	 */
	for (i = 0; i < UHCI_NUMFRAMES; i++) {

		/* Only place we don't use the frame list routines */
659
		uhci->frame[i] = uhci_frame_skel_link(uhci, i);
Linus Torvalds's avatar
Linus Torvalds committed
660
661
662
663
	}

	/*
	 * Some architectures require a full mb() to enforce completion of
664
	 * the memory writes above before the I/O transfers in configure_hc().
Linus Torvalds's avatar
Linus Torvalds committed
665
666
	 */
	mb();
667

668
	spin_lock_irq(&uhci->lock);
669
	configure_hc(uhci);
670
	uhci->is_initialized = 1;
671
	start_rh(uhci);
672
	spin_unlock_irq(&uhci->lock);
Linus Torvalds's avatar
Linus Torvalds committed
673
674
675
676
677
678
	return 0;

/*
 * error exits:
 */
err_alloc_skelqh:
679
680
	for (i = 0; i < UHCI_NUM_SKELQH; i++) {
		if (uhci->skelqh[i])
Linus Torvalds's avatar
Linus Torvalds committed
681
			uhci_free_qh(uhci, uhci->skelqh[i]);
682
	}
Linus Torvalds's avatar
Linus Torvalds committed
683
684
685
686
687
688
689
690
691
692

	uhci_free_td(uhci, uhci->term_td);

err_alloc_term_td:
	dma_pool_destroy(uhci->qh_pool);

err_create_qh_pool:
	dma_pool_destroy(uhci->td_pool);

err_create_td_pool:
693
694
695
696
697
698
	kfree(uhci->frame_cpu);

err_alloc_frame_cpu:
	dma_free_coherent(uhci_dev(uhci),
			UHCI_NUMFRAMES * sizeof(*uhci->frame),
			uhci->frame, uhci->frame_dma_handle);
Linus Torvalds's avatar
Linus Torvalds committed
699

700
err_alloc_frame:
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
704
705
706
707
708
709
710
	debugfs_remove(uhci->dentry);

	return retval;
}

static void uhci_stop(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);

	spin_lock_irq(&uhci->lock);
711
	if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead)
712
		uhci_hc_died(uhci);
713
	uhci_scan_schedule(uhci);
Linus Torvalds's avatar
Linus Torvalds committed
714
	spin_unlock_irq(&uhci->lock);
715
	synchronize_irq(hcd->irq);
716

717
	del_timer_sync(&uhci->fsbr_timer);
Linus Torvalds's avatar
Linus Torvalds committed
718
719
720
721
	release_uhci(uhci);
}

#ifdef CONFIG_PM
722
723
724
static int uhci_rh_suspend(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
David Brownell's avatar
David Brownell committed
725
	int rc = 0;
726
727

	spin_lock_irq(&uhci->lock);
728
	if (!HCD_HW_ACCESSIBLE(hcd))
David Brownell's avatar
David Brownell committed
729
		rc = -ESHUTDOWN;
730
731
732
733
734
735
736
737
738
739
740
741
742
743
	else if (uhci->dead)
		;		/* Dead controllers tell no tales */

	/* Once the controller is stopped, port resumes that are already
	 * in progress won't complete.  Hence if remote wakeup is enabled
	 * for the root hub and any ports are in the middle of a resume or
	 * remote wakeup, we must fail the suspend.
	 */
	else if (hcd->self.root_hub->do_remote_wakeup &&
			uhci->resuming_ports) {
		dev_dbg(uhci_dev(uhci), "suspend failed because a port "
				"is resuming\n");
		rc = -EBUSY;
	} else
744
		suspend_rh(uhci, UHCI_RH_SUSPENDED);
745
	spin_unlock_irq(&uhci->lock);
David Brownell's avatar
David Brownell committed
746
	return rc;
747
748
749
750
751
}

static int uhci_rh_resume(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
752
	int rc = 0;
753
754

	spin_lock_irq(&uhci->lock);
755
	if (!HCD_HW_ACCESSIBLE(hcd))
David Brownell's avatar
David Brownell committed
756
		rc = -ESHUTDOWN;
757
	else if (!uhci->dead)
758
		wakeup_rh(uhci);
759
	spin_unlock_irq(&uhci->lock);
760
	return rc;
761
762
}

Linus Torvalds's avatar
Linus Torvalds committed
763
764
#endif

765
/* Wait until a particular device/endpoint's QH is idle, and free it */
Linus Torvalds's avatar
Linus Torvalds committed
766
static void uhci_hcd_endpoint_disable(struct usb_hcd *hcd,
767
		struct usb_host_endpoint *hep)
Linus Torvalds's avatar
Linus Torvalds committed
768
769
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
770
771
772
773
774
775
	struct uhci_qh *qh;

	spin_lock_irq(&uhci->lock);
	qh = (struct uhci_qh *) hep->hcpriv;
	if (qh == NULL)
		goto done;
Linus Torvalds's avatar
Linus Torvalds committed
776

777
778
779
780
781
782
783
784
785
786
787
788
	while (qh->state != QH_STATE_IDLE) {
		++uhci->num_waiting;
		spin_unlock_irq(&uhci->lock);
		wait_event_interruptible(uhci->waitqh,
				qh->state == QH_STATE_IDLE);
		spin_lock_irq(&uhci->lock);
		--uhci->num_waiting;
	}

	uhci_free_qh(uhci, qh);
done:
	spin_unlock_irq(&uhci->lock);
Linus Torvalds's avatar
Linus Torvalds committed
789
790
791
792
793
}

static int uhci_hcd_get_frame_number(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
794
795
	unsigned frame_number;
	unsigned delta;
Linus Torvalds's avatar
Linus Torvalds committed
796
797

	/* Minimize latency by avoiding the spinlock */
798
799
	frame_number = uhci->frame_number;
	barrier();
800
	delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
801
802
			(UHCI_NUMFRAMES - 1);
	return frame_number + delta;
Linus Torvalds's avatar
Linus Torvalds committed
803
804
}

805
806
807
808
809
810
/* Determines number of ports on controller */
static int uhci_count_ports(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
	unsigned io_size = (unsigned) hcd->rsrc_len;
	int port;
Linus Torvalds's avatar
Linus Torvalds committed
811

812
813
814
815
816
817
818
819
820
821
	/* The UHCI spec says devices must have 2 ports, and goes on to say
	 * they may have more but gives no way to determine how many there
	 * are.  However according to the UHCI spec, Bit 7 of the port
	 * status and control register is always set to 1.  So we try to
	 * use this to our advantage.  Another common failure mode when
	 * a nonexistent register is addressed is to return all ones, so
	 * we test for that also.
	 */
	for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
		unsigned int portstatus;
Linus Torvalds's avatar
Linus Torvalds committed
822

823
		portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
824
825
826
827
828
		if (!(portstatus & 0x0080) || portstatus == 0xffff)
			break;
	}
	if (debug)
		dev_info(uhci_dev(uhci), "detected %d ports\n", port);
Linus Torvalds's avatar
Linus Torvalds committed
829

830
831
832
833
834
835
	/* Anything greater than 7 is weird so we'll ignore it. */
	if (port > UHCI_RH_MAXCHILD) {
		dev_info(uhci_dev(uhci), "port count misdetected? "
				"forcing to 2 ports\n");
		port = 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
836

837
838
	return port;
}
Linus Torvalds's avatar
Linus Torvalds committed
839

840
static const char hcd_name[] = "uhci_hcd";
Linus Torvalds's avatar
Linus Torvalds committed
841

842
#ifdef CONFIG_PCI
843
#include "uhci-pci.c"
844
845
#define	PCI_DRIVER		uhci_pci_driver
#endif
Linus Torvalds's avatar
Linus Torvalds committed
846

847
848
849
850
#ifdef CONFIG_SPARC_LEON
#include "uhci-grlib.c"
#define PLATFORM_DRIVER		uhci_grlib_driver
#endif
Linus Torvalds's avatar
Linus Torvalds committed
851

852
853
854
855
856
#ifdef CONFIG_USB_UHCI_PLATFORM
#include "uhci-platform.c"
#define PLATFORM_DRIVER		uhci_platform_driver
#endif

857
858
#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER)
#error "missing bus glue for uhci-hcd"
859
#endif
Linus Torvalds's avatar
Linus Torvalds committed
860
861
862
863
864
865
866
867

static int __init uhci_hcd_init(void)
{
	int retval = -ENOMEM;

	if (usb_disabled())
		return -ENODEV;

868
869
	printk(KERN_INFO "uhci_hcd: " DRIVER_DESC "%s\n",
			ignore_oc ? ", overcurrent ignored" : "");
870
	set_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
871

872
	if (DEBUG_CONFIGURED) {
Linus Torvalds's avatar
Linus Torvalds committed
873
874
875
		errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
		if (!errbuf)
			goto errbuf_failed;
876
		uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);
877
878
		if (!uhci_debugfs_root)
			goto debug_failed;
Linus Torvalds's avatar
Linus Torvalds committed
879
880
881
	}

	uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
882
		sizeof(struct urb_priv), 0, 0, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
	if (!uhci_up_cachep)
		goto up_failed;

886
887
888
889
890
891
892
893
894
895
896
#ifdef PLATFORM_DRIVER
	retval = platform_driver_register(&PLATFORM_DRIVER);
	if (retval < 0)
		goto clean0;
#endif

#ifdef PCI_DRIVER
	retval = pci_register_driver(&PCI_DRIVER);
	if (retval < 0)
		goto clean1;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
897
898
899

	return 0;

900
901
902
903
904
905
906
#ifdef PCI_DRIVER
clean1:
#endif
#ifdef PLATFORM_DRIVER
	platform_driver_unregister(&PLATFORM_DRIVER);
clean0:
#endif
907
	kmem_cache_destroy(uhci_up_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
908
909
910
911
912

up_failed:
	debugfs_remove(uhci_debugfs_root);

debug_failed:
913
	kfree(errbuf);
Linus Torvalds's avatar
Linus Torvalds committed
914
915
916

errbuf_failed:

917
	clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
Linus Torvalds's avatar
Linus Torvalds committed
918
919
920
921
922
	return retval;
}

static void __exit uhci_hcd_cleanup(void) 
{
923
924
925
926
927
928
#ifdef PLATFORM_DRIVER
	platform_driver_unregister(&PLATFORM_DRIVER);
#endif
#ifdef PCI_DRIVER
	pci_unregister_driver(&PCI_DRIVER);
#endif
929
	kmem_cache_destroy(uhci_up_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
930
	debugfs_remove(uhci_debugfs_root);
931
	kfree(errbuf);
932
	clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
Linus Torvalds's avatar
Linus Torvalds committed
933
934
935
936
937
938
939
940
}

module_init(uhci_hcd_init);
module_exit(uhci_hcd_cleanup);

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