usb.c 30.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * drivers/usb/core/usb.c
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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/usb/hcd.h>
36
#include <linux/mutex.h>
37
#include <linux/workqueue.h>
38
#include <linux/debugfs.h>
Linus Torvalds's avatar
Linus Torvalds committed
39
40

#include <asm/io.h>
41
#include <linux/scatterlist.h>
Linus Torvalds's avatar
Linus Torvalds committed
42
43
44
45
46
47
48
49
#include <linux/mm.h>
#include <linux/dma-mapping.h>

#include "usb.h"


const char *usbcore_name = "usbcore";

50
static bool nousb;	/* Disable USB when built into kernel image */
Linus Torvalds's avatar
Linus Torvalds committed
51

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

#else
#define usb_autosuspend_delay		0
#endif

Linus Torvalds's avatar
Linus Torvalds committed
62

63
64
65
/**
 * usb_find_alt_setting() - Given a configuration, find the alternate setting
 * for the given interface.
66
67
68
 * @config: the configuration to search (not necessarily the current config).
 * @iface_num: interface number to search in
 * @alt_num: alternate interface setting number to search for.
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 *
 * Search the configuration's interface cache for the given alt setting.
 */
struct usb_host_interface *usb_find_alt_setting(
		struct usb_host_config *config,
		unsigned int iface_num,
		unsigned int alt_num)
{
	struct usb_interface_cache *intf_cache = NULL;
	int i;

	for (i = 0; i < config->desc.bNumInterfaces; i++) {
		if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
				== iface_num) {
			intf_cache = config->intf_cache[i];
			break;
		}
	}
	if (!intf_cache)
		return NULL;
	for (i = 0; i < intf_cache->num_altsetting; i++)
		if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
			return &intf_cache->altsetting[i];

	printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
			"config %u\n", alt_num, iface_num,
			config->desc.bConfigurationValue);
	return NULL;
}
EXPORT_SYMBOL_GPL(usb_find_alt_setting);

Linus Torvalds's avatar
Linus Torvalds committed
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/**
 * 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!
 */
119
120
struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
				      unsigned ifnum)
Linus Torvalds's avatar
Linus Torvalds committed
121
122
123
124
125
126
127
128
129
130
131
132
133
{
	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;
}
134
EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
Linus Torvalds's avatar
Linus Torvalds committed
135
136

/**
Randy Dunlap's avatar
Randy Dunlap committed
137
 * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
Linus Torvalds's avatar
Linus Torvalds committed
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 * @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!
 */
153
154
155
struct usb_host_interface *usb_altnum_to_altsetting(
					const struct usb_interface *intf,
					unsigned int altnum)
Linus Torvalds's avatar
Linus Torvalds committed
156
157
158
159
160
161
162
163
164
{
	int i;

	for (i = 0; i < intf->num_altsetting; i++) {
		if (intf->altsetting[i].desc.bAlternateSetting == altnum)
			return &intf->altsetting[i];
	}
	return NULL;
}
165
EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
Linus Torvalds's avatar
Linus Torvalds committed
166

167
168
struct find_interface_arg {
	int minor;
169
	struct device_driver *drv;
170
171
};

172
static int __find_interface(struct device *dev, void *data)
173
{
174
	struct find_interface_arg *arg = data;
175
	struct usb_interface *intf;
176

177
	if (!is_usb_interface(dev))
178
179
		return 0;

180
181
	if (dev->driver != arg->drv)
		return 0;
182
	intf = to_usb_interface(dev);
183
	return intf->minor == arg->minor;
184
185
}

Linus Torvalds's avatar
Linus Torvalds committed
186
187
188
189
190
/**
 * 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
 *
Russ Dill's avatar
Russ Dill committed
191
 * This walks the bus device list and returns a pointer to the interface
192
193
 * with the matching minor and driver.  Note, this only works for devices
 * that share the USB major number.
Linus Torvalds's avatar
Linus Torvalds committed
194
195
196
 */
struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
{
197
	struct find_interface_arg argb;
Russ Dill's avatar
Russ Dill committed
198
199
	struct device *dev;

200
	argb.minor = minor;
201
202
203
	argb.drv = &drv->drvwrap.driver;

	dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
Russ Dill's avatar
Russ Dill committed
204
205
206
207
208

	/* Drop reference count from bus_find_device */
	put_device(dev);

	return dev ? to_usb_interface(dev) : NULL;
Linus Torvalds's avatar
Linus Torvalds committed
209
}
210
EXPORT_SYMBOL_GPL(usb_find_interface);
Linus Torvalds's avatar
Linus Torvalds committed
211
212
213
214
215
216
217
218
219
220
221

/**
 * 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;
222
	struct usb_hcd *hcd;
Linus Torvalds's avatar
Linus Torvalds committed
223
224

	udev = to_usb_device(dev);
225
	hcd = bus_to_hcd(udev->bus);
Linus Torvalds's avatar
Linus Torvalds committed
226
227

	usb_destroy_configuration(udev);
Andiry Xu's avatar
Andiry Xu committed
228
	usb_release_bos_descriptor(udev);
229
	usb_put_hcd(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
230
231
232
233
234
235
	kfree(udev->product);
	kfree(udev->manufacturer);
	kfree(udev->serial);
	kfree(udev);
}

Alan Stern's avatar
Alan Stern committed
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#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 */

260
261
#ifdef	CONFIG_PM

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
/* 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 */
277
	usb_resume_complete(dev);
278
279
280
281
282
283
284
285
286
}

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

static int usb_dev_resume(struct device *dev)
{
287
	return usb_resume(dev, PMSG_RESUME);
288
289
290
291
292
293
294
295
296
}

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

static int usb_dev_thaw(struct device *dev)
{
297
	return usb_resume(dev, PMSG_THAW);
298
299
300
301
302
303
304
305
306
}

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

static int usb_dev_restore(struct device *dev)
{
307
	return usb_resume(dev, PMSG_RESTORE);
308
309
}

310
static const struct dev_pm_ops usb_device_pm_ops = {
311
312
313
314
315
316
317
318
	.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,
319
320
321
322
323
#ifdef CONFIG_USB_SUSPEND
	.runtime_suspend =	usb_runtime_suspend,
	.runtime_resume =	usb_runtime_resume,
	.runtime_idle =		usb_runtime_idle,
#endif
324
325
};

326
#endif	/* CONFIG_PM */
327

328

329
static char *usb_devnode(struct device *dev, umode_t *mode)
330
331
332
333
334
335
336
337
{
	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);
}

338
339
340
341
struct device_type usb_device_type = {
	.name =		"usb_device",
	.release =	usb_release_dev,
	.uevent =	usb_dev_uevent,
342
	.devnode = 	usb_devnode,
343
#ifdef CONFIG_PM
344
	.pm =		&usb_device_pm_ops,
345
#endif
346
347
};

348
349
350
351
352
353
354
355
356

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


Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
/**
 * 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
362
 * Context: !in_interrupt()
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
366
367
368
 *
 * 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.
 */
369
370
struct usb_device *usb_alloc_dev(struct usb_device *parent,
				 struct usb_bus *bus, unsigned port1)
Linus Torvalds's avatar
Linus Torvalds committed
371
372
{
	struct usb_device *dev;
373
374
	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
	unsigned root_hub = 0;
Linus Torvalds's avatar
Linus Torvalds committed
375

376
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
377
378
379
	if (!dev)
		return NULL;

380
	if (!usb_get_hcd(bus_to_hcd(bus))) {
Linus Torvalds's avatar
Linus Torvalds committed
381
382
383
		kfree(dev);
		return NULL;
	}
384
385
386
387
388
389
390
	/* 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;
	}
Linus Torvalds's avatar
Linus Torvalds committed
391
392
393

	device_initialize(&dev->dev);
	dev->dev.bus = &usb_bus_type;
394
	dev->dev.type = &usb_device_type;
395
	dev->dev.groups = usb_device_groups;
Linus Torvalds's avatar
Linus Torvalds committed
396
	dev->dev.dma_mask = bus->controller->dma_mask;
397
	set_dev_node(&dev->dev, dev_to_node(bus->controller));
Linus Torvalds's avatar
Linus Torvalds committed
398
	dev->state = USB_STATE_ATTACHED;
399
	atomic_set(&dev->urbnum, 0);
Linus Torvalds's avatar
Linus Torvalds committed
400
401
402
403
404

	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 */
405
	usb_enable_endpoint(dev, &dev->ep0, false);
406
	dev->can_submit = 1;
Linus Torvalds's avatar
Linus Torvalds committed
407
408
409
410
411

	/* 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
412
	 * are often labeled with these port numbers.  The name isn't
Linus Torvalds's avatar
Linus Torvalds committed
413
414
415
	 * as stable:  bus->busnum changes easily from modprobe order,
	 * cardbus or pci hotplugging, and so on.
	 */
416
417
	if (unlikely(!parent)) {
		dev->devpath[0] = '0';
418
		dev->route = 0;
Linus Torvalds's avatar
Linus Torvalds committed
419
420

		dev->dev.parent = bus->controller;
421
		dev_set_name(&dev->dev, "usb%d", bus->busnum);
422
		root_hub = 1;
Linus Torvalds's avatar
Linus Torvalds committed
423
424
	} else {
		/* match any labeling on the hubs; it's one-based */
425
		if (parent->devpath[0] == '0') {
426
			snprintf(dev->devpath, sizeof dev->devpath,
Linus Torvalds's avatar
Linus Torvalds committed
427
				"%d", port1);
428
429
430
			/* Root ports are not counted in route string */
			dev->route = 0;
		} else {
431
			snprintf(dev->devpath, sizeof dev->devpath,
Linus Torvalds's avatar
Linus Torvalds committed
432
				"%s.%d", parent->devpath, port1);
433
434
435
436
437
438
439
			/* 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));
440
		}
Linus Torvalds's avatar
Linus Torvalds committed
441
442

		dev->dev.parent = &parent->dev;
443
		dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
Linus Torvalds's avatar
Linus Torvalds committed
444
445
446
447

		/* hub driver sets up TT records */
	}

448
	dev->portnum = port1;
Linus Torvalds's avatar
Linus Torvalds committed
449
450
451
452
	dev->bus = bus;
	dev->parent = parent;
	INIT_LIST_HEAD(&dev->filelist);

453
#ifdef	CONFIG_PM
454
455
	pm_runtime_set_autosuspend_delay(&dev->dev,
			usb_autosuspend_delay * 1000);
Sarah Sharp's avatar
Sarah Sharp committed
456
457
	dev->connect_time = jiffies;
	dev->active_duration = -jiffies;
458
#endif
459
460
461
462
463
464
	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;
	}
Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
	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;
}
486
EXPORT_SYMBOL_GPL(usb_get_dev);
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
491
492
493
494
495
496
497
498
499

/**
 * 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);
}
500
EXPORT_SYMBOL_GPL(usb_put_dev);
Linus Torvalds's avatar
Linus Torvalds committed
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520

/**
 * 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;
}
521
EXPORT_SYMBOL_GPL(usb_get_intf);
Linus Torvalds's avatar
Linus Torvalds committed
522
523
524
525
526
527
528
529
530
531
532
533
534
535

/**
 * 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);
}
536
EXPORT_SYMBOL_GPL(usb_put_intf);
Linus Torvalds's avatar
Linus Torvalds committed
537
538
539

/*			USB device locking
 *
540
541
542
543
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
544
545
546
 *
 * 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
547
548
 * do this; nobody else needs to worry about it.  The rule for locking
 * is simple:
Linus Torvalds's avatar
Linus Torvalds committed
549
550
551
552
553
554
 *
 *	When locking both a device and its parent, always lock the
 *	the parent first.
 */

/**
Randy Dunlap's avatar
Randy Dunlap committed
555
 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
Linus Torvalds's avatar
Linus Torvalds committed
556
557
558
559
560
561
562
563
 * @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()
564
 * or suspend() method will block waiting for a device reset to complete.
Linus Torvalds's avatar
Linus Torvalds committed
565
 *
566
 * Returns a negative error code for failure, otherwise 0.
Linus Torvalds's avatar
Linus Torvalds committed
567
568
 */
int usb_lock_device_for_reset(struct usb_device *udev,
569
			      const struct usb_interface *iface)
Linus Torvalds's avatar
Linus Torvalds committed
570
{
571
572
	unsigned long jiffies_expire = jiffies + HZ;

Linus Torvalds's avatar
Linus Torvalds committed
573
574
575
576
	if (udev->state == USB_STATE_NOTATTACHED)
		return -ENODEV;
	if (udev->state == USB_STATE_SUSPENDED)
		return -EHOSTUNREACH;
577
578
579
	if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
			iface->condition == USB_INTERFACE_UNBOUND))
		return -EINTR;
Linus Torvalds's avatar
Linus Torvalds committed
580

581
	while (!usb_trylock_device(udev)) {
582
583
584
585
586
587

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

Linus Torvalds's avatar
Linus Torvalds committed
588
589
590
591
592
		msleep(15);
		if (udev->state == USB_STATE_NOTATTACHED)
			return -ENODEV;
		if (udev->state == USB_STATE_SUSPENDED)
			return -EHOSTUNREACH;
593
594
		if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
				iface->condition == USB_INTERFACE_UNBOUND))
Linus Torvalds's avatar
Linus Torvalds committed
595
596
			return -EINTR;
	}
597
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
598
}
599
EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
Linus Torvalds's avatar
Linus Torvalds committed
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615

/**
 * 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)
{
616
	return usb_hcd_get_frame_number(dev);
Linus Torvalds's avatar
Linus Torvalds committed
617
}
618
EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
Linus Torvalds's avatar
Linus Torvalds committed
619
620
621
622
623
624
625
626

/*-------------------------------------------------------------------*/
/*
 * __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,
627
			       unsigned char type, void **ptr)
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
632
633
634
635
636
637
{
	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,
638
				header->bDescriptorType,
Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
642
643
644
645
646
647
648
649
650
651
652
				header->bLength);
			return -1;
		}

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

		buffer += header->bLength;
		size -= header->bLength;
	}
	return -1;
}
653
EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
Linus Torvalds's avatar
Linus Torvalds committed
654
655

/**
656
 * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
Linus Torvalds's avatar
Linus Torvalds committed
657
658
659
660
661
662
663
664
665
666
667
 * @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
David Brownell's avatar
David Brownell committed
668
669
 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
 * hardware during URB completion/resubmit.  The implementation varies between
Linus Torvalds's avatar
Linus Torvalds committed
670
 * platforms, depending on details of how DMA will work to this device.
David Brownell's avatar
David Brownell committed
671
672
673
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
674
 *
675
 * When the buffer is no longer used, free it with usb_free_coherent().
Linus Torvalds's avatar
Linus Torvalds committed
676
 */
677
678
void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
			 dma_addr_t *dma)
Linus Torvalds's avatar
Linus Torvalds committed
679
{
Alan Stern's avatar
Alan Stern committed
680
	if (!dev || !dev->bus)
Linus Torvalds's avatar
Linus Torvalds committed
681
		return NULL;
682
	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
Linus Torvalds's avatar
Linus Torvalds committed
683
}
684
EXPORT_SYMBOL_GPL(usb_alloc_coherent);
Linus Torvalds's avatar
Linus Torvalds committed
685
686

/**
687
 * usb_free_coherent - free memory allocated with usb_alloc_coherent()
Linus Torvalds's avatar
Linus Torvalds committed
688
689
690
691
692
693
 * @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
694
 * been allocated using usb_alloc_coherent(), and the parameters must match
David Brownell's avatar
David Brownell committed
695
 * those provided in that allocation request.
Linus Torvalds's avatar
Linus Torvalds committed
696
 */
697
698
void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
		       dma_addr_t dma)
Linus Torvalds's avatar
Linus Torvalds committed
699
{
Alan Stern's avatar
Alan Stern committed
700
	if (!dev || !dev->bus)
701
702
703
		return;
	if (!addr)
		return;
704
	hcd_buffer_free(dev->bus, size, addr, dma);
Linus Torvalds's avatar
Linus Torvalds committed
705
}
706
EXPORT_SYMBOL_GPL(usb_free_coherent);
Linus Torvalds's avatar
Linus Torvalds committed
707
708
709
710
711
712

/**
 * 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
713
 * the parameter.  URB_NO_TRANSFER_DMA_MAP is
Linus Torvalds's avatar
Linus Torvalds committed
714
715
716
717
718
719
720
721
722
723
724
 * 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
725
struct urb *usb_buffer_map(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
726
727
728
729
730
731
732
733
734
735
736
{
	struct usb_bus		*bus;
	struct device		*controller;

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

	if (controller->dma_mask) {
737
		urb->transfer_dma = dma_map_single(controller,
Linus Torvalds's avatar
Linus Torvalds committed
738
			urb->transfer_buffer, urb->transfer_buffer_length,
739
			usb_pipein(urb->pipe)
Linus Torvalds's avatar
Linus Torvalds committed
740
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
741
742
	/* FIXME generic api broken like pci, can't report errors */
	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
Linus Torvalds's avatar
Linus Torvalds committed
743
744
	} else
		urb->transfer_dma = ~0;
745
	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
746
747
	return urb;
}
748
EXPORT_SYMBOL_GPL(usb_buffer_map);
Linus Torvalds's avatar
Linus Torvalds committed
749
750
751
752
753
754
755
756
757
758
759
760
761
#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
 */
762
void usb_buffer_dmasync(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
767
768
769
770
771
772
773
774
{
	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) {
775
		dma_sync_single_for_cpu(controller,
Linus Torvalds's avatar
Linus Torvalds committed
776
			urb->transfer_dma, urb->transfer_buffer_length,
777
			usb_pipein(urb->pipe)
Linus Torvalds's avatar
Linus Torvalds committed
778
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
779
		if (usb_pipecontrol(urb->pipe))
780
			dma_sync_single_for_cpu(controller,
Linus Torvalds's avatar
Linus Torvalds committed
781
					urb->setup_dma,
782
					sizeof(struct usb_ctrlrequest),
Linus Torvalds's avatar
Linus Torvalds committed
783
784
785
					DMA_TO_DEVICE);
	}
}
786
EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
Linus Torvalds's avatar
Linus Torvalds committed
787
788
789
790
791
792
793
794
795
#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
796
void usb_buffer_unmap(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
797
798
799
800
801
802
803
804
805
806
807
808
{
	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) {
809
		dma_unmap_single(controller,
Linus Torvalds's avatar
Linus Torvalds committed
810
			urb->transfer_dma, urb->transfer_buffer_length,
811
			usb_pipein(urb->pipe)
Linus Torvalds's avatar
Linus Torvalds committed
812
813
				? DMA_FROM_DEVICE : DMA_TO_DEVICE);
	}
814
	urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
815
}
816
EXPORT_SYMBOL_GPL(usb_buffer_unmap);
Linus Torvalds's avatar
Linus Torvalds committed
817
818
#endif  /*  0  */

819
#if 0
Linus Torvalds's avatar
Linus Torvalds committed
820
821
822
/**
 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
 * @dev: device to which the scatterlist will be mapped
823
 * @is_in: mapping transfer direction
Linus Torvalds's avatar
Linus Torvalds committed
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
 * @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().
 */
846
int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
847
		      struct scatterlist *sg, int nents)
Linus Torvalds's avatar
Linus Torvalds committed
848
849
850
851
852
853
854
855
{
	struct usb_bus		*bus;
	struct device		*controller;

	if (!dev
			|| !(bus = dev->bus)
			|| !(controller = bus->controller)
			|| !controller->dma_mask)
856
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
857

858
	/* FIXME generic api broken like pci, can't report errors */
859
	return dma_map_sg(controller, sg, nents,
860
			is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
861
}
862
EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
863
#endif
Linus Torvalds's avatar
Linus Torvalds committed
864
865
866
867
868
869
870
871
872
873
874

/* 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
875
 * @is_in: mapping transfer direction
Linus Torvalds's avatar
Linus Torvalds committed
876
877
878
879
880
881
 * @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.
 */
882
void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
883
			   struct scatterlist *sg, int n_hw_ents)
Linus Torvalds's avatar
Linus Torvalds committed
884
885
886
887
888
889
890
891
892
893
{
	struct usb_bus		*bus;
	struct device		*controller;

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

894
895
	dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
			    is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed
896
}
897
EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
Linus Torvalds's avatar
Linus Torvalds committed
898
899
#endif

900
#if 0
Linus Torvalds's avatar
Linus Torvalds committed
901
902
903
/**
 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
 * @dev: device to which the scatterlist will be mapped
904
 * @is_in: mapping transfer direction
Linus Torvalds's avatar
Linus Torvalds committed
905
906
907
908
909
 * @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().
 */
910
void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
911
			 struct scatterlist *sg, int n_hw_ents)
Linus Torvalds's avatar
Linus Torvalds committed
912
913
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)
		return;

922
	dma_unmap_sg(controller, sg, n_hw_ents,
923
			is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed
924
}
925
EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
926
#endif
Linus Torvalds's avatar
Linus Torvalds committed
927

928
929
930
931
932
933
/* 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
Linus Torvalds's avatar
Linus Torvalds committed
934
935
936
937
938
939
940
941

/*
 * for external read access to <nousb>
 */
int usb_disabled(void)
{
	return nousb;
}
942
EXPORT_SYMBOL_GPL(usb_disabled);
Linus Torvalds's avatar
Linus Torvalds committed
943

Alan Stern's avatar
Alan Stern committed
944
945
946
947
948
949
950
951
952
953
954
955
956
/*
 * 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)
957
			usb_create_sysfs_intf_files(to_usb_interface(dev));
Alan Stern's avatar
Alan Stern committed
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
		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,
};

974
975
976
struct dentry *usb_debug_root;
EXPORT_SYMBOL_GPL(usb_debug_root);

977
static struct dentry *usb_debug_devices;
978

979
980
981
982
983
static int usb_debugfs_init(void)
{
	usb_debug_root = debugfs_create_dir("usb", NULL);
	if (!usb_debug_root)
		return -ENOENT;
984
985
986
987
988
989
990
991
992
993

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

994
995
996
997
998
	return 0;
}

static void usb_debugfs_cleanup(void)
{
999
	debugfs_remove(usb_debug_devices);
1000
1001
1002
	debugfs_remove(usb_debug_root);
}

Linus Torvalds's avatar
Linus Torvalds committed
1003
1004
1005
1006
1007
1008
1009
/*
 * Init
 */
static int __init usb_init(void)
{
	int retval;
	if (nousb) {
1010
		pr_info("%s: USB support disabled\n", usbcore_name);
Linus Torvalds's avatar
Linus Torvalds committed
1011
1012
1013
		return 0;
	}

1014
1015
1016
1017
	retval = usb_debugfs_init();
	if (retval)
		goto out;

Linus Torvalds's avatar
Linus Torvalds committed
1018
	retval = bus_register(&usb_bus_type);
1019
	if (retval)
1020
		goto bus_register_failed;
Alan Stern's avatar
Alan Stern committed
1021
1022
1023
	retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
	if (retval)
		goto bus_notifier_failed;
Linus Torvalds's avatar
Linus Torvalds committed
1024
1025
1026
	retval = usb_major_init();
	if (retval)
		goto major_init_failed;
1027
1028
1029
	retval = usb_register(&usbfs_driver);
	if (retval)
		goto driver_register_failed;
1030
	retval = usb_devio_init();
1031
	if (retval)
1032
		goto usb_devio_init_failed;
Linus Torvalds's avatar
Linus Torvalds committed
1033
1034
1035
1036
1037
1038
	retval = usbfs_init();
	if (retval)
		goto fs_init_failed;
	retval = usb_hub_init();
	if (retval)
		goto hub_init_failed;
1039
	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
Linus Torvalds's avatar
Linus Torvalds committed
1040
1041
1042
1043
1044
1045
1046
	if (!retval)
		goto out;

	usb_hub_cleanup();
hub_init_failed:
	usbfs_cleanup();
fs_init_failed:
1047
1048
	usb_devio_cleanup();
usb_devio_init_failed:
1049
1050
1051
	usb_deregister(&usbfs_driver);
driver_register_failed:
	usb_major_cleanup();
Linus Torvalds's avatar
Linus Torvalds committed
1052
major_init_failed:
Alan Stern's avatar
Alan Stern committed
1053
1054
	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_notifier_failed:
Linus Torvalds's avatar
Linus Torvalds committed
1055
	bus_unregister(&usb_bus_type);
1056
bus_register_failed:
1057
	usb_debugfs_cleanup();
Linus Torvalds's avatar
Linus Torvalds committed
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
out:
	return retval;
}

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

1071
	usb_deregister_device_driver(&usb_generic_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1072
1073
	usb_major_cleanup();
	usbfs_cleanup();
1074
	usb_deregister(&usbfs_driver);
1075
	usb_devio_cleanup();
Linus Torvalds's avatar
Linus Torvalds committed
1076
	usb_hub_cleanup();
Alan Stern's avatar
Alan Stern committed
1077
	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
Linus Torvalds's avatar
Linus Torvalds committed
1078
	bus_unregister(&usb_bus_type);
1079
	usb_debugfs_cleanup();
Linus Torvalds's avatar
Linus Torvalds committed
1080
1081
1082
1083
1084
}

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