usb.c 32.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * drivers/usb/core/usb.c
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * (C) Copyright Linus Torvalds 1999
 * (C) Copyright Johannes Erdfelt 1999-2001
 * (C) Copyright Andreas Gal 1999
 * (C) Copyright Gregory P. Smith 1999
 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
 * (C) Copyright Randy Dunlap 2000
 * (C) Copyright David Brownell 2000-2004
 * (C) Copyright Yggdrasil Computing, Inc. 2000
 *     (usb_device_id matching changes by Adam J. Richter)
 * (C) Copyright Greg Kroah-Hartman 2002-2003
 *
 * NOTE! This is not actually a driver at all, rather this is
 * just a collection of helper routines that implement the
 * generic USB things that the real drivers can use..
 *
 * Think of this as a "USB library" rather than anything else.
 * It should be considered a slave, with no callbacks. Callbacks
 * are evil.
 */

#include <linux/module.h>
25
#include <linux/moduleparam.h>
L
Linus Torvalds 已提交
26 27 28 29 30 31 32 33 34
#include <linux/string.h>
#include <linux/bitops.h>
#include <linux/slab.h>
#include <linux/interrupt.h>  /* for in_interrupt() */
#include <linux/kmod.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/errno.h>
#include <linux/usb.h>
35
#include <linux/mutex.h>
36
#include <linux/workqueue.h>
37
#include <linux/debugfs.h>
L
Linus Torvalds 已提交
38 39

#include <asm/io.h>
A
Adrian Bunk 已提交
40
#include <linux/scatterlist.h>
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51
#include <linux/mm.h>
#include <linux/dma-mapping.h>

#include "hcd.h"
#include "usb.h"


const char *usbcore_name = "usbcore";

static int nousb;	/* Disable USB when built into kernel image */

52 53
/* Workqueue for autosuspend and for remote wakeup of root hubs */
struct workqueue_struct *ksuspend_usb_wq;
54

55 56 57
#ifdef	CONFIG_USB_SUSPEND
static int usb_autosuspend_delay = 2;		/* Default delay value,
						 * in seconds */
58
module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
59 60 61 62 63 64
MODULE_PARM_DESC(autosuspend, "default autosuspend delay");

#else
#define usb_autosuspend_delay		0
#endif

L
Linus Torvalds 已提交
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

/**
 * usb_ifnum_to_if - get the interface object with a given interface number
 * @dev: the device whose current configuration is considered
 * @ifnum: the desired interface
 *
 * This walks the device descriptor for the currently active configuration
 * and returns a pointer to the interface with that particular interface
 * number, or null.
 *
 * Note that configuration descriptors are not required to assign interface
 * numbers sequentially, so that it would be incorrect to assume that
 * the first interface in that descriptor corresponds to interface zero.
 * This routine helps device drivers avoid such mistakes.
 * However, you should make sure that you do the right thing with any
 * alternate settings available for this interfaces.
 *
 * Don't call this function unless you are bound to one of the interfaces
 * on this device or you have locked the device!
 */
85 86
struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
				      unsigned ifnum)
L
Linus Torvalds 已提交
87 88 89 90 91 92 93 94 95 96 97 98 99
{
	struct usb_host_config *config = dev->actconfig;
	int i;

	if (!config)
		return NULL;
	for (i = 0; i < config->desc.bNumInterfaces; i++)
		if (config->interface[i]->altsetting[0]
				.desc.bInterfaceNumber == ifnum)
			return config->interface[i];

	return NULL;
}
100
EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
L
Linus Torvalds 已提交
101 102

/**
R
Randy Dunlap 已提交
103
 * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
L
Linus Torvalds 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
 * @intf: the interface containing the altsetting in question
 * @altnum: the desired alternate setting number
 *
 * This searches the altsetting array of the specified interface for
 * an entry with the correct bAlternateSetting value and returns a pointer
 * to that entry, or null.
 *
 * Note that altsettings need not be stored sequentially by number, so
 * it would be incorrect to assume that the first altsetting entry in
 * the array corresponds to altsetting zero.  This routine helps device
 * drivers avoid such mistakes.
 *
 * Don't call this function unless you are bound to the intf interface
 * or you have locked the device!
 */
119 120 121
struct usb_host_interface *usb_altnum_to_altsetting(
					const struct usb_interface *intf,
					unsigned int altnum)
L
Linus Torvalds 已提交
122 123 124 125 126 127 128 129 130
{
	int i;

	for (i = 0; i < intf->num_altsetting; i++) {
		if (intf->altsetting[i].desc.bAlternateSetting == altnum)
			return &intf->altsetting[i];
	}
	return NULL;
}
131
EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
L
Linus Torvalds 已提交
132

133 134 135 136
struct find_interface_arg {
	int minor;
	struct usb_interface *interface;
};
L
Linus Torvalds 已提交
137

138
static int __find_interface(struct device *dev, void *data)
139
{
140 141
	struct find_interface_arg *arg = data;
	struct usb_interface *intf;
142

143
	if (!is_usb_interface(dev))
144 145 146
		return 0;

	intf = to_usb_interface(dev);
147 148
	if (intf->minor != -1 && intf->minor == arg->minor) {
		arg->interface = intf;
149 150 151 152 153
		return 1;
	}
	return 0;
}

L
Linus Torvalds 已提交
154 155 156 157 158
/**
 * usb_find_interface - find usb_interface pointer for driver and device
 * @drv: the driver whose current configuration is considered
 * @minor: the minor number of the desired device
 *
159
 * This walks the driver device list and returns a pointer to the interface
L
Linus Torvalds 已提交
160 161 162 163 164
 * with the matching minor.  Note, this only works for devices that share the
 * USB major number.
 */
struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
{
165
	struct find_interface_arg argb;
166
	int retval;
L
Linus Torvalds 已提交
167

168 169
	argb.minor = minor;
	argb.interface = NULL;
170 171 172
	/* eat the error, it will be in argb.interface */
	retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb,
					__find_interface);
173
	return argb.interface;
L
Linus Torvalds 已提交
174
}
175
EXPORT_SYMBOL_GPL(usb_find_interface);
L
Linus Torvalds 已提交
176 177 178 179 180 181 182 183 184 185 186

/**
 * usb_release_dev - free a usb device structure when all users of it are finished.
 * @dev: device that's been disconnected
 *
 * Will be called only by the device core when all users of this usb device are
 * done.
 */
static void usb_release_dev(struct device *dev)
{
	struct usb_device *udev;
187
	struct usb_hcd *hcd;
L
Linus Torvalds 已提交
188 189

	udev = to_usb_device(dev);
190
	hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
191 192

	usb_destroy_configuration(udev);
193 194 195 196
	/* Root hubs aren't real devices, so don't free HCD resources */
	if (hcd->driver->free_dev && udev->parent)
		hcd->driver->free_dev(hcd, udev);
	usb_put_hcd(hcd);
L
Linus Torvalds 已提交
197 198 199 200 201 202
	kfree(udev->product);
	kfree(udev->manufacturer);
	kfree(udev->serial);
	kfree(udev);
}

A
Alan Stern 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
#ifdef	CONFIG_HOTPLUG
static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct usb_device *usb_dev;

	usb_dev = to_usb_device(dev);

	if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
		return -ENOMEM;

	if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
		return -ENOMEM;

	return 0;
}

#else

static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	return -ENODEV;
}
#endif	/* CONFIG_HOTPLUG */

227 228
#ifdef	CONFIG_PM

229 230
static int ksuspend_usb_init(void)
{
231 232 233 234
	/* This workqueue is supposed to be both freezable and
	 * singlethreaded.  Its job doesn't justify running on more
	 * than one CPU.
	 */
235
	ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");
236 237 238 239 240 241 242 243 244 245
	if (!ksuspend_usb_wq)
		return -ENOMEM;
	return 0;
}

static void ksuspend_usb_cleanup(void)
{
	destroy_workqueue(ksuspend_usb_wq);
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/* USB device Power-Management thunks.
 * There's no need to distinguish here between quiescing a USB device
 * and powering it down; the generic_suspend() routine takes care of
 * it by skipping the usb_port_suspend() call for a quiesce.  And for
 * USB interfaces there's no difference at all.
 */

static int usb_dev_prepare(struct device *dev)
{
	return 0;		/* Implement eventually? */
}

static void usb_dev_complete(struct device *dev)
{
	/* Currently used only for rebinding interfaces */
A
Alan Stern 已提交
261
	usb_resume(dev, PMSG_RESUME);	/* Message event is meaningless */
262 263 264 265 266 267 268 269 270
}

static int usb_dev_suspend(struct device *dev)
{
	return usb_suspend(dev, PMSG_SUSPEND);
}

static int usb_dev_resume(struct device *dev)
{
A
Alan Stern 已提交
271
	return usb_resume(dev, PMSG_RESUME);
272 273 274 275 276 277 278 279 280
}

static int usb_dev_freeze(struct device *dev)
{
	return usb_suspend(dev, PMSG_FREEZE);
}

static int usb_dev_thaw(struct device *dev)
{
A
Alan Stern 已提交
281
	return usb_resume(dev, PMSG_THAW);
282 283 284 285 286 287 288 289 290
}

static int usb_dev_poweroff(struct device *dev)
{
	return usb_suspend(dev, PMSG_HIBERNATE);
}

static int usb_dev_restore(struct device *dev)
{
A
Alan Stern 已提交
291
	return usb_resume(dev, PMSG_RESTORE);
292 293
}

294
static struct dev_pm_ops usb_device_pm_ops = {
295 296 297 298 299 300 301 302 303 304
	.prepare =	usb_dev_prepare,
	.complete =	usb_dev_complete,
	.suspend =	usb_dev_suspend,
	.resume =	usb_dev_resume,
	.freeze =	usb_dev_freeze,
	.thaw =		usb_dev_thaw,
	.poweroff =	usb_dev_poweroff,
	.restore =	usb_dev_restore,
};

305 306 307 308
#else

#define ksuspend_usb_init()	0
#define ksuspend_usb_cleanup()	do {} while (0)
309
#define usb_device_pm_ops	(*(struct dev_pm_ops *)0)
310 311

#endif	/* CONFIG_PM */
312

313

314
static char *usb_devnode(struct device *dev, mode_t *mode)
315 316 317 318 319 320 321 322
{
	struct usb_device *usb_dev;

	usb_dev = to_usb_device(dev);
	return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
			 usb_dev->bus->busnum, usb_dev->devnum);
}

323 324 325 326
struct device_type usb_device_type = {
	.name =		"usb_device",
	.release =	usb_release_dev,
	.uevent =	usb_dev_uevent,
327
	.devnode = 	usb_devnode,
328 329 330
	.pm =		&usb_device_pm_ops,
};

331 332 333 334 335 336 337 338 339

/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
static unsigned usb_bus_is_wusb(struct usb_bus *bus)
{
	struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
	return hcd->wireless;
}


L
Linus Torvalds 已提交
340 341 342 343 344
/**
 * usb_alloc_dev - usb device constructor (usbcore-internal)
 * @parent: hub to which device is connected; null to allocate a root hub
 * @bus: bus used to access the device
 * @port1: one-based index of port; ignored for root hubs
345
 * Context: !in_interrupt()
L
Linus Torvalds 已提交
346 347 348 349 350 351
 *
 * Only hub drivers (including virtual root hub drivers for host
 * controllers) should ever call this.
 *
 * This call may not be used in a non-sleeping context.
 */
352 353
struct usb_device *usb_alloc_dev(struct usb_device *parent,
				 struct usb_bus *bus, unsigned port1)
L
Linus Torvalds 已提交
354 355
{
	struct usb_device *dev;
356 357
	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
	unsigned root_hub = 0;
L
Linus Torvalds 已提交
358

359
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
L
Linus Torvalds 已提交
360 361 362
	if (!dev)
		return NULL;

363
	if (!usb_get_hcd(bus_to_hcd(bus))) {
L
Linus Torvalds 已提交
364 365 366
		kfree(dev);
		return NULL;
	}
367 368 369 370 371 372 373
	/* Root hubs aren't true devices, so don't allocate HCD resources */
	if (usb_hcd->driver->alloc_dev && parent &&
		!usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
		usb_put_hcd(bus_to_hcd(bus));
		kfree(dev);
		return NULL;
	}
L
Linus Torvalds 已提交
374 375 376

	device_initialize(&dev->dev);
	dev->dev.bus = &usb_bus_type;
377
	dev->dev.type = &usb_device_type;
378
	dev->dev.groups = usb_device_groups;
L
Linus Torvalds 已提交
379
	dev->dev.dma_mask = bus->controller->dma_mask;
380
	set_dev_node(&dev->dev, dev_to_node(bus->controller));
L
Linus Torvalds 已提交
381
	dev->state = USB_STATE_ATTACHED;
382
	atomic_set(&dev->urbnum, 0);
L
Linus Torvalds 已提交
383 384 385 386 387

	INIT_LIST_HEAD(&dev->ep0.urb_list);
	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
	/* ep0 maxpacket comes later, from device descriptor */
388
	usb_enable_endpoint(dev, &dev->ep0, false);
389
	dev->can_submit = 1;
L
Linus Torvalds 已提交
390 391 392 393 394

	/* Save readable and stable topology id, distinguishing devices
	 * by location for diagnostics, tools, driver model, etc.  The
	 * string is a path along hub ports, from the root.  Each device's
	 * dev->devpath will be stable until USB is re-cabled, and hubs
395
	 * are often labeled with these port numbers.  The name isn't
L
Linus Torvalds 已提交
396 397 398
	 * as stable:  bus->busnum changes easily from modprobe order,
	 * cardbus or pci hotplugging, and so on.
	 */
399 400
	if (unlikely(!parent)) {
		dev->devpath[0] = '0';
401
		dev->route = 0;
L
Linus Torvalds 已提交
402 403

		dev->dev.parent = bus->controller;
404
		dev_set_name(&dev->dev, "usb%d", bus->busnum);
405
		root_hub = 1;
L
Linus Torvalds 已提交
406 407
	} else {
		/* match any labeling on the hubs; it's one-based */
408
		if (parent->devpath[0] == '0') {
409
			snprintf(dev->devpath, sizeof dev->devpath,
L
Linus Torvalds 已提交
410
				"%d", port1);
411 412 413
			/* Root ports are not counted in route string */
			dev->route = 0;
		} else {
414
			snprintf(dev->devpath, sizeof dev->devpath,
L
Linus Torvalds 已提交
415
				"%s.%d", parent->devpath, port1);
416 417 418 419 420 421 422
			/* Route string assumes hubs have less than 16 ports */
			if (port1 < 15)
				dev->route = parent->route +
					(port1 << ((parent->level - 1)*4));
			else
				dev->route = parent->route +
					(15 << ((parent->level - 1)*4));
423
		}
L
Linus Torvalds 已提交
424 425

		dev->dev.parent = &parent->dev;
426
		dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
L
Linus Torvalds 已提交
427 428 429 430

		/* hub driver sets up TT records */
	}

431
	dev->portnum = port1;
L
Linus Torvalds 已提交
432 433 434 435
	dev->bus = bus;
	dev->parent = parent;
	INIT_LIST_HEAD(&dev->filelist);

436 437
#ifdef	CONFIG_PM
	mutex_init(&dev->pm_mutex);
D
David Howells 已提交
438
	INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
439
	INIT_WORK(&dev->autoresume, usb_autoresume_work);
440
	dev->autosuspend_delay = usb_autosuspend_delay * HZ;
S
Sarah Sharp 已提交
441 442
	dev->connect_time = jiffies;
	dev->active_duration = -jiffies;
443
#endif
444 445 446 447 448 449
	if (root_hub)	/* Root hub always ok [and always wired] */
		dev->authorized = 1;
	else {
		dev->authorized = usb_hcd->authorized_default;
		dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
	}
L
Linus Torvalds 已提交
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
	return dev;
}

/**
 * usb_get_dev - increments the reference count of the usb device structure
 * @dev: the device being referenced
 *
 * Each live reference to a device should be refcounted.
 *
 * Drivers for USB interfaces should normally record such references in
 * their probe() methods, when they bind to an interface, and release
 * them by calling usb_put_dev(), in their disconnect() methods.
 *
 * A pointer to the device with the incremented reference counter is returned.
 */
struct usb_device *usb_get_dev(struct usb_device *dev)
{
	if (dev)
		get_device(&dev->dev);
	return dev;
}
471
EXPORT_SYMBOL_GPL(usb_get_dev);
L
Linus Torvalds 已提交
472 473 474 475 476 477 478 479 480 481 482 483 484

/**
 * usb_put_dev - release a use of the usb device structure
 * @dev: device that's been disconnected
 *
 * Must be called when a user of a device is finished with it.  When the last
 * user of the device calls this function, the memory of the device is freed.
 */
void usb_put_dev(struct usb_device *dev)
{
	if (dev)
		put_device(&dev->dev);
}
485
EXPORT_SYMBOL_GPL(usb_put_dev);
L
Linus Torvalds 已提交
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505

/**
 * usb_get_intf - increments the reference count of the usb interface structure
 * @intf: the interface being referenced
 *
 * Each live reference to a interface must be refcounted.
 *
 * Drivers for USB interfaces should normally record such references in
 * their probe() methods, when they bind to an interface, and release
 * them by calling usb_put_intf(), in their disconnect() methods.
 *
 * A pointer to the interface with the incremented reference counter is
 * returned.
 */
struct usb_interface *usb_get_intf(struct usb_interface *intf)
{
	if (intf)
		get_device(&intf->dev);
	return intf;
}
506
EXPORT_SYMBOL_GPL(usb_get_intf);
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519 520

/**
 * usb_put_intf - release a use of the usb interface structure
 * @intf: interface that's been decremented
 *
 * Must be called when a user of an interface is finished with it.  When the
 * last user of the interface calls this function, the memory of the interface
 * is freed.
 */
void usb_put_intf(struct usb_interface *intf)
{
	if (intf)
		put_device(&intf->dev);
}
521
EXPORT_SYMBOL_GPL(usb_put_intf);
L
Linus Torvalds 已提交
522 523 524

/*			USB device locking
 *
525 526 527 528
 * USB devices and interfaces are locked using the semaphore in their
 * embedded struct device.  The hub driver guarantees that whenever a
 * device is connected or disconnected, drivers are called with the
 * USB device locked as well as their particular interface.
L
Linus Torvalds 已提交
529 530 531
 *
 * Complications arise when several devices are to be locked at the same
 * time.  Only hub-aware drivers that are part of usbcore ever have to
532 533
 * do this; nobody else needs to worry about it.  The rule for locking
 * is simple:
L
Linus Torvalds 已提交
534 535 536 537 538 539
 *
 *	When locking both a device and its parent, always lock the
 *	the parent first.
 */

/**
R
Randy Dunlap 已提交
540
 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
L
Linus Torvalds 已提交
541 542 543 544 545 546 547 548
 * @udev: device that's being locked
 * @iface: interface bound to the driver making the request (optional)
 *
 * Attempts to acquire the device lock, but fails if the device is
 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface
 * is neither BINDING nor BOUND.  Rather than sleeping to wait for the
 * lock, the routine polls repeatedly.  This is to prevent deadlock with
 * disconnect; in some drivers (such as usb-storage) the disconnect()
549
 * or suspend() method will block waiting for a device reset to complete.
L
Linus Torvalds 已提交
550
 *
551
 * Returns a negative error code for failure, otherwise 0.
L
Linus Torvalds 已提交
552 553
 */
int usb_lock_device_for_reset(struct usb_device *udev,
554
			      const struct usb_interface *iface)
L
Linus Torvalds 已提交
555
{
556 557
	unsigned long jiffies_expire = jiffies + HZ;

L
Linus Torvalds 已提交
558 559 560 561
	if (udev->state == USB_STATE_NOTATTACHED)
		return -ENODEV;
	if (udev->state == USB_STATE_SUSPENDED)
		return -EHOSTUNREACH;
562 563 564
	if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
			iface->condition == USB_INTERFACE_UNBOUND))
		return -EINTR;
L
Linus Torvalds 已提交
565

566
	while (usb_trylock_device(udev) != 0) {
567 568 569 570 571 572

		/* If we can't acquire the lock after waiting one second,
		 * we're probably deadlocked */
		if (time_after(jiffies, jiffies_expire))
			return -EBUSY;

L
Linus Torvalds 已提交
573 574 575 576 577
		msleep(15);
		if (udev->state == USB_STATE_NOTATTACHED)
			return -ENODEV;
		if (udev->state == USB_STATE_SUSPENDED)
			return -EHOSTUNREACH;
578 579
		if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
				iface->condition == USB_INTERFACE_UNBOUND))
L
Linus Torvalds 已提交
580 581
			return -EINTR;
	}
582
	return 0;
L
Linus Torvalds 已提交
583
}
584
EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
L
Linus Torvalds 已提交
585 586 587 588 589 590 591 592 593 594 595 596 597 598

static struct usb_device *match_device(struct usb_device *dev,
				       u16 vendor_id, u16 product_id)
{
	struct usb_device *ret_dev = NULL;
	int child;

	dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n",
	    le16_to_cpu(dev->descriptor.idVendor),
	    le16_to_cpu(dev->descriptor.idProduct));

	/* see if this device matches */
	if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) &&
	    (product_id == le16_to_cpu(dev->descriptor.idProduct))) {
599
		dev_dbg(&dev->dev, "matched this device!\n");
L
Linus Torvalds 已提交
600 601 602 603 604 605 606
		ret_dev = usb_get_dev(dev);
		goto exit;
	}

	/* look through all of the children of this device */
	for (child = 0; child < dev->maxchild; ++child) {
		if (dev->children[child]) {
607
			usb_lock_device(dev->children[child]);
L
Linus Torvalds 已提交
608 609
			ret_dev = match_device(dev->children[child],
					       vendor_id, product_id);
610
			usb_unlock_device(dev->children[child]);
L
Linus Torvalds 已提交
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
			if (ret_dev)
				goto exit;
		}
	}
exit:
	return ret_dev;
}

/**
 * usb_find_device - find a specific usb device in the system
 * @vendor_id: the vendor id of the device to find
 * @product_id: the product id of the device to find
 *
 * Returns a pointer to a struct usb_device if such a specified usb
 * device is present in the system currently.  The usage count of the
 * device will be incremented if a device is found.  Make sure to call
 * usb_put_dev() when the caller is finished with the device.
 *
 * If a device with the specified vendor and product id is not found,
 * NULL is returned.
 */
struct usb_device *usb_find_device(u16 vendor_id, u16 product_id)
{
	struct list_head *buslist;
	struct usb_bus *bus;
	struct usb_device *dev = NULL;
637

638
	mutex_lock(&usb_bus_list_lock);
L
Linus Torvalds 已提交
639
	for (buslist = usb_bus_list.next;
640
	     buslist != &usb_bus_list;
L
Linus Torvalds 已提交
641 642 643 644 645 646 647 648 649 650 651
	     buslist = buslist->next) {
		bus = container_of(buslist, struct usb_bus, bus_list);
		if (!bus->root_hub)
			continue;
		usb_lock_device(bus->root_hub);
		dev = match_device(bus->root_hub, vendor_id, product_id);
		usb_unlock_device(bus->root_hub);
		if (dev)
			goto exit;
	}
exit:
652
	mutex_unlock(&usb_bus_list_lock);
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
	return dev;
}

/**
 * usb_get_current_frame_number - return current bus frame number
 * @dev: the device whose bus is being queried
 *
 * Returns the current frame number for the USB host controller
 * used with the given USB device.  This can be used when scheduling
 * isochronous requests.
 *
 * Note that different kinds of host controller have different
 * "scheduling horizons".  While one type might support scheduling only
 * 32 frames into the future, others could support scheduling up to
 * 1024 frames into the future.
 */
int usb_get_current_frame_number(struct usb_device *dev)
{
671
	return usb_hcd_get_frame_number(dev);
L
Linus Torvalds 已提交
672
}
673
EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
L
Linus Torvalds 已提交
674 675 676 677 678 679 680 681

/*-------------------------------------------------------------------*/
/*
 * __usb_get_extra_descriptor() finds a descriptor of specific type in the
 * extra field of the interface and endpoint descriptor structs.
 */

int __usb_get_extra_descriptor(char *buffer, unsigned size,
682
			       unsigned char type, void **ptr)
L
Linus Torvalds 已提交
683 684 685 686 687 688 689 690 691 692
{
	struct usb_descriptor_header *header;

	while (size >= sizeof(struct usb_descriptor_header)) {
		header = (struct usb_descriptor_header *)buffer;

		if (header->bLength < 2) {
			printk(KERN_ERR
				"%s: bogus descriptor, type %d length %d\n",
				usbcore_name,
693
				header->bDescriptorType,
L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702 703 704 705 706 707
				header->bLength);
			return -1;
		}

		if (header->bDescriptorType == type) {
			*ptr = header;
			return 0;
		}

		buffer += header->bLength;
		size -= header->bLength;
	}
	return -1;
}
708
EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
L
Linus Torvalds 已提交
709 710 711 712 713 714 715 716 717 718 719 720 721 722

/**
 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
 * @dev: device the buffer will be used with
 * @size: requested buffer size
 * @mem_flags: affect whether allocation may block
 * @dma: used to return DMA address of buffer
 *
 * Return value is either null (indicating no buffer could be allocated), or
 * the cpu-space pointer to a buffer that may be used to perform DMA to the
 * specified device.  Such cpu-space buffers are returned along with the DMA
 * address (through the pointer provided).
 *
 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
D
David Brownell 已提交
723 724
 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
 * hardware during URB completion/resubmit.  The implementation varies between
L
Linus Torvalds 已提交
725
 * platforms, depending on details of how DMA will work to this device.
D
David Brownell 已提交
726 727 728
 * Using these buffers also eliminates cacheline sharing problems on
 * architectures where CPU caches are not DMA-coherent.  On systems without
 * bus-snooping caches, these buffers are uncached.
L
Linus Torvalds 已提交
729 730 731
 *
 * When the buffer is no longer used, free it with usb_buffer_free().
 */
732 733
void *usb_buffer_alloc(struct usb_device *dev, size_t size, gfp_t mem_flags,
		       dma_addr_t *dma)
L
Linus Torvalds 已提交
734
{
A
Alan Stern 已提交
735
	if (!dev || !dev->bus)
L
Linus Torvalds 已提交
736
		return NULL;
737
	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
L
Linus Torvalds 已提交
738
}
739
EXPORT_SYMBOL_GPL(usb_buffer_alloc);
L
Linus Torvalds 已提交
740 741 742 743 744 745 746 747 748 749

/**
 * usb_buffer_free - free memory allocated with usb_buffer_alloc()
 * @dev: device the buffer was used with
 * @size: requested buffer size
 * @addr: CPU address of buffer
 * @dma: DMA address of buffer
 *
 * This reclaims an I/O buffer, letting it be reused.  The memory must have
 * been allocated using usb_buffer_alloc(), and the parameters must match
D
David Brownell 已提交
750
 * those provided in that allocation request.
L
Linus Torvalds 已提交
751
 */
752 753
void usb_buffer_free(struct usb_device *dev, size_t size, void *addr,
		     dma_addr_t dma)
L
Linus Torvalds 已提交
754
{
A
Alan Stern 已提交
755
	if (!dev || !dev->bus)
756 757 758
		return;
	if (!addr)
		return;
759
	hcd_buffer_free(dev->bus, size, addr, dma);
L
Linus Torvalds 已提交
760
}
761
EXPORT_SYMBOL_GPL(usb_buffer_free);
L
Linus Torvalds 已提交
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779

/**
 * usb_buffer_map - create DMA mapping(s) for an urb
 * @urb: urb whose transfer_buffer/setup_packet will be mapped
 *
 * Return value is either null (indicating no buffer could be mapped), or
 * the parameter.  URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are
 * added to urb->transfer_flags if the operation succeeds.  If the device
 * is connected to this system through a non-DMA controller, this operation
 * always succeeds.
 *
 * This call would normally be used for an urb which is reused, perhaps
 * as the target of a large periodic transfer, with usb_buffer_dmasync()
 * calls to synchronize memory and dma state.
 *
 * Reverse the effect of this call with usb_buffer_unmap().
 */
#if 0
780
struct urb *usb_buffer_map(struct urb *urb)
L
Linus Torvalds 已提交
781 782 783 784 785 786 787 788 789 790 791
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!urb
			|| !urb->dev
			|| !(bus = urb->dev->bus)
			|| !(controller = bus->controller))
		return NULL;

	if (controller->dma_mask) {
792
		urb->transfer_dma = dma_map_single(controller,
L
Linus Torvalds 已提交
793
			urb->transfer_buffer, urb->transfer_buffer_length,
794
			usb_pipein(urb->pipe)
L
Linus Torvalds 已提交
795
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
796 797
		if (usb_pipecontrol(urb->pipe))
			urb->setup_dma = dma_map_single(controller,
L
Linus Torvalds 已提交
798
					urb->setup_packet,
799
					sizeof(struct usb_ctrlrequest),
L
Linus Torvalds 已提交
800
					DMA_TO_DEVICE);
801 802
	/* FIXME generic api broken like pci, can't report errors */
	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
L
Linus Torvalds 已提交
803 804 805 806 807 808
	} else
		urb->transfer_dma = ~0;
	urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP
				| URB_NO_SETUP_DMA_MAP);
	return urb;
}
809
EXPORT_SYMBOL_GPL(usb_buffer_map);
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819 820 821 822
#endif  /*  0  */

/* XXX DISABLED, no users currently.  If you wish to re-enable this
 * XXX please determine whether the sync is to transfer ownership of
 * XXX the buffer from device to cpu or vice verse, and thusly use the
 * XXX appropriate _for_{cpu,device}() method.  -DaveM
 */
#if 0

/**
 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
 * @urb: urb whose transfer_buffer/setup_packet will be synchronized
 */
823
void usb_buffer_dmasync(struct urb *urb)
L
Linus Torvalds 已提交
824 825 826 827 828 829 830 831 832 833 834 835
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!urb
			|| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
			|| !urb->dev
			|| !(bus = urb->dev->bus)
			|| !(controller = bus->controller))
		return;

	if (controller->dma_mask) {
836
		dma_sync_single_for_cpu(controller,
L
Linus Torvalds 已提交
837
			urb->transfer_dma, urb->transfer_buffer_length,
838
			usb_pipein(urb->pipe)
L
Linus Torvalds 已提交
839
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
840
		if (usb_pipecontrol(urb->pipe))
841
			dma_sync_single_for_cpu(controller,
L
Linus Torvalds 已提交
842
					urb->setup_dma,
843
					sizeof(struct usb_ctrlrequest),
L
Linus Torvalds 已提交
844 845 846
					DMA_TO_DEVICE);
	}
}
847
EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
L
Linus Torvalds 已提交
848 849 850 851 852 853 854 855 856
#endif

/**
 * usb_buffer_unmap - free DMA mapping(s) for an urb
 * @urb: urb whose transfer_buffer will be unmapped
 *
 * Reverses the effect of usb_buffer_map().
 */
#if 0
857
void usb_buffer_unmap(struct urb *urb)
L
Linus Torvalds 已提交
858 859 860 861 862 863 864 865 866 867 868 869
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!urb
			|| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
			|| !urb->dev
			|| !(bus = urb->dev->bus)
			|| !(controller = bus->controller))
		return;

	if (controller->dma_mask) {
870
		dma_unmap_single(controller,
L
Linus Torvalds 已提交
871
			urb->transfer_dma, urb->transfer_buffer_length,
872
			usb_pipein(urb->pipe)
L
Linus Torvalds 已提交
873
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
874 875
		if (usb_pipecontrol(urb->pipe))
			dma_unmap_single(controller,
L
Linus Torvalds 已提交
876
					urb->setup_dma,
877
					sizeof(struct usb_ctrlrequest),
L
Linus Torvalds 已提交
878 879 880 881 882
					DMA_TO_DEVICE);
	}
	urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP
				| URB_NO_SETUP_DMA_MAP);
}
883
EXPORT_SYMBOL_GPL(usb_buffer_unmap);
L
Linus Torvalds 已提交
884 885 886 887 888
#endif  /*  0  */

/**
 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
 * @dev: device to which the scatterlist will be mapped
A
Alan Stern 已提交
889
 * @is_in: mapping transfer direction
L
Linus Torvalds 已提交
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
 * @sg: the scatterlist to map
 * @nents: the number of entries in the scatterlist
 *
 * Return value is either < 0 (indicating no buffers could be mapped), or
 * the number of DMA mapping array entries in the scatterlist.
 *
 * The caller is responsible for placing the resulting DMA addresses from
 * the scatterlist into URB transfer buffer pointers, and for setting the
 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
 *
 * Top I/O rates come from queuing URBs, instead of waiting for each one
 * to complete before starting the next I/O.   This is particularly easy
 * to do with scatterlists.  Just allocate and submit one URB for each DMA
 * mapping entry returned, stopping on the first error or when all succeed.
 * Better yet, use the usb_sg_*() calls, which do that (and more) for you.
 *
 * This call would normally be used when translating scatterlist requests,
 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
 * may be able to coalesce mappings for improved I/O efficiency.
 *
 * Reverse the effect of this call with usb_buffer_unmap_sg().
 */
A
Alan Stern 已提交
912
int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
913
		      struct scatterlist *sg, int nents)
L
Linus Torvalds 已提交
914 915 916 917 918 919 920 921
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!dev
			|| !(bus = dev->bus)
			|| !(controller = bus->controller)
			|| !controller->dma_mask)
922
		return -EINVAL;
L
Linus Torvalds 已提交
923

924
	/* FIXME generic api broken like pci, can't report errors */
925
	return dma_map_sg(controller, sg, nents,
926
			is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
L
Linus Torvalds 已提交
927
}
928
EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
L
Linus Torvalds 已提交
929 930 931 932 933 934 935 936 937 938 939

/* XXX DISABLED, no users currently.  If you wish to re-enable this
 * XXX please determine whether the sync is to transfer ownership of
 * XXX the buffer from device to cpu or vice verse, and thusly use the
 * XXX appropriate _for_{cpu,device}() method.  -DaveM
 */
#if 0

/**
 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
 * @dev: device to which the scatterlist will be mapped
A
Alan Stern 已提交
940
 * @is_in: mapping transfer direction
L
Linus Torvalds 已提交
941 942 943 944 945 946
 * @sg: the scatterlist to synchronize
 * @n_hw_ents: the positive return value from usb_buffer_map_sg
 *
 * Use this when you are re-using a scatterlist's data buffers for
 * another USB request.
 */
A
Alan Stern 已提交
947
void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
948
			   struct scatterlist *sg, int n_hw_ents)
L
Linus Torvalds 已提交
949 950 951 952 953 954 955 956 957 958
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!dev
			|| !(bus = dev->bus)
			|| !(controller = bus->controller)
			|| !controller->dma_mask)
		return;

959 960
	dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
			    is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
L
Linus Torvalds 已提交
961
}
962
EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
L
Linus Torvalds 已提交
963 964 965 966 967
#endif

/**
 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
 * @dev: device to which the scatterlist will be mapped
A
Alan Stern 已提交
968
 * @is_in: mapping transfer direction
L
Linus Torvalds 已提交
969 970 971 972 973
 * @sg: the scatterlist to unmap
 * @n_hw_ents: the positive return value from usb_buffer_map_sg
 *
 * Reverses the effect of usb_buffer_map_sg().
 */
A
Alan Stern 已提交
974
void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
975
			 struct scatterlist *sg, int n_hw_ents)
L
Linus Torvalds 已提交
976 977 978 979 980 981 982 983 984 985
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!dev
			|| !(bus = dev->bus)
			|| !(controller = bus->controller)
			|| !controller->dma_mask)
		return;

986
	dma_unmap_sg(controller, sg, n_hw_ents,
A
Alan Stern 已提交
987
			is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
L
Linus Torvalds 已提交
988
}
989
EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
L
Linus Torvalds 已提交
990

991 992 993 994 995 996
/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
#ifdef MODULE
module_param(nousb, bool, 0444);
#else
core_param(nousb, nousb, bool, 0444);
#endif
L
Linus Torvalds 已提交
997 998 999 1000 1001 1002 1003 1004

/*
 * for external read access to <nousb>
 */
int usb_disabled(void)
{
	return nousb;
}
1005
EXPORT_SYMBOL_GPL(usb_disabled);
L
Linus Torvalds 已提交
1006

A
Alan Stern 已提交
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
/*
 * Notifications of device and interface registration
 */
static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
		void *data)
{
	struct device *dev = data;

	switch (action) {
	case BUS_NOTIFY_ADD_DEVICE:
		if (dev->type == &usb_device_type)
			(void) usb_create_sysfs_dev_files(to_usb_device(dev));
		else if (dev->type == &usb_if_device_type)
			(void) usb_create_sysfs_intf_files(
					to_usb_interface(dev));
		break;

	case BUS_NOTIFY_DEL_DEVICE:
		if (dev->type == &usb_device_type)
			usb_remove_sysfs_dev_files(to_usb_device(dev));
		else if (dev->type == &usb_if_device_type)
			usb_remove_sysfs_intf_files(to_usb_interface(dev));
		break;
	}
	return 0;
}

static struct notifier_block usb_bus_nb = {
	.notifier_call = usb_bus_notify,
};

1038 1039 1040
struct dentry *usb_debug_root;
EXPORT_SYMBOL_GPL(usb_debug_root);

1041 1042
struct dentry *usb_debug_devices;

1043 1044 1045 1046 1047
static int usb_debugfs_init(void)
{
	usb_debug_root = debugfs_create_dir("usb", NULL);
	if (!usb_debug_root)
		return -ENOENT;
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057

	usb_debug_devices = debugfs_create_file("devices", 0444,
						usb_debug_root, NULL,
						&usbfs_devices_fops);
	if (!usb_debug_devices) {
		debugfs_remove(usb_debug_root);
		usb_debug_root = NULL;
		return -ENOENT;
	}

1058 1059 1060 1061 1062
	return 0;
}

static void usb_debugfs_cleanup(void)
{
1063
	debugfs_remove(usb_debug_devices);
1064 1065 1066
	debugfs_remove(usb_debug_root);
}

L
Linus Torvalds 已提交
1067 1068 1069 1070 1071 1072 1073
/*
 * Init
 */
static int __init usb_init(void)
{
	int retval;
	if (nousb) {
1074
		pr_info("%s: USB support disabled\n", usbcore_name);
L
Linus Torvalds 已提交
1075 1076 1077
		return 0;
	}

1078 1079 1080 1081
	retval = usb_debugfs_init();
	if (retval)
		goto out;

1082 1083 1084
	retval = ksuspend_usb_init();
	if (retval)
		goto out;
L
Linus Torvalds 已提交
1085
	retval = bus_register(&usb_bus_type);
1086
	if (retval)
1087
		goto bus_register_failed;
A
Alan Stern 已提交
1088 1089 1090
	retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
	if (retval)
		goto bus_notifier_failed;
L
Linus Torvalds 已提交
1091 1092 1093
	retval = usb_major_init();
	if (retval)
		goto major_init_failed;
1094 1095 1096
	retval = usb_register(&usbfs_driver);
	if (retval)
		goto driver_register_failed;
1097
	retval = usb_devio_init();
1098
	if (retval)
1099
		goto usb_devio_init_failed;
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105
	retval = usbfs_init();
	if (retval)
		goto fs_init_failed;
	retval = usb_hub_init();
	if (retval)
		goto hub_init_failed;
1106
	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112 1113
	if (!retval)
		goto out;

	usb_hub_cleanup();
hub_init_failed:
	usbfs_cleanup();
fs_init_failed:
1114 1115
	usb_devio_cleanup();
usb_devio_init_failed:
1116 1117 1118
	usb_deregister(&usbfs_driver);
driver_register_failed:
	usb_major_cleanup();
L
Linus Torvalds 已提交
1119
major_init_failed:
A
Alan Stern 已提交
1120 1121
	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_notifier_failed:
L
Linus Torvalds 已提交
1122
	bus_unregister(&usb_bus_type);
1123 1124
bus_register_failed:
	ksuspend_usb_cleanup();
L
Linus Torvalds 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
out:
	return retval;
}

/*
 * Cleanup
 */
static void __exit usb_exit(void)
{
	/* This will matter if shutdown/reboot does exitcalls. */
	if (nousb)
		return;

1138
	usb_deregister_device_driver(&usb_generic_driver);
L
Linus Torvalds 已提交
1139 1140
	usb_major_cleanup();
	usbfs_cleanup();
1141
	usb_deregister(&usbfs_driver);
1142
	usb_devio_cleanup();
L
Linus Torvalds 已提交
1143
	usb_hub_cleanup();
A
Alan Stern 已提交
1144
	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
L
Linus Torvalds 已提交
1145
	bus_unregister(&usb_bus_type);
1146
	ksuspend_usb_cleanup();
1147
	usb_debugfs_cleanup();
L
Linus Torvalds 已提交
1148 1149 1150 1151 1152
}

subsys_initcall(usb_init);
module_exit(usb_exit);
MODULE_LICENSE("GPL");