uhci-hcd.c 24.7 KB
Newer Older
L
Linus Torvalds 已提交
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-2006 Alan Stern, stern@rowland.harvard.edu
L
Linus Torvalds 已提交
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
 *
 * 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/sched.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>
#include <linux/bitops.h>

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

#include "../core/hcd.h"
#include "uhci-hcd.h"
51
#include "pci-quirks.h"
L
Linus Torvalds 已提交
52 53 54 55

/*
 * Version Information
 */
56
#define DRIVER_VERSION "v3.0"
L
Linus Torvalds 已提交
57 58 59 60 61 62 63
#define DRIVER_AUTHOR "Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, \
Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber, \
Alan Stern"
#define DRIVER_DESC "USB Universal Host Controller Interface driver"

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

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

L
Linus Torvalds 已提交
80 81 82 83 84
static char *errbuf;
#define ERRBUF_LEN    (32 * 1024)

static kmem_cache_t *uhci_up_cachep;	/* urb_priv */

85 86
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
static void wakeup_rh(struct uhci_hcd *uhci);
L
Linus Torvalds 已提交
87 88 89 90
static void uhci_get_current_frame_number(struct uhci_hcd *uhci);

#include "uhci-debug.c"
#include "uhci-q.c"
91
#include "uhci-hub.c"
L
Linus Torvalds 已提交
92

93
/*
94
 * Finish up a host controller reset and update the recorded state.
95
 */
96
static void finish_reset(struct uhci_hcd *uhci)
L
Linus Torvalds 已提交
97
{
98 99 100 101 102 103 104 105 106
	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)
		outw(0, uhci->io_addr + USBPORTSC1 + (port * 2));

107
	uhci->port_c_suspend = uhci->resuming_ports = 0;
108
	uhci->rh_state = UHCI_RH_RESET;
109 110
	uhci->is_stopped = UHCI_IS_STOPPED;
	uhci_to_hcd(uhci)->state = HC_STATE_HALT;
111
	uhci_to_hcd(uhci)->poll_rh = 0;
112 113

	uhci->dead = 0;		/* Full reset resurrects the controller */
L
Linus Torvalds 已提交
114 115
}

A
Alan Stern 已提交
116 117
/*
 * Last rites for a defunct/nonfunctional controller
118
 * or one we don't want to use any more.
A
Alan Stern 已提交
119
 */
120
static void uhci_hc_died(struct uhci_hcd *uhci)
A
Alan Stern 已提交
121
{
122
	uhci_get_current_frame_number(uhci);
123 124
	uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
	finish_reset(uhci);
125 126 127 128
	uhci->dead = 1;

	/* The current frame may already be partway finished */
	++uhci->frame_number;
A
Alan Stern 已提交
129 130
}

131
/*
D
David Brownell 已提交
132 133 134
 * 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.
135 136 137
 */
static void check_and_reset_hc(struct uhci_hcd *uhci)
{
138 139
	if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
		finish_reset(uhci);
140 141 142 143 144 145 146 147 148 149 150
}

/*
 * 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 */
	outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);

	/* Store the frame list base address */
151
	outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
152 153

	/* Set the current frame number */
154 155
	outw(uhci->frame_number & UHCI_MAX_SOF_NUMBER,
			uhci->io_addr + USBFRNUM);
156

157 158
	/* Mark controller as not halted before we enable interrupts */
	uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
159 160 161 162 163 164 165 166
	mb();

	/* Enable PIRQ */
	pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP,
			USBLEGSUP_DEFAULT);
}


167
static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
L
Linus Torvalds 已提交
168
{
169
	int port;
L
Linus Torvalds 已提交
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
	switch (to_pci_dev(uhci_dev(uhci))->vendor) {
	    default:
		break;

	    case PCI_VENDOR_ID_GENESYS:
		/* Genesys Logic's GL880S controllers don't generate
		 * resume-detect interrupts.
		 */
		return 1;

	    case PCI_VENDOR_ID_INTEL:
		/* Some of Intel's USB controllers have a bug that causes
		 * resume-detect interrupts if any port has an over-current
		 * condition.  To make matters worse, some motherboards
		 * hardwire unused USB ports' over-current inputs active!
		 * To prevent problems, we will not enable resume-detect
		 * interrupts if any ports are OC.
		 */
		for (port = 0; port < uhci->rh_numports; ++port) {
			if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
					USBPORTSC_OC)
				return 1;
		}
		break;
	}
	return 0;
}

199
static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
200 201 202 203 204 205 206
__releases(uhci->lock)
__acquires(uhci->lock)
{
	int auto_stop;
	int int_enable;

	auto_stop = (new_state == UHCI_RH_AUTO_STOPPED);
D
David Brownell 已提交
207 208
	dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
			"%s%s\n", __FUNCTION__,
209 210 211 212 213 214 215 216 217 218 219 220 221
			(auto_stop ? " (auto-stop)" : ""));

	/* If we get a suspend request when we're already auto-stopped
	 * then there's nothing to do.
	 */
	if (uhci->rh_state == UHCI_RH_AUTO_STOPPED) {
		uhci->rh_state = new_state;
		return;
	}

	/* Enable resume-detect interrupts if they work.
	 * Then enter Global Suspend mode, still configured.
	 */
222 223 224 225 226
	uhci->working_RD = 1;
	int_enable = USBINTR_RESUME;
	if (resume_detect_interrupts_are_broken(uhci)) {
		uhci->working_RD = int_enable = 0;
	}
227 228
	outw(int_enable, uhci->io_addr + USBINTR);
	outw(USBCMD_EGSM | USBCMD_CF, uhci->io_addr + USBCMD);
229
	mb();
230 231 232 233 234 235 236 237 238 239 240 241
	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.
	 */
	if (!auto_stop && !(inw(uhci->io_addr + USBSTS) & USBSTS_HCH)) {
		uhci->rh_state = UHCI_RH_SUSPENDING;
		spin_unlock_irq(&uhci->lock);
		msleep(1);
		spin_lock_irq(&uhci->lock);
242
		if (uhci->dead)
A
Alan Stern 已提交
243
			return;
244 245
	}
	if (!(inw(uhci->io_addr + USBSTS) & USBSTS_HCH))
D
David Brownell 已提交
246 247
		dev_warn(&uhci_to_hcd(uhci)->self.root_hub->dev,
			"Controller not stopped yet!\n");
L
Linus Torvalds 已提交
248 249

	uhci_get_current_frame_number(uhci);
250 251

	uhci->rh_state = new_state;
L
Linus Torvalds 已提交
252
	uhci->is_stopped = UHCI_IS_STOPPED;
253
	uhci_to_hcd(uhci)->poll_rh = !int_enable;
L
Linus Torvalds 已提交
254

255
	uhci_scan_schedule(uhci);
A
Alan Stern 已提交
256
	uhci_fsbr_off(uhci);
L
Linus Torvalds 已提交
257 258
}

259 260
static void start_rh(struct uhci_hcd *uhci)
{
261
	uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
262 263 264 265 266 267 268 269 270
	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.
	 */
	outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, uhci->io_addr + USBCMD);
	outw(USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP,
			uhci->io_addr + USBINTR);
	mb();
271 272
	uhci->rh_state = UHCI_RH_RUNNING;
	uhci_to_hcd(uhci)->poll_rh = 1;
273 274 275
}

static void wakeup_rh(struct uhci_hcd *uhci)
276 277
__releases(uhci->lock)
__acquires(uhci->lock)
L
Linus Torvalds 已提交
278
{
D
David Brownell 已提交
279 280
	dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
			"%s%s\n", __FUNCTION__,
281 282
			uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
				" (auto-start)" : "");
L
Linus Torvalds 已提交
283

284 285 286 287 288 289 290 291 292 293 294
	/* 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) {
		uhci->rh_state = UHCI_RH_RESUMING;
		outw(USBCMD_FGR | USBCMD_EGSM | USBCMD_CF,
				uhci->io_addr + USBCMD);
		spin_unlock_irq(&uhci->lock);
		msleep(20);
		spin_lock_irq(&uhci->lock);
295
		if (uhci->dead)
A
Alan Stern 已提交
296
			return;
L
Linus Torvalds 已提交
297

298 299
		/* End Global Resume and wait for EOP to be sent */
		outw(USBCMD_CF, uhci->io_addr + USBCMD);
300
		mb();
301 302 303 304
		udelay(4);
		if (inw(uhci->io_addr + USBCMD) & USBCMD_FGR)
			dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
	}
L
Linus Torvalds 已提交
305

306
	start_rh(uhci);
307

308 309
	/* Restart root hub polling */
	mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
L
Linus Torvalds 已提交
310 311
}

312
static irqreturn_t uhci_irq(struct usb_hcd *hcd)
313 314 315
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
	unsigned short status;
A
Alan Stern 已提交
316
	unsigned long flags;
L
Linus Torvalds 已提交
317 318

	/*
319 320 321
	 * 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.
L
Linus Torvalds 已提交
322
	 */
323
	status = inw(uhci->io_addr + USBSTS);
324 325
	if (!(status & ~USBSTS_HCH))	/* shared interrupt, not mine */
		return IRQ_NONE;
326
	outw(status, uhci->io_addr + USBSTS);		/* Clear it */
327 328 329 330 331 332 333 334

	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");
A
Alan Stern 已提交
335 336 337 338 339
		if (status & USBSTS_HCH) {
			spin_lock_irqsave(&uhci->lock, flags);
			if (uhci->rh_state >= UHCI_RH_RUNNING) {
				dev_err(uhci_dev(uhci),
					"host controller halted, "
340
					"very bad!\n");
341 342 343 344 345 346
				if (debug > 1 && errbuf) {
					/* Print the schedule for debugging */
					uhci_sprint_schedule(uhci,
							errbuf, ERRBUF_LEN);
					lprintk(errbuf);
				}
347
				uhci_hc_died(uhci);
348 349 350 351

				/* Force a callback in case there are
				 * pending unlinks */
				mod_timer(&hcd->rh_timer, jiffies);
A
Alan Stern 已提交
352 353
			}
			spin_unlock_irqrestore(&uhci->lock, flags);
L
Linus Torvalds 已提交
354 355 356
		}
	}

357
	if (status & USBSTS_RD)
358
		usb_hcd_poll_rh_status(hcd);
359 360
	else {
		spin_lock_irqsave(&uhci->lock, flags);
361
		uhci_scan_schedule(uhci);
362 363
		spin_unlock_irqrestore(&uhci->lock, flags);
	}
L
Linus Torvalds 已提交
364

365 366
	return IRQ_HANDLED;
}
L
Linus Torvalds 已提交
367

368 369
/*
 * Store the current frame number in uhci->frame_number if the controller
370 371 372 373 374
 * is runnning.  Expand from 11 bits (of which we use only 10) to a
 * 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.
375 376 377
 */
static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
{
378 379 380 381 382 383 384
	if (!uhci->is_stopped) {
		unsigned delta;

		delta = (inw(uhci->io_addr + USBFRNUM) - uhci->frame_number) &
				(UHCI_NUMFRAMES - 1);
		uhci->frame_number += delta;
	}
L
Linus Torvalds 已提交
385 386 387 388 389 390 391 392 393
}

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

394 395 396 397 398 399 400 401
	if (DEBUG_CONFIGURED) {
		spin_lock_irq(&uhci->lock);
		uhci->is_initialized = 0;
		spin_unlock_irq(&uhci->lock);

		debugfs_remove(uhci->dentry);
	}

L
Linus Torvalds 已提交
402
	for (i = 0; i < UHCI_NUM_SKELQH; i++)
403
		uhci_free_qh(uhci, uhci->skelqh[i]);
L
Linus Torvalds 已提交
404

405
	uhci_free_td(uhci, uhci->term_td);
L
Linus Torvalds 已提交
406

407
	dma_pool_destroy(uhci->qh_pool);
L
Linus Torvalds 已提交
408

409
	dma_pool_destroy(uhci->td_pool);
L
Linus Torvalds 已提交
410

411 412 413 414 415
	kfree(uhci->frame_cpu);

	dma_free_coherent(uhci_dev(uhci),
			UHCI_NUMFRAMES * sizeof(*uhci->frame),
			uhci->frame, uhci->frame_dma_handle);
L
Linus Torvalds 已提交
416 417
}

D
David Brownell 已提交
418
static int uhci_init(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
419 420
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
421 422
	unsigned io_size = (unsigned) hcd->rsrc_len;
	int port;
L
Linus Torvalds 已提交
423 424 425

	uhci->io_addr = (unsigned long) hcd->rsrc_start;

426 427
	/* 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
428
	 * are.  However according to the UHCI spec, Bit 7 of the port
429
	 * status and control register is always set to 1.  So we try to
430 431 432
	 * 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.
433 434 435 436 437
	 */
	for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
		unsigned int portstatus;

		portstatus = inw(uhci->io_addr + USBPORTSC1 + (port * 2));
438
		if (!(portstatus & 0x0080) || portstatus == 0xffff)
439 440 441 442 443
			break;
	}
	if (debug)
		dev_info(uhci_dev(uhci), "detected %d ports\n", port);

444 445
	/* Anything greater than 7 is weird so we'll ignore it. */
	if (port > UHCI_RH_MAXCHILD) {
446 447 448 449 450 451
		dev_info(uhci_dev(uhci), "port count misdetected? "
				"forcing to 2 ports\n");
		port = 2;
	}
	uhci->rh_numports = port;

452 453
	/* Kick BIOS off this hardware and reset if the controller
	 * isn't already safely quiescent.
L
Linus Torvalds 已提交
454
	 */
455
	check_and_reset_hc(uhci);
L
Linus Torvalds 已提交
456 457 458
	return 0;
}

459 460 461 462 463 464 465 466 467 468 469
/* Make sure the controller is quiescent and that we're not using it
 * any more.  This is mainly for the benefit of programs which, like kexec,
 * expect the hardware to be idle: not doing DMA or generating IRQs.
 *
 * This routine may be called in a damaged or failing kernel.  Hence we
 * do not acquire the spinlock before shutting down the controller.
 */
static void uhci_shutdown(struct pci_dev *pdev)
{
	struct usb_hcd *hcd = (struct usb_hcd *) pci_get_drvdata(pdev);

470
	uhci_hc_died(hcd_to_uhci(hcd));
471 472
}

L
Linus Torvalds 已提交
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
/*
 * 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
 * protocols higher up. The order is:
 *
 *  - any isochronous events handled before any
 *    of the queues. We don't do that here, because
 *    we'll create the actual TD entries on demand.
 *  - The first queue is the interrupt queue.
 *  - The second queue is the control queue, split into low- and full-speed
 *  - The third queue is bulk queue.
 *  - The fourth queue is the bandwidth reclamation queue, which loops back
 *    to the full-speed control queue.
 */
static int uhci_start(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
	int retval = -EBUSY;
493
	int i;
L
Linus Torvalds 已提交
494 495
	struct dentry *dentry;

496
	hcd->uses_new_polling = 1;
L
Linus Torvalds 已提交
497 498

	spin_lock_init(&uhci->lock);
499 500
	setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout,
			(unsigned long) uhci);
501
	INIT_LIST_HEAD(&uhci->idle_qh_list);
L
Linus Torvalds 已提交
502 503
	init_waitqueue_head(&uhci->waitqh);

504 505 506 507 508 509 510 511 512 513 514 515 516
	if (DEBUG_CONFIGURED) {
		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");
			retval = -ENOMEM;
			goto err_create_debug_entry;
		}
		uhci->dentry = dentry;
	}

517 518 519 520
	uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
			UHCI_NUMFRAMES * sizeof(*uhci->frame),
			&uhci->frame_dma_handle, 0);
	if (!uhci->frame) {
L
Linus Torvalds 已提交
521 522
		dev_err(uhci_dev(uhci), "unable to allocate "
				"consistent memory for frame list\n");
523
		goto err_alloc_frame;
L
Linus Torvalds 已提交
524
	}
525
	memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
L
Linus Torvalds 已提交
526

527 528 529 530 531 532 533
	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;
	}
L
Linus Torvalds 已提交
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548

	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;
	}

549
	uhci->term_td = uhci_alloc_td(uhci);
L
Linus Torvalds 已提交
550 551 552 553 554 555
	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++) {
556
		uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
		if (!uhci->skelqh[i]) {
			dev_err(uhci_dev(uhci), "unable to allocate QH\n");
			goto err_alloc_skelqh;
		}
	}

	/*
	 * 8 Interrupt queues; link all higher int queues to int1,
	 * then link int1 to control and control to bulk
	 */
	uhci->skel_int128_qh->link =
			uhci->skel_int64_qh->link =
			uhci->skel_int32_qh->link =
			uhci->skel_int16_qh->link =
			uhci->skel_int8_qh->link =
			uhci->skel_int4_qh->link =
573 574 575 576 577 578 579 580 581 582 583
			uhci->skel_int2_qh->link = UHCI_PTR_QH |
			cpu_to_le32(uhci->skel_int1_qh->dma_handle);

	uhci->skel_int1_qh->link = UHCI_PTR_QH |
			cpu_to_le32(uhci->skel_ls_control_qh->dma_handle);
	uhci->skel_ls_control_qh->link = UHCI_PTR_QH |
			cpu_to_le32(uhci->skel_fs_control_qh->dma_handle);
	uhci->skel_fs_control_qh->link = UHCI_PTR_QH |
			cpu_to_le32(uhci->skel_bulk_qh->dma_handle);
	uhci->skel_bulk_qh->link = UHCI_PTR_QH |
			cpu_to_le32(uhci->skel_term_qh->dma_handle);
L
Linus Torvalds 已提交
584 585

	/* This dummy TD is to work around a bug in Intel PIIX controllers */
586
	uhci_fill_td(uhci->term_td, 0, uhci_explen(0) |
L
Linus Torvalds 已提交
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
		(0x7f << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN, 0);
	uhci->term_td->link = cpu_to_le32(uhci->term_td->dma_handle);

	uhci->skel_term_qh->link = UHCI_PTR_TERM;
	uhci->skel_term_qh->element = cpu_to_le32(uhci->term_td->dma_handle);

	/*
	 * Fill the frame list: make all entries point to the proper
	 * interrupt queue.
	 *
	 * 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.
	 */
	for (i = 0; i < UHCI_NUMFRAMES; i++) {
		int irq;

		/*
		 * ffs (Find First bit Set) does exactly what we need:
609 610 611 612
		 * 1,3,5,...  => ffs = 0 => use skel_int2_qh = skelqh[8],
		 * 2,6,10,... => ffs = 1 => use skel_int4_qh = skelqh[7], etc.
		 * ffs >= 7 => not on any high-period queue, so use
		 *	skel_int1_qh = skelqh[9].
L
Linus Torvalds 已提交
613 614
		 * Add UHCI_NUMFRAMES to insure at least one bit is set.
		 */
615 616 617
		irq = 8 - (int) __ffs(i + UHCI_NUMFRAMES);
		if (irq <= 1)
			irq = 9;
L
Linus Torvalds 已提交
618 619

		/* Only place we don't use the frame list routines */
620
		uhci->frame[i] = UHCI_PTR_QH |
L
Linus Torvalds 已提交
621 622 623 624 625
				cpu_to_le32(uhci->skelqh[irq]->dma_handle);
	}

	/*
	 * Some architectures require a full mb() to enforce completion of
626
	 * the memory writes above before the I/O transfers in configure_hc().
L
Linus Torvalds 已提交
627 628
	 */
	mb();
629 630

	configure_hc(uhci);
631
	uhci->is_initialized = 1;
632
	start_rh(uhci);
L
Linus Torvalds 已提交
633 634 635 636 637 638
	return 0;

/*
 * error exits:
 */
err_alloc_skelqh:
639 640
	for (i = 0; i < UHCI_NUM_SKELQH; i++) {
		if (uhci->skelqh[i])
L
Linus Torvalds 已提交
641
			uhci_free_qh(uhci, uhci->skelqh[i]);
642
	}
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652

	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:
653 654 655 656 657 658
	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);
L
Linus Torvalds 已提交
659

660
err_alloc_frame:
L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669 670 671
	debugfs_remove(uhci->dentry);

err_create_debug_entry:
	return retval;
}

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

	spin_lock_irq(&uhci->lock);
672 673
	if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) && !uhci->dead)
		uhci_hc_died(uhci);
674
	uhci_scan_schedule(uhci);
L
Linus Torvalds 已提交
675
	spin_unlock_irq(&uhci->lock);
676

677
	del_timer_sync(&uhci->fsbr_timer);
L
Linus Torvalds 已提交
678 679 680 681
	release_uhci(uhci);
}

#ifdef CONFIG_PM
682 683 684
static int uhci_rh_suspend(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
D
David Brownell 已提交
685
	int rc = 0;
686 687

	spin_lock_irq(&uhci->lock);
D
David Brownell 已提交
688 689
	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
		rc = -ESHUTDOWN;
690
	else if (!uhci->dead)
A
Alan Stern 已提交
691
		suspend_rh(uhci, UHCI_RH_SUSPENDED);
692
	spin_unlock_irq(&uhci->lock);
D
David Brownell 已提交
693
	return rc;
694 695 696 697 698
}

static int uhci_rh_resume(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
A
Alan Stern 已提交
699
	int rc = 0;
700 701

	spin_lock_irq(&uhci->lock);
D
David Brownell 已提交
702 703 704
	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
		dev_warn(&hcd->self.root_hub->dev, "HC isn't running!\n");
		rc = -ESHUTDOWN;
705
	} else if (!uhci->dead)
A
Alan Stern 已提交
706
		wakeup_rh(uhci);
707
	spin_unlock_irq(&uhci->lock);
A
Alan Stern 已提交
708
	return rc;
709 710
}

711
static int uhci_suspend(struct usb_hcd *hcd, pm_message_t message)
L
Linus Torvalds 已提交
712 713
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
A
Alan Stern 已提交
714
	int rc = 0;
L
Linus Torvalds 已提交
715

716 717
	dev_dbg(uhci_dev(uhci), "%s\n", __FUNCTION__);

L
Linus Torvalds 已提交
718
	spin_lock_irq(&uhci->lock);
719 720
	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)
		goto done_okay;		/* Already suspended or dead */
721

A
Alan Stern 已提交
722 723 724 725 726 727
	if (uhci->rh_state > UHCI_RH_SUSPENDED) {
		dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
		rc = -EBUSY;
		goto done;
	};

728 729 730 731
	/* All PCI host controllers are required to disable IRQ generation
	 * at the source, so we must turn off PIRQ.
	 */
	pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP, 0);
732
	mb();
733
	hcd->poll_rh = 0;
734 735 736

	/* FIXME: Enable non-PME# remote wakeup? */

737 738 739 740
	/* make sure snapshot being resumed re-enumerates everything */
	if (message.event == PM_EVENT_PRETHAW)
		uhci_hc_died(uhci);

741 742
done_okay:
	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
A
Alan Stern 已提交
743
done:
L
Linus Torvalds 已提交
744
	spin_unlock_irq(&uhci->lock);
A
Alan Stern 已提交
745
	return rc;
L
Linus Torvalds 已提交
746 747 748 749 750 751
}

static int uhci_resume(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);

752 753
	dev_dbg(uhci_dev(uhci), "%s\n", __FUNCTION__);

754
	/* Since we aren't in D3 any more, it's safe to set this flag
755
	 * even if the controller was dead.
756 757
	 */
	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
758
	mb();
759

L
Linus Torvalds 已提交
760 761
	spin_lock_irq(&uhci->lock);

762 763
	/* FIXME: Disable non-PME# remote wakeup? */

764 765 766
	/* The firmware or a boot kernel may have changed the controller
	 * settings during a system wakeup.  Check it and reconfigure
	 * to avoid problems.
767 768
	 */
	check_and_reset_hc(uhci);
769 770

	/* If the controller was dead before, it's back alive now */
771 772
	configure_hc(uhci);

773 774 775 776
	if (uhci->rh_state == UHCI_RH_RESET) {

		/* The controller had to be reset */
		usb_root_hub_lost_power(hcd->self.root_hub);
777
		suspend_rh(uhci, UHCI_RH_SUSPENDED);
778
	}
779

780
	spin_unlock_irq(&uhci->lock);
781

782 783 784
	if (!uhci->working_RD) {
		/* Suspended root hub needs to be polled */
		hcd->poll_rh = 1;
785
		usb_hcd_poll_rh_status(hcd);
786
	}
L
Linus Torvalds 已提交
787 788 789 790
	return 0;
}
#endif

791
/* Wait until a particular device/endpoint's QH is idle, and free it */
L
Linus Torvalds 已提交
792
static void uhci_hcd_endpoint_disable(struct usb_hcd *hcd,
793
		struct usb_host_endpoint *hep)
L
Linus Torvalds 已提交
794 795
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
796 797 798 799 800 801
	struct uhci_qh *qh;

	spin_lock_irq(&uhci->lock);
	qh = (struct uhci_qh *) hep->hcpriv;
	if (qh == NULL)
		goto done;
L
Linus Torvalds 已提交
802

803 804 805 806 807 808 809 810 811 812 813 814
	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);
L
Linus Torvalds 已提交
815 816 817 818 819
}

static int uhci_hcd_get_frame_number(struct usb_hcd *hcd)
{
	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
820 821
	unsigned frame_number;
	unsigned delta;
L
Linus Torvalds 已提交
822 823

	/* Minimize latency by avoiding the spinlock */
824 825 826 827 828
	frame_number = uhci->frame_number;
	barrier();
	delta = (inw(uhci->io_addr + USBFRNUM) - frame_number) &
			(UHCI_NUMFRAMES - 1);
	return frame_number + delta;
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836 837 838 839 840 841 842
}

static const char hcd_name[] = "uhci_hcd";

static const struct hc_driver uhci_driver = {
	.description =		hcd_name,
	.product_desc =		"UHCI Host Controller",
	.hcd_priv_size =	sizeof(struct uhci_hcd),

	/* Generic hardware linkage */
	.irq =			uhci_irq,
	.flags =		HCD_USB11,

	/* Basic lifecycle operations */
D
David Brownell 已提交
843
	.reset =		uhci_init,
L
Linus Torvalds 已提交
844 845 846 847
	.start =		uhci_start,
#ifdef CONFIG_PM
	.suspend =		uhci_suspend,
	.resume =		uhci_resume,
848 849
	.bus_suspend =		uhci_rh_suspend,
	.bus_resume =		uhci_rh_resume,
L
Linus Torvalds 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
#endif
	.stop =			uhci_stop,

	.urb_enqueue =		uhci_urb_enqueue,
	.urb_dequeue =		uhci_urb_dequeue,

	.endpoint_disable =	uhci_hcd_endpoint_disable,
	.get_frame_number =	uhci_hcd_get_frame_number,

	.hub_status_data =	uhci_hub_status_data,
	.hub_control =		uhci_hub_control,
};

static const struct pci_device_id uhci_pci_ids[] = { {
	/* handle any USB UHCI controller */
865
	PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
L
Linus Torvalds 已提交
866 867 868 869 870 871 872 873 874 875 876 877
	.driver_data =	(unsigned long) &uhci_driver,
	}, { /* end: all zeroes */ }
};

MODULE_DEVICE_TABLE(pci, uhci_pci_ids);

static struct pci_driver uhci_pci_driver = {
	.name =		(char *)hcd_name,
	.id_table =	uhci_pci_ids,

	.probe =	usb_hcd_pci_probe,
	.remove =	usb_hcd_pci_remove,
878
	.shutdown =	uhci_shutdown,
L
Linus Torvalds 已提交
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894

#ifdef	CONFIG_PM
	.suspend =	usb_hcd_pci_suspend,
	.resume =	usb_hcd_pci_resume,
#endif	/* PM */
};
 
static int __init uhci_hcd_init(void)
{
	int retval = -ENOMEM;

	printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION "\n");

	if (usb_disabled())
		return -ENODEV;

895
	if (DEBUG_CONFIGURED) {
L
Linus Torvalds 已提交
896 897 898
		errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
		if (!errbuf)
			goto errbuf_failed;
899 900 901
		uhci_debugfs_root = debugfs_create_dir("uhci", NULL);
		if (!uhci_debugfs_root)
			goto debug_failed;
L
Linus Torvalds 已提交
902 903 904 905 906 907 908 909 910 911 912 913 914 915
	}

	uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
		sizeof(struct urb_priv), 0, 0, NULL, NULL);
	if (!uhci_up_cachep)
		goto up_failed;

	retval = pci_register_driver(&uhci_pci_driver);
	if (retval)
		goto init_failed;

	return 0;

init_failed:
916
	kmem_cache_destroy(uhci_up_cachep);
L
Linus Torvalds 已提交
917 918 919 920 921

up_failed:
	debugfs_remove(uhci_debugfs_root);

debug_failed:
922
	kfree(errbuf);
L
Linus Torvalds 已提交
923 924 925 926 927 928 929 930 931

errbuf_failed:

	return retval;
}

static void __exit uhci_hcd_cleanup(void) 
{
	pci_unregister_driver(&uhci_pci_driver);
932
	kmem_cache_destroy(uhci_up_cachep);
L
Linus Torvalds 已提交
933
	debugfs_remove(uhci_debugfs_root);
934
	kfree(errbuf);
L
Linus Torvalds 已提交
935 936 937 938 939 940 941 942
}

module_init(uhci_hcd_init);
module_exit(uhci_hcd_cleanup);

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