driver.c 50.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * drivers/usb/driver.c - most of the driver model stuff for usb
 *
 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
 *
 * based on drivers/usb/usb.c which had the following copyrights:
 *	(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
20
21
 * matching, probing, releasing, suspending and resuming for
 * real drivers.
22
23
24
25
 *
 */

#include <linux/device.h>
26
#include <linux/slab.h>
27
#include <linux/export.h>
28
#include <linux/usb.h>
29
#include <linux/usb/quirks.h>
30
31
#include <linux/usb/hcd.h>

32
33
#include "usb.h"

Alan Stern's avatar
Alan Stern committed
34

35
36
37
38
39
40
#ifdef CONFIG_HOTPLUG

/*
 * Adds a new dynamic USBdevice ID to this driver,
 * and cause the driver to probe for all devices again.
 */
41
42
43
ssize_t usb_store_new_id(struct usb_dynids *dynids,
			 struct device_driver *driver,
			 const char *buf, size_t count)
44
45
46
47
{
	struct usb_dynid *dynid;
	u32 idVendor = 0;
	u32 idProduct = 0;
48
	unsigned int bInterfaceClass = 0;
49
	int fields = 0;
50
	int retval = 0;
51

52
53
	fields = sscanf(buf, "%x %x %x", &idVendor, &idProduct,
					&bInterfaceClass);
54
55
56
57
58
59
60
61
62
63
64
	if (fields < 2)
		return -EINVAL;

	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
	if (!dynid)
		return -ENOMEM;

	INIT_LIST_HEAD(&dynid->node);
	dynid->id.idVendor = idVendor;
	dynid->id.idProduct = idProduct;
	dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
65
66
67
68
	if (fields == 3) {
		dynid->id.bInterfaceClass = (u8)bInterfaceClass;
		dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
	}
69

70
	spin_lock(&dynids->lock);
71
	list_add_tail(&dynid->node, &dynids->list);
72
	spin_unlock(&dynids->lock);
73
74

	if (get_driver(driver)) {
75
		retval = driver_attach(driver);
76
77
78
		put_driver(driver);
	}

79
80
	if (retval)
		return retval;
81
82
	return count;
}
83
84
85
86
87
88
89
90
91
EXPORT_SYMBOL_GPL(usb_store_new_id);

static ssize_t store_new_id(struct device_driver *driver,
			    const char *buf, size_t count)
{
	struct usb_driver *usb_drv = to_usb_driver(driver);

	return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
}
92
93
static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/**
 * store_remove_id - remove a USB device ID from this driver
 * @driver: target device driver
 * @buf: buffer for scanning device ID data
 * @count: input size
 *
 * Removes a dynamic usb device ID from this driver.
 */
static ssize_t
store_remove_id(struct device_driver *driver, const char *buf, size_t count)
{
	struct usb_dynid *dynid, *n;
	struct usb_driver *usb_driver = to_usb_driver(driver);
	u32 idVendor = 0;
	u32 idProduct = 0;
	int fields = 0;
	int retval = 0;

	fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
	if (fields < 2)
		return -EINVAL;

	spin_lock(&usb_driver->dynids.lock);
	list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
		struct usb_device_id *id = &dynid->id;
		if ((id->idVendor == idVendor) &&
		    (id->idProduct == idProduct)) {
			list_del(&dynid->node);
			kfree(dynid);
			retval = 0;
			break;
		}
	}
	spin_unlock(&usb_driver->dynids.lock);

	if (retval)
		return retval;
	return count;
}
static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);

135
136
137
138
static int usb_create_newid_file(struct usb_driver *usb_drv)
{
	int error = 0;

139
140
141
	if (usb_drv->no_dynamic_id)
		goto exit;

142
	if (usb_drv->probe != NULL)
143
144
		error = driver_create_file(&usb_drv->drvwrap.driver,
					   &driver_attr_new_id);
145
exit:
146
147
148
	return error;
}

149
150
151
152
153
154
static void usb_remove_newid_file(struct usb_driver *usb_drv)
{
	if (usb_drv->no_dynamic_id)
		return;

	if (usb_drv->probe != NULL)
155
156
		driver_remove_file(&usb_drv->drvwrap.driver,
				   &driver_attr_new_id);
157
158
}

159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
static int
usb_create_removeid_file(struct usb_driver *drv)
{
	int error = 0;
	if (drv->probe != NULL)
		error = driver_create_file(&drv->drvwrap.driver,
				&driver_attr_remove_id);
	return error;
}

static void usb_remove_removeid_file(struct usb_driver *drv)
{
	driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id);
}

174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
static void usb_free_dynids(struct usb_driver *usb_drv)
{
	struct usb_dynid *dynid, *n;

	spin_lock(&usb_drv->dynids.lock);
	list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
		list_del(&dynid->node);
		kfree(dynid);
	}
	spin_unlock(&usb_drv->dynids.lock);
}
#else
static inline int usb_create_newid_file(struct usb_driver *usb_drv)
{
	return 0;
}

191
192
193
194
static void usb_remove_newid_file(struct usb_driver *usb_drv)
{
}

195
196
197
198
199
200
201
202
203
204
static int
usb_create_removeid_file(struct usb_driver *drv)
{
	return 0;
}

static void usb_remove_removeid_file(struct usb_driver *drv)
{
}

205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
static inline void usb_free_dynids(struct usb_driver *usb_drv)
{
}
#endif

static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
							struct usb_driver *drv)
{
	struct usb_dynid *dynid;

	spin_lock(&drv->dynids.lock);
	list_for_each_entry(dynid, &drv->dynids.list, node) {
		if (usb_match_one_id(intf, &dynid->id)) {
			spin_unlock(&drv->dynids.lock);
			return &dynid->id;
		}
	}
	spin_unlock(&drv->dynids.lock);
	return NULL;
}


227
228
229
230
/* called from driver core with dev locked */
static int usb_probe_device(struct device *dev)
{
	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
231
	struct usb_device *udev = to_usb_device(dev);
232
	int error = 0;
233

234
	dev_dbg(dev, "%s\n", __func__);
235
236
237

	/* TODO: Add real matching code */

238
239
240
	/* The device should always appear to be in use
	 * unless the driver suports autosuspend.
	 */
241
242
	if (!udriver->supports_autosuspend)
		error = usb_autoresume_device(udev);
243

244
245
	if (!error)
		error = udriver->probe(udev);
246
247
248
249
250
251
	return error;
}

/* called from driver core with dev locked */
static int usb_unbind_device(struct device *dev)
{
252
	struct usb_device *udev = to_usb_device(dev);
253
254
	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);

255
256
257
	udriver->disconnect(udev);
	if (!udriver->supports_autosuspend)
		usb_autosuspend_device(udev);
258
259
260
	return 0;
}

261
262
263
264
265
266
267
268
269
270
271
272
273
274
/*
 * Cancel any pending scheduled resets
 *
 * [see usb_queue_reset_device()]
 *
 * Called after unconfiguring / when releasing interfaces. See
 * comments in __usb_queue_reset_device() regarding
 * udev->reset_running.
 */
static void usb_cancel_queued_reset(struct usb_interface *iface)
{
	if (iface->reset_running == 0)
		cancel_work_sync(&iface->reset_ws);
}
275
276

/* called from driver core with dev locked */
277
278
static int usb_probe_interface(struct device *dev)
{
279
	struct usb_driver *driver = to_usb_driver(dev->driver);
280
281
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *udev = interface_to_usbdev(intf);
282
283
284
	const struct usb_device_id *id;
	int error = -ENODEV;

285
	dev_dbg(dev, "%s\n", __func__);
286

287
	intf->needs_binding = 0;
288

289
	if (usb_device_is_owned(udev))
290
		return error;
291

292
293
	if (udev->authorized == 0) {
		dev_err(&intf->dev, "Device is not authorized for usage\n");
294
		return error;
295
	}
296

297
	id = usb_match_id(intf, driver->id_table);
298
299
	if (!id)
		id = usb_match_dynamic_id(intf, driver);
300
301
	if (!id)
		return error;
302

303
304
305
306
307
308
309
	dev_dbg(dev, "%s - got id\n", __func__);

	error = usb_autoresume_device(udev);
	if (error)
		return error;

	intf->condition = USB_INTERFACE_BINDING;
310

311
	/* Probed interfaces are initially active.  They are
312
313
	 * runtime-PM-enabled only if the driver has autosuspend support.
	 * They are sensitive to their children's power states.
314
	 */
315
316
317
318
	pm_runtime_set_active(dev);
	pm_suspend_ignore_children(dev, false);
	if (driver->supports_autosuspend)
		pm_runtime_enable(dev);
319
320
321
322
323
324
325
326

	/* Carry out a deferred switch to altsetting 0 */
	if (intf->needs_altsetting0) {
		error = usb_set_interface(udev, intf->altsetting[0].
				desc.bInterfaceNumber, 0);
		if (error < 0)
			goto err;
		intf->needs_altsetting0 = 0;
327
328
	}

329
330
331
332
333
334
	error = driver->probe(intf, id);
	if (error)
		goto err;

	intf->condition = USB_INTERFACE_BOUND;
	usb_autosuspend_device(udev);
335
	return error;
336

337
 err:
338
339
340
	intf->needs_remote_wakeup = 0;
	intf->condition = USB_INTERFACE_UNBOUND;
	usb_cancel_queued_reset(intf);
341
342

	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
343
344
	if (driver->supports_autosuspend)
		pm_runtime_disable(dev);
345
346
	pm_runtime_set_suspended(dev);

347
348
	usb_autosuspend_device(udev);
	return error;
349
350
}

351
/* called from driver core with dev locked */
352
353
static int usb_unbind_interface(struct device *dev)
{
354
	struct usb_driver *driver = to_usb_driver(dev->driver);
355
	struct usb_interface *intf = to_usb_interface(dev);
356
	struct usb_device *udev;
357
	int error, r;
358
359
360

	intf->condition = USB_INTERFACE_UNBINDING;

361
362
	/* Autoresume for set_interface call below */
	udev = interface_to_usbdev(intf);
363
	error = usb_autoresume_device(udev);
364

Alan Stern's avatar
Alan Stern committed
365
366
367
368
	/* Terminate all URBs for this interface unless the driver
	 * supports "soft" unbinding.
	 */
	if (!driver->soft_unbind)
369
		usb_disable_interface(udev, intf, false);
370

371
	driver->disconnect(intf);
372
	usb_cancel_queued_reset(intf);
373

374
375
376
377
378
379
	/* Reset other interface state.
	 * We cannot do a Set-Interface if the device is suspended or
	 * if it is prepared for a system sleep (since installing a new
	 * altsetting means creating new endpoint device entries).
	 * When either of these happens, defer the Set-Interface.
	 */
380
381
382
383
384
	if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
		/* Already in altsetting 0 so skip Set-Interface.
		 * Just re-enable it without affecting the endpoint toggles.
		 */
		usb_enable_interface(udev, intf, false);
385
	} else if (!error && !intf->dev.power.is_prepared) {
386
		r = usb_set_interface(udev, intf->altsetting[0].
387
				desc.bInterfaceNumber, 0);
388
389
390
		if (r < 0)
			intf->needs_altsetting0 = 1;
	} else {
391
		intf->needs_altsetting0 = 1;
392
	}
393
	usb_set_intfdata(intf, NULL);
394

395
	intf->condition = USB_INTERFACE_UNBOUND;
396
397
	intf->needs_remote_wakeup = 0;

398
	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
399
400
	if (driver->supports_autosuspend)
		pm_runtime_disable(dev);
401
402
403
404
405
406
407
	pm_runtime_set_suspended(dev);

	/* Undo any residual pm_autopm_get_interface_* calls */
	for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
		usb_autopm_put_interface_no_suspend(intf);
	atomic_set(&intf->pm_usage_cnt, 0);

408
	if (!error)
409
		usb_autosuspend_device(udev);
410
411
412
413

	return 0;
}

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
/**
 * usb_driver_claim_interface - bind a driver to an interface
 * @driver: the driver to be bound
 * @iface: the interface to which it will be bound; must be in the
 *	usb device's active configuration
 * @priv: driver data associated with that interface
 *
 * This is used by usb device drivers that need to claim more than one
 * interface on a device when probing (audio and acm are current examples).
 * No device driver should directly modify internal usb_interface or
 * usb_device structure members.
 *
 * Few drivers should need to use this routine, since the most natural
 * way to bind to an interface is to return the private data from
 * the driver's probe() method.
 *
430
431
432
 * Callers must own the device lock, so driver probe() entries don't need
 * extra locking, but other call contexts may need to explicitly claim that
 * lock.
433
434
 */
int usb_driver_claim_interface(struct usb_driver *driver,
435
				struct usb_interface *iface, void *priv)
436
437
{
	struct device *dev = &iface->dev;
438
	int retval = 0;
439
440
441
442

	if (dev->driver)
		return -EBUSY;

443
	dev->driver = &driver->drvwrap.driver;
444
	usb_set_intfdata(iface, priv);
445
	iface->needs_binding = 0;
446

447
	iface->condition = USB_INTERFACE_BOUND;
448

449
450
451
452
453
	/* Claimed interfaces are initially inactive (suspended) and
	 * runtime-PM-enabled, but only if the driver has autosuspend
	 * support.  Otherwise they are marked active, to prevent the
	 * device from being autosuspended, but left disabled.  In either
	 * case they are sensitive to their children's power states.
454
455
456
457
	 */
	pm_suspend_ignore_children(dev, false);
	if (driver->supports_autosuspend)
		pm_runtime_enable(dev);
458
459
	else
		pm_runtime_set_active(dev);
460
461
462
463
464

	/* if interface was already added, bind now; else let
	 * the future device_add() bind it, bypassing probe()
	 */
	if (device_is_registered(dev))
465
		retval = device_bind_driver(dev);
466

467
	return retval;
468
}
469
EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
470
471
472
473
474
475
476
477
478
479
480

/**
 * usb_driver_release_interface - unbind a driver from an interface
 * @driver: the driver to be unbound
 * @iface: the interface from which it will be unbound
 *
 * This can be used by drivers to release an interface without waiting
 * for their disconnect() methods to be called.  In typical cases this
 * also causes the driver disconnect() method to be called.
 *
 * This call is synchronous, and may not be used in an interrupt context.
481
482
483
 * Callers must own the device lock, so driver disconnect() entries don't
 * need extra locking, but other call contexts may need to explicitly claim
 * that lock.
484
485
486
487
488
489
490
 */
void usb_driver_release_interface(struct usb_driver *driver,
					struct usb_interface *iface)
{
	struct device *dev = &iface->dev;

	/* this should never happen, don't release something that's not ours */
491
	if (!dev->driver || dev->driver != &driver->drvwrap.driver)
492
493
494
495
496
		return;

	/* don't release from within disconnect() */
	if (iface->condition != USB_INTERFACE_BOUND)
		return;
497
	iface->condition = USB_INTERFACE_UNBINDING;
498

499
500
501
	/* Release via the driver core only if the interface
	 * has already been registered
	 */
502
503
	if (device_is_registered(dev)) {
		device_release_driver(dev);
504
	} else {
505
		device_lock(dev);
506
507
		usb_unbind_interface(dev);
		dev->driver = NULL;
508
		device_unlock(dev);
509
510
	}
}
511
EXPORT_SYMBOL_GPL(usb_driver_release_interface);
512

513
/* returns 0 if no match, 1 if match */
514
int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
{
	if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
	    id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
	    id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
		return 0;

	/* No need to test id->bcdDevice_lo != 0, since 0 is never
	   greater than any unsigned number. */
	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
	    (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
	    (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
	    (id->bDeviceClass != dev->descriptor.bDeviceClass))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
539
	    (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
540
541
542
543
544
545
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
	    (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
		return 0;

546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
	return 1;
}

/* returns 0 if no match, 1 if match */
int usb_match_one_id(struct usb_interface *interface,
		     const struct usb_device_id *id)
{
	struct usb_host_interface *intf;
	struct usb_device *dev;

	/* proc_connectinfo in devio.c may call us with id == NULL. */
	if (id == NULL)
		return 0;

	intf = interface->cur_altsetting;
	dev = interface_to_usbdev(interface);

	if (!usb_match_device(dev, id))
		return 0;

566
567
568
569
570
571
572
573
574
575
	/* The interface class, subclass, and protocol should never be
	 * checked for a match if the device class is Vendor Specific,
	 * unless the match record specifies the Vendor ID. */
	if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
			!(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
			(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
				USB_DEVICE_ID_MATCH_INT_SUBCLASS |
				USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
		return 0;

576
577
578
579
580
581
582
583
584
585
586
587
588
589
	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
	    (id->bInterfaceClass != intf->desc.bInterfaceClass))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
	    (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
		return 0;

	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
	    (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
		return 0;

	return 1;
}
590
591
EXPORT_SYMBOL_GPL(usb_match_one_id);

592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
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
637
638
639
640
641
642
643
644
645
/**
 * usb_match_id - find first usb_device_id matching device or interface
 * @interface: the interface of interest
 * @id: array of usb_device_id structures, terminated by zero entry
 *
 * usb_match_id searches an array of usb_device_id's and returns
 * the first one matching the device or interface, or null.
 * This is used when binding (or rebinding) a driver to an interface.
 * Most USB device drivers will use this indirectly, through the usb core,
 * but some layered driver frameworks use it directly.
 * These device tables are exported with MODULE_DEVICE_TABLE, through
 * modutils, to support the driver loading functionality of USB hotplugging.
 *
 * What Matches:
 *
 * The "match_flags" element in a usb_device_id controls which
 * members are used.  If the corresponding bit is set, the
 * value in the device_id must match its corresponding member
 * in the device or interface descriptor, or else the device_id
 * does not match.
 *
 * "driver_info" is normally used only by device drivers,
 * but you can create a wildcard "matches anything" usb_device_id
 * as a driver's "modules.usbmap" entry if you provide an id with
 * only a nonzero "driver_info" field.  If you do this, the USB device
 * driver's probe() routine should use additional intelligence to
 * decide whether to bind to the specified interface.
 *
 * What Makes Good usb_device_id Tables:
 *
 * The match algorithm is very simple, so that intelligence in
 * driver selection must come from smart driver id records.
 * Unless you have good reasons to use another selection policy,
 * provide match elements only in related groups, and order match
 * specifiers from specific to general.  Use the macros provided
 * for that purpose if you can.
 *
 * The most specific match specifiers use device descriptor
 * data.  These are commonly used with product-specific matches;
 * the USB_DEVICE macro lets you provide vendor and product IDs,
 * and you can also match against ranges of product revisions.
 * These are widely used for devices with application or vendor
 * specific bDeviceClass values.
 *
 * Matches based on device class/subclass/protocol specifications
 * are slightly more general; use the USB_DEVICE_INFO macro, or
 * its siblings.  These are used with single-function devices
 * where bDeviceClass doesn't specify that each interface has
 * its own class.
 *
 * Matches based on interface class/subclass/protocol are the
 * most general; they let drivers bind to any interface on a
 * multiple-function device.  Use the USB_INTERFACE_INFO
 * macro, or its siblings, to match class-per-interface style
646
647
648
649
650
651
652
653
654
655
656
 * devices (as recorded in bInterfaceClass).
 *
 * Note that an entry created by USB_INTERFACE_INFO won't match
 * any interface if the device class is set to Vendor-Specific.
 * This is deliberate; according to the USB spec the meanings of
 * the interface class/subclass/protocol for these devices are also
 * vendor-specific, and hence matching against a standard product
 * class wouldn't work anyway.  If you really want to use an
 * interface-based match for such a device, create a match record
 * that also specifies the vendor ID.  (Unforunately there isn't a
 * standard macro for creating records like this.)
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
 *
 * Within those groups, remember that not all combinations are
 * meaningful.  For example, don't give a product version range
 * without vendor and product IDs; or specify a protocol without
 * its associated class and subclass.
 */
const struct usb_device_id *usb_match_id(struct usb_interface *interface,
					 const struct usb_device_id *id)
{
	/* proc_connectinfo in devio.c may call us with id == NULL. */
	if (id == NULL)
		return NULL;

	/* It is important to check that id->driver_info is nonzero,
	   since an entry that is all zeroes except for a nonzero
	   id->driver_info is the way to create an entry that
	   indicates that the driver want to examine every
	   device and interface. */
675
676
	for (; id->idVendor || id->idProduct || id->bDeviceClass ||
	       id->bInterfaceClass || id->driver_info; id++) {
677
678
		if (usb_match_one_id(interface, id))
			return id;
679
680
681
682
	}

	return NULL;
}
683
EXPORT_SYMBOL_GPL(usb_match_id);
684

685
static int usb_device_match(struct device *dev, struct device_driver *drv)
686
{
687
688
	/* devices and interfaces are handled separately */
	if (is_usb_device(dev)) {
689

690
691
692
		/* interface drivers never match devices */
		if (!is_usb_device_driver(drv))
			return 0;
693

694
		/* TODO: Add real matching code */
695
696
		return 1;

697
	} else if (is_usb_interface(dev)) {
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
		struct usb_interface *intf;
		struct usb_driver *usb_drv;
		const struct usb_device_id *id;

		/* device drivers never match interfaces */
		if (is_usb_device_driver(drv))
			return 0;

		intf = to_usb_interface(dev);
		usb_drv = to_usb_driver(drv);

		id = usb_match_id(intf, usb_drv->id_table);
		if (id)
			return 1;

		id = usb_match_dynamic_id(intf, usb_drv);
		if (id)
			return 1;
	}

718
719
720
	return 0;
}

721
#ifdef	CONFIG_HOTPLUG
722
static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
723
724
725
{
	struct usb_device *usb_dev;

726
	if (is_usb_device(dev)) {
727
		usb_dev = to_usb_device(dev);
728
	} else if (is_usb_interface(dev)) {
729
		struct usb_interface *intf = to_usb_interface(dev);
730

731
		usb_dev = interface_to_usbdev(intf);
732
733
	} else {
		return 0;
734
	}
735
736

	if (usb_dev->devnum < 0) {
737
		/* driver is often null here; dev_dbg() would oops */
738
		pr_debug("usb %s: already deleted?\n", dev_name(dev));
739
740
741
		return -ENODEV;
	}
	if (!usb_dev->bus) {
742
		pr_debug("usb %s: bus removed?\n", dev_name(dev));
743
744
745
746
747
748
		return -ENODEV;
	}

#ifdef	CONFIG_USB_DEVICEFS
	/* If this is available, userspace programs can directly read
	 * all the device descriptors we don't tell them about.  Or
749
	 * act as usermode drivers.
750
	 */
751
	if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
752
753
754
755
756
			   usb_dev->bus->busnum, usb_dev->devnum))
		return -ENOMEM;
#endif

	/* per-device configurations are common */
757
	if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
758
759
760
761
762
763
			   le16_to_cpu(usb_dev->descriptor.idVendor),
			   le16_to_cpu(usb_dev->descriptor.idProduct),
			   le16_to_cpu(usb_dev->descriptor.bcdDevice)))
		return -ENOMEM;

	/* class-based driver binding models */
764
	if (add_uevent_var(env, "TYPE=%d/%d/%d",
765
766
767
768
769
770
771
772
773
774
			   usb_dev->descriptor.bDeviceClass,
			   usb_dev->descriptor.bDeviceSubClass,
			   usb_dev->descriptor.bDeviceProtocol))
		return -ENOMEM;

	return 0;
}

#else

775
static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
776
777
778
779
780
{
	return -ENODEV;
}
#endif	/* CONFIG_HOTPLUG */

781
/**
782
783
 * usb_register_device_driver - register a USB device (not interface) driver
 * @new_udriver: USB operations for the device driver
784
 * @owner: module owner of this driver.
785
 *
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
 * Registers a USB device driver with the USB core.  The list of
 * unattached devices will be rescanned whenever a new driver is
 * added, allowing the new driver to attach to any recognized devices.
 * Returns a negative error code on failure and 0 on success.
 */
int usb_register_device_driver(struct usb_device_driver *new_udriver,
		struct module *owner)
{
	int retval = 0;

	if (usb_disabled())
		return -ENODEV;

	new_udriver->drvwrap.for_devices = 1;
	new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
	new_udriver->drvwrap.driver.bus = &usb_bus_type;
	new_udriver->drvwrap.driver.probe = usb_probe_device;
	new_udriver->drvwrap.driver.remove = usb_unbind_device;
	new_udriver->drvwrap.driver.owner = owner;

	retval = driver_register(&new_udriver->drvwrap.driver);

	if (!retval) {
		pr_info("%s: registered new device driver %s\n",
			usbcore_name, new_udriver->name);
		usbfs_update_special();
	} else {
		printk(KERN_ERR "%s: error %d registering device "
			"	driver %s\n",
			usbcore_name, retval, new_udriver->name);
	}

	return retval;
}
EXPORT_SYMBOL_GPL(usb_register_device_driver);

/**
 * usb_deregister_device_driver - unregister a USB device (not interface) driver
 * @udriver: USB operations of the device driver to unregister
 * Context: must be able to sleep
 *
 * Unlinks the specified driver from the internal USB driver list.
 */
void usb_deregister_device_driver(struct usb_device_driver *udriver)
{
	pr_info("%s: deregistering device driver %s\n",
			usbcore_name, udriver->name);

	driver_unregister(&udriver->drvwrap.driver);
	usbfs_update_special();
}
EXPORT_SYMBOL_GPL(usb_deregister_device_driver);

/**
 * usb_register_driver - register a USB interface driver
 * @new_driver: USB operations for the interface driver
 * @owner: module owner of this driver.
Randy Dunlap's avatar
Randy Dunlap committed
843
 * @mod_name: module name string
844
845
846
847
 *
 * Registers a USB interface driver with the USB core.  The list of
 * unattached interfaces will be rescanned whenever a new driver is
 * added, allowing the new driver to attach to any recognized interfaces.
848
849
850
851
852
853
 * Returns a negative error code on failure and 0 on success.
 *
 * NOTE: if you want your driver to use the USB major number, you must call
 * usb_register_dev() to enable that functionality.  This function no longer
 * takes care of that.
 */
854
855
int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
			const char *mod_name)
856
857
858
859
860
861
{
	int retval = 0;

	if (usb_disabled())
		return -ENODEV;

862
863
864
865
866
867
	new_driver->drvwrap.for_devices = 0;
	new_driver->drvwrap.driver.name = (char *) new_driver->name;
	new_driver->drvwrap.driver.bus = &usb_bus_type;
	new_driver->drvwrap.driver.probe = usb_probe_interface;
	new_driver->drvwrap.driver.remove = usb_unbind_interface;
	new_driver->drvwrap.driver.owner = owner;
868
	new_driver->drvwrap.driver.mod_name = mod_name;
869
870
	spin_lock_init(&new_driver->dynids.lock);
	INIT_LIST_HEAD(&new_driver->dynids.list);
871

872
	retval = driver_register(&new_driver->drvwrap.driver);
873
874
	if (retval)
		goto out;
875

876
877
878
879
880
881
882
883
884
885
886
	usbfs_update_special();

	retval = usb_create_newid_file(new_driver);
	if (retval)
		goto out_newid;

	retval = usb_create_removeid_file(new_driver);
	if (retval)
		goto out_removeid;

	pr_info("%s: registered new interface driver %s\n",
887
888
			usbcore_name, new_driver->name);

889
out:
890
	return retval;
891
892
893
894
895
896
897
898
899
900

out_removeid:
	usb_remove_newid_file(new_driver);
out_newid:
	driver_unregister(&new_driver->drvwrap.driver);

	printk(KERN_ERR "%s: error %d registering interface "
			"	driver %s\n",
			usbcore_name, retval, new_driver->name);
	goto out;
901
}
902
EXPORT_SYMBOL_GPL(usb_register_driver);
903
904

/**
905
906
 * usb_deregister - unregister a USB interface driver
 * @driver: USB operations of the interface driver to unregister
907
908
909
910
911
912
913
914
915
916
 * Context: must be able to sleep
 *
 * Unlinks the specified driver from the internal USB driver list.
 *
 * NOTE: If you called usb_register_dev(), you still need to call
 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
 * this * call will no longer do it for you.
 */
void usb_deregister(struct usb_driver *driver)
{
917
918
	pr_info("%s: deregistering interface driver %s\n",
			usbcore_name, driver->name);
919

920
	usb_remove_removeid_file(driver);
921
	usb_remove_newid_file(driver);
922
	usb_free_dynids(driver);
923
	driver_unregister(&driver->drvwrap.driver);
924
925
926

	usbfs_update_special();
}
927
EXPORT_SYMBOL_GPL(usb_deregister);
928

929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
/* Forced unbinding of a USB interface driver, either because
 * it doesn't support pre_reset/post_reset/reset_resume or
 * because it doesn't support suspend/resume.
 *
 * The caller must hold @intf's device's lock, but not its pm_mutex
 * and not @intf->dev.sem.
 */
void usb_forced_unbind_intf(struct usb_interface *intf)
{
	struct usb_driver *driver = to_usb_driver(intf->dev.driver);

	dev_dbg(&intf->dev, "forced unbind\n");
	usb_driver_release_interface(driver, intf);

	/* Mark the interface for later rebinding */
	intf->needs_binding = 1;
}

/* Delayed forced unbinding of a USB interface driver and scan
 * for rebinding.
 *
 * The caller must hold @intf's device's lock, but not its pm_mutex
 * and not @intf->dev.sem.
 *
953
954
 * Note: Rebinds will be skipped if a system sleep transition is in
 * progress and the PM "complete" callback hasn't occurred yet.
955
956
957
958
959
960
 */
void usb_rebind_intf(struct usb_interface *intf)
{
	int rc;

	/* Delayed unbind of an existing driver */
961
962
	if (intf->dev.driver)
		usb_forced_unbind_intf(intf);
963
964

	/* Try to rebind the interface */
965
	if (!intf->dev.power.is_prepared) {
966
967
968
969
970
		intf->needs_binding = 0;
		rc = device_attach(&intf->dev);
		if (rc < 0)
			dev_warn(&intf->dev, "rebind failed: %d\n", rc);
	}
971
972
}

Alan Stern's avatar
Alan Stern committed
973
974
#ifdef CONFIG_PM

975
976
977
/* Unbind drivers for @udev's interfaces that don't support suspend/resume
 * There is no check for reset_resume here because it can be determined
 * only during resume whether reset_resume is needed.
978
979
980
 *
 * The caller must hold @udev's device lock.
 */
981
static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
982
983
984
985
986
987
988
989
990
991
{
	struct usb_host_config	*config;
	int			i;
	struct usb_interface	*intf;
	struct usb_driver	*drv;

	config = udev->actconfig;
	if (config) {
		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
			intf = config->interface[i];
992
993
994
995
996

			if (intf->dev.driver) {
				drv = to_usb_driver(intf->dev.driver);
				if (!drv->suspend || !drv->resume)
					usb_forced_unbind_intf(intf);
997
998
999
1000
1001
			}
		}
	}
}

1002
1003
1004
1005
1006
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
1038
/* Unbind drivers for @udev's interfaces that failed to support reset-resume.
 * These interfaces have the needs_binding flag set by usb_resume_interface().
 *
 * The caller must hold @udev's device lock.
 */
static void unbind_no_reset_resume_drivers_interfaces(struct usb_device *udev)
{
	struct usb_host_config	*config;
	int			i;
	struct usb_interface	*intf;

	config = udev->actconfig;
	if (config) {
		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
			intf = config->interface[i];
			if (intf->dev.driver && intf->needs_binding)
				usb_forced_unbind_intf(intf);
		}
	}
}

static void do_rebind_interfaces(struct usb_device *udev)
{
	struct usb_host_config	*config;
	int			i;
	struct usb_interface	*intf;

	config = udev->actconfig;
	if (config) {
		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
			intf = config->interface[i];
			if (intf->needs_binding)
				usb_rebind_intf(intf);
		}
	}
}

1039
static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1040
{
1041
	struct usb_device_driver	*udriver;
1042
	int				status = 0;
1043

1044
1045
1046
1047
	if (udev->state == USB_STATE_NOTATTACHED ||
			udev->state == USB_STATE_SUSPENDED)
		goto done;

1048
1049
1050
1051
	/* For devices that don't have a driver, we do a generic suspend. */
	if (udev->dev.driver)
		udriver = to_usb_device_driver(udev->dev.driver);
	else {
1052
		udev->do_remote_wakeup = 0;
1053
		udriver = &usb_generic_driver;
1054
	}
1055
1056
	status = udriver->suspend(udev, msg);

Alan Stern's avatar
Alan Stern committed
1057
 done:
1058
	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1059
	return status;
1060
1061
}

1062
static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1063
1064
{
	struct usb_device_driver	*udriver;
1065
	int				status = 0;
1066

Alan Stern's avatar
Alan Stern committed
1067
1068
	if (udev->state == USB_STATE_NOTATTACHED)
		goto done;
1069

1070
1071
1072
	/* Can't resume it if it doesn't have a driver. */
	if (udev->dev.driver == NULL) {
		status = -ENOTCONN;
1073
		goto done;
1074
1075
	}

1076
1077
1078
	/* Non-root devices on a full/low-speed bus must wait for their
	 * companion high-speed root hub, in case a handoff is needed.
	 */
1079
	if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
1080
1081
1082
		device_pm_wait_for_dev(&udev->dev,
				&udev->bus->hs_companion->root_hub->dev);

1083
1084
1085
	if (udev->quirks & USB_QUIRK_RESET_RESUME)
		udev->reset_resume = 1;

1086
	udriver = to_usb_device_driver(udev->dev.driver);
1087
	status = udriver->resume(udev, msg);
1088

Alan Stern's avatar
Alan Stern committed
1089
 done:
1090
	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1091
	return status;
1092
1093
}

1094
1095
static int usb_suspend_interface(struct usb_device *udev,
		struct usb_interface *intf, pm_message_t msg)
1096
1097
{
	struct usb_driver	*driver;
1098
	int			status = 0;
1099

1100
1101
	if (udev->state == USB_STATE_NOTATTACHED ||
			intf->condition == USB_INTERFACE_UNBOUND)
1102
		goto done;
1103
	driver = to_usb_driver(intf->dev.driver);
1104

1105
1106
1107
1108
	/* at this time we know the driver supports suspend */
	status = driver->suspend(intf, msg);
	if (status && !PMSG_IS_AUTO(msg))
		dev_err(&intf->dev, "suspend error %d\n", status);
1109

Alan Stern's avatar
Alan Stern committed
1110
 done:
1111
	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1112
1113
1114
	return status;
}

1115
static int usb_resume_interface(struct usb_device *udev,
1116
		struct usb_interface *intf, pm_message_t msg, int reset_resume)
1117
{
1118
	struct usb_driver	*driver;
1119
	int			status = 0;
1120

1121
	if (udev->state == USB_STATE_NOTATTACHED)
1122
		goto done;
1123

1124
1125
1126
1127
	/* Don't let autoresume interfere with unbinding */
	if (intf->condition == USB_INTERFACE_UNBINDING)
		goto done;

1128
	/* Can't resume it if it doesn't have a driver. */
1129
1130
1131
	if (intf->condition == USB_INTERFACE_UNBOUND) {

		/* Carry out a deferred switch to altsetting 0 */
1132
		if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
1133
1134
1135
1136
			usb_set_interface(udev, intf->altsetting[0].
					desc.bInterfaceNumber, 0);
			intf->needs_altsetting0 = 0;
		}
1137
		goto done;
1138
	}
1139
1140
1141

	/* Don't resume if the interface is marked for rebinding */
	if (intf->needs_binding)
1142
		goto done;
1143
	driver = to_usb_driver(intf->dev.driver);
1144

Alan Stern's avatar
Alan Stern committed
1145
1146
1147
1148
1149
1150
1151
	if (reset_resume) {
		if (driver->reset_resume) {
			status = driver->reset_resume(intf);
			if (status)
				dev_err(&intf->dev, "%s error %d\n",
						"reset_resume", status);
		} else {
1152
			intf->needs_binding = 1;
Alan Stern's avatar
Alan Stern committed
1153
1154
1155
1156
			dev_warn(&intf->dev, "no %s for driver %s?\n",
					"reset_resume", driver->name);
		}
	} else {
1157
1158
1159
		status = driver->resume(intf);
		if (status)
			dev_err(&intf->dev, "resume error %d\n", status);
Alan Stern's avatar
Alan Stern committed
1160
	}
1161
1162

done:
1163
	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
Alan Stern's avatar
Alan Stern committed
1164

1165
	/* Later we will unbind the driver and/or reprobe, if necessary */
1166
	return status;
1167
1168
}

1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
/**
 * usb_suspend_both - suspend a USB device and its interfaces
 * @udev: the usb_device to suspend
 * @msg: Power Management message describing this state transition
 *
 * This is the central routine for suspending USB devices.  It calls the
 * suspend methods for all the interface drivers in @udev and then calls
 * the suspend method for @udev itself.  If an error occurs at any stage,
 * all the interfaces which were suspended are resumed so that they remain
 * in the same state as the device.
 *
1180
1181
1182
1183
1184
1185
 * Autosuspend requests originating from a child device or an interface
 * driver may be made without the protection of @udev's device lock, but
 * all other suspend calls will hold the lock.  Usbcore will insure that
 * method calls do not arrive during bind, unbind, or reset operations.
 * However drivers must be prepared to handle suspend calls arriving at
 * unpredictable times.
1186
1187
1188
 *
 * This routine can run only in process context.
 */
1189
static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1190
1191
{
	int			status = 0;
1192
	int			i = 0, n = 0;
1193
	struct usb_interface	*intf;
1194

1195
1196
1197
	if (udev->state == USB_STATE_NOTATTACHED ||
			udev->state == USB_STATE_SUSPENDED)
		goto done;
1198

1199
	/* Suspend all the interfaces and then udev itself */
1200
	if (udev->actconfig) {
1201
1202
		n = udev->actconfig->desc.bNumInterfaces;
		for (i = n - 1; i >= 0; --i) {
1203
			intf = udev->actconfig->interface[i];
1204
			status = usb_suspend_interface(udev, intf, msg);
1205
1206

			/* Ignore errors during system sleep transitions */
1207
			if (!PMSG_IS_AUTO(msg))
1208
				status = 0;
1209
1210
1211
1212
			if (status != 0)
				break;
		}
	}
1213
	if (status == 0) {
1214
		status = usb_suspend_device(udev, msg);
1215

1216
		/* Again, ignore errors during system sleep transitions */
1217
		if (!PMSG_IS_AUTO(msg))
1218
1219
1220
			status = 0;
	}

1221
1222
	/* If the suspend failed, resume interfaces that did get suspended */
	if (status != 0) {
1223
		msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1224
		while (++i < n) {
1225
			intf = udev->actconfig->interface[i];
1226
			usb_resume_interface(udev, intf, msg, 0);
1227
		}
1228