2 * drivers/usb/driver.c - most of the driver model stuff for usb
4 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
6 * based on drivers/usb/usb.c which had the following copyrights:
7 * (C) Copyright Linus Torvalds 1999
8 * (C) Copyright Johannes Erdfelt 1999-2001
9 * (C) Copyright Andreas Gal 1999
10 * (C) Copyright Gregory P. Smith 1999
11 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
12 * (C) Copyright Randy Dunlap 2000
13 * (C) Copyright David Brownell 2000-2004
14 * (C) Copyright Yggdrasil Computing, Inc. 2000
15 * (usb_device_id matching changes by Adam J. Richter)
16 * (C) Copyright Greg Kroah-Hartman 2002-2003
18 * NOTE! This is not actually a driver at all, rather this is
19 * just a collection of helper routines that implement the
20 * matching, probing, releasing, suspending and resuming for
25 #include <linux/device.h>
26 #include <linux/usb.h>
27 #include <linux/workqueue.h>
34 * Adds a new dynamic USBdevice ID to this driver,
35 * and cause the driver to probe for all devices again.
37 ssize_t
usb_store_new_id(struct usb_dynids
*dynids
,
38 struct device_driver
*driver
,
39 const char *buf
, size_t count
)
41 struct usb_dynid
*dynid
;
47 fields
= sscanf(buf
, "%x %x", &idVendor
, &idProduct
);
51 dynid
= kzalloc(sizeof(*dynid
), GFP_KERNEL
);
55 INIT_LIST_HEAD(&dynid
->node
);
56 dynid
->id
.idVendor
= idVendor
;
57 dynid
->id
.idProduct
= idProduct
;
58 dynid
->id
.match_flags
= USB_DEVICE_ID_MATCH_DEVICE
;
60 spin_lock(&dynids
->lock
);
61 list_add_tail(&dynids
->list
, &dynid
->node
);
62 spin_unlock(&dynids
->lock
);
64 if (get_driver(driver
)) {
65 retval
= driver_attach(driver
);
73 EXPORT_SYMBOL_GPL(usb_store_new_id
);
75 static ssize_t
store_new_id(struct device_driver
*driver
,
76 const char *buf
, size_t count
)
78 struct usb_driver
*usb_drv
= to_usb_driver(driver
);
80 return usb_store_new_id(&usb_drv
->dynids
, driver
, buf
, count
);
82 static DRIVER_ATTR(new_id
, S_IWUSR
, NULL
, store_new_id
);
84 static int usb_create_newid_file(struct usb_driver
*usb_drv
)
88 if (usb_drv
->no_dynamic_id
)
91 if (usb_drv
->probe
!= NULL
)
92 error
= sysfs_create_file(&usb_drv
->drvwrap
.driver
.kobj
,
93 &driver_attr_new_id
.attr
);
98 static void usb_remove_newid_file(struct usb_driver
*usb_drv
)
100 if (usb_drv
->no_dynamic_id
)
103 if (usb_drv
->probe
!= NULL
)
104 sysfs_remove_file(&usb_drv
->drvwrap
.driver
.kobj
,
105 &driver_attr_new_id
.attr
);
108 static void usb_free_dynids(struct usb_driver
*usb_drv
)
110 struct usb_dynid
*dynid
, *n
;
112 spin_lock(&usb_drv
->dynids
.lock
);
113 list_for_each_entry_safe(dynid
, n
, &usb_drv
->dynids
.list
, node
) {
114 list_del(&dynid
->node
);
117 spin_unlock(&usb_drv
->dynids
.lock
);
120 static inline int usb_create_newid_file(struct usb_driver
*usb_drv
)
125 static void usb_remove_newid_file(struct usb_driver
*usb_drv
)
129 static inline void usb_free_dynids(struct usb_driver
*usb_drv
)
134 static const struct usb_device_id
*usb_match_dynamic_id(struct usb_interface
*intf
,
135 struct usb_driver
*drv
)
137 struct usb_dynid
*dynid
;
139 spin_lock(&drv
->dynids
.lock
);
140 list_for_each_entry(dynid
, &drv
->dynids
.list
, node
) {
141 if (usb_match_one_id(intf
, &dynid
->id
)) {
142 spin_unlock(&drv
->dynids
.lock
);
146 spin_unlock(&drv
->dynids
.lock
);
151 /* called from driver core with dev locked */
152 static int usb_probe_device(struct device
*dev
)
154 struct usb_device_driver
*udriver
= to_usb_device_driver(dev
->driver
);
155 struct usb_device
*udev
;
158 dev_dbg(dev
, "%s\n", __FUNCTION__
);
160 if (!is_usb_device(dev
)) /* Sanity check */
163 udev
= to_usb_device(dev
);
165 /* TODO: Add real matching code */
167 /* The device should always appear to be in use
168 * unless the driver suports autosuspend.
170 udev
->pm_usage_cnt
= !(udriver
->supports_autosuspend
);
172 error
= udriver
->probe(udev
);
176 /* called from driver core with dev locked */
177 static int usb_unbind_device(struct device
*dev
)
179 struct usb_device_driver
*udriver
= to_usb_device_driver(dev
->driver
);
181 udriver
->disconnect(to_usb_device(dev
));
186 /* called from driver core with dev locked */
187 static int usb_probe_interface(struct device
*dev
)
189 struct usb_driver
*driver
= to_usb_driver(dev
->driver
);
190 struct usb_interface
*intf
;
191 struct usb_device
*udev
;
192 const struct usb_device_id
*id
;
195 dev_dbg(dev
, "%s\n", __FUNCTION__
);
197 if (is_usb_device(dev
)) /* Sanity check */
200 intf
= to_usb_interface(dev
);
201 udev
= interface_to_usbdev(intf
);
203 id
= usb_match_id(intf
, driver
->id_table
);
205 id
= usb_match_dynamic_id(intf
, driver
);
207 dev_dbg(dev
, "%s - got id\n", __FUNCTION__
);
209 error
= usb_autoresume_device(udev
);
213 /* Interface "power state" doesn't correspond to any hardware
214 * state whatsoever. We use it to record when it's bound to
215 * a driver that may start I/0: it's not frozen/quiesced.
218 intf
->condition
= USB_INTERFACE_BINDING
;
220 /* The interface should always appear to be in use
221 * unless the driver suports autosuspend.
223 intf
->pm_usage_cnt
= !(driver
->supports_autosuspend
);
225 error
= driver
->probe(intf
, id
);
228 intf
->needs_remote_wakeup
= 0;
229 intf
->condition
= USB_INTERFACE_UNBOUND
;
231 intf
->condition
= USB_INTERFACE_BOUND
;
233 usb_autosuspend_device(udev
);
239 /* called from driver core with dev locked */
240 static int usb_unbind_interface(struct device
*dev
)
242 struct usb_driver
*driver
= to_usb_driver(dev
->driver
);
243 struct usb_interface
*intf
= to_usb_interface(dev
);
244 struct usb_device
*udev
;
247 intf
->condition
= USB_INTERFACE_UNBINDING
;
249 /* Autoresume for set_interface call below */
250 udev
= interface_to_usbdev(intf
);
251 error
= usb_autoresume_device(udev
);
253 /* release all urbs for this interface */
254 usb_disable_interface(interface_to_usbdev(intf
), intf
);
256 driver
->disconnect(intf
);
258 /* reset other interface state */
259 usb_set_interface(interface_to_usbdev(intf
),
260 intf
->altsetting
[0].desc
.bInterfaceNumber
,
262 usb_set_intfdata(intf
, NULL
);
264 intf
->condition
= USB_INTERFACE_UNBOUND
;
266 intf
->needs_remote_wakeup
= 0;
269 usb_autosuspend_device(udev
);
275 * usb_driver_claim_interface - bind a driver to an interface
276 * @driver: the driver to be bound
277 * @iface: the interface to which it will be bound; must be in the
278 * usb device's active configuration
279 * @priv: driver data associated with that interface
281 * This is used by usb device drivers that need to claim more than one
282 * interface on a device when probing (audio and acm are current examples).
283 * No device driver should directly modify internal usb_interface or
284 * usb_device structure members.
286 * Few drivers should need to use this routine, since the most natural
287 * way to bind to an interface is to return the private data from
288 * the driver's probe() method.
290 * Callers must own the device lock, so driver probe() entries don't need
291 * extra locking, but other call contexts may need to explicitly claim that
294 int usb_driver_claim_interface(struct usb_driver
*driver
,
295 struct usb_interface
*iface
, void* priv
)
297 struct device
*dev
= &iface
->dev
;
298 struct usb_device
*udev
= interface_to_usbdev(iface
);
304 dev
->driver
= &driver
->drvwrap
.driver
;
305 usb_set_intfdata(iface
, priv
);
308 iface
->condition
= USB_INTERFACE_BOUND
;
310 iface
->pm_usage_cnt
= !(driver
->supports_autosuspend
);
313 /* if interface was already added, bind now; else let
314 * the future device_add() bind it, bypassing probe()
316 if (device_is_registered(dev
))
317 retval
= device_bind_driver(dev
);
321 EXPORT_SYMBOL(usb_driver_claim_interface
);
324 * usb_driver_release_interface - unbind a driver from an interface
325 * @driver: the driver to be unbound
326 * @iface: the interface from which it will be unbound
328 * This can be used by drivers to release an interface without waiting
329 * for their disconnect() methods to be called. In typical cases this
330 * also causes the driver disconnect() method to be called.
332 * This call is synchronous, and may not be used in an interrupt context.
333 * Callers must own the device lock, so driver disconnect() entries don't
334 * need extra locking, but other call contexts may need to explicitly claim
337 void usb_driver_release_interface(struct usb_driver
*driver
,
338 struct usb_interface
*iface
)
340 struct device
*dev
= &iface
->dev
;
341 struct usb_device
*udev
= interface_to_usbdev(iface
);
343 /* this should never happen, don't release something that's not ours */
344 if (!dev
->driver
|| dev
->driver
!= &driver
->drvwrap
.driver
)
347 /* don't release from within disconnect() */
348 if (iface
->condition
!= USB_INTERFACE_BOUND
)
351 /* don't release if the interface hasn't been added yet */
352 if (device_is_registered(dev
)) {
353 iface
->condition
= USB_INTERFACE_UNBINDING
;
354 device_release_driver(dev
);
358 usb_set_intfdata(iface
, NULL
);
361 iface
->condition
= USB_INTERFACE_UNBOUND
;
362 mark_quiesced(iface
);
363 iface
->needs_remote_wakeup
= 0;
366 EXPORT_SYMBOL(usb_driver_release_interface
);
368 /* returns 0 if no match, 1 if match */
369 int usb_match_device(struct usb_device
*dev
, const struct usb_device_id
*id
)
371 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_VENDOR
) &&
372 id
->idVendor
!= le16_to_cpu(dev
->descriptor
.idVendor
))
375 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_PRODUCT
) &&
376 id
->idProduct
!= le16_to_cpu(dev
->descriptor
.idProduct
))
379 /* No need to test id->bcdDevice_lo != 0, since 0 is never
380 greater than any unsigned number. */
381 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_LO
) &&
382 (id
->bcdDevice_lo
> le16_to_cpu(dev
->descriptor
.bcdDevice
)))
385 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_HI
) &&
386 (id
->bcdDevice_hi
< le16_to_cpu(dev
->descriptor
.bcdDevice
)))
389 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_CLASS
) &&
390 (id
->bDeviceClass
!= dev
->descriptor
.bDeviceClass
))
393 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_SUBCLASS
) &&
394 (id
->bDeviceSubClass
!= dev
->descriptor
.bDeviceSubClass
))
397 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_PROTOCOL
) &&
398 (id
->bDeviceProtocol
!= dev
->descriptor
.bDeviceProtocol
))
404 /* returns 0 if no match, 1 if match */
405 int usb_match_one_id(struct usb_interface
*interface
,
406 const struct usb_device_id
*id
)
408 struct usb_host_interface
*intf
;
409 struct usb_device
*dev
;
411 /* proc_connectinfo in devio.c may call us with id == NULL. */
415 intf
= interface
->cur_altsetting
;
416 dev
= interface_to_usbdev(interface
);
418 if (!usb_match_device(dev
, id
))
421 /* The interface class, subclass, and protocol should never be
422 * checked for a match if the device class is Vendor Specific,
423 * unless the match record specifies the Vendor ID. */
424 if (dev
->descriptor
.bDeviceClass
== USB_CLASS_VENDOR_SPEC
&&
425 !(id
->match_flags
& USB_DEVICE_ID_MATCH_VENDOR
) &&
426 (id
->match_flags
& (USB_DEVICE_ID_MATCH_INT_CLASS
|
427 USB_DEVICE_ID_MATCH_INT_SUBCLASS
|
428 USB_DEVICE_ID_MATCH_INT_PROTOCOL
)))
431 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_INT_CLASS
) &&
432 (id
->bInterfaceClass
!= intf
->desc
.bInterfaceClass
))
435 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_INT_SUBCLASS
) &&
436 (id
->bInterfaceSubClass
!= intf
->desc
.bInterfaceSubClass
))
439 if ((id
->match_flags
& USB_DEVICE_ID_MATCH_INT_PROTOCOL
) &&
440 (id
->bInterfaceProtocol
!= intf
->desc
.bInterfaceProtocol
))
445 EXPORT_SYMBOL_GPL(usb_match_one_id
);
448 * usb_match_id - find first usb_device_id matching device or interface
449 * @interface: the interface of interest
450 * @id: array of usb_device_id structures, terminated by zero entry
452 * usb_match_id searches an array of usb_device_id's and returns
453 * the first one matching the device or interface, or null.
454 * This is used when binding (or rebinding) a driver to an interface.
455 * Most USB device drivers will use this indirectly, through the usb core,
456 * but some layered driver frameworks use it directly.
457 * These device tables are exported with MODULE_DEVICE_TABLE, through
458 * modutils, to support the driver loading functionality of USB hotplugging.
462 * The "match_flags" element in a usb_device_id controls which
463 * members are used. If the corresponding bit is set, the
464 * value in the device_id must match its corresponding member
465 * in the device or interface descriptor, or else the device_id
468 * "driver_info" is normally used only by device drivers,
469 * but you can create a wildcard "matches anything" usb_device_id
470 * as a driver's "modules.usbmap" entry if you provide an id with
471 * only a nonzero "driver_info" field. If you do this, the USB device
472 * driver's probe() routine should use additional intelligence to
473 * decide whether to bind to the specified interface.
475 * What Makes Good usb_device_id Tables:
477 * The match algorithm is very simple, so that intelligence in
478 * driver selection must come from smart driver id records.
479 * Unless you have good reasons to use another selection policy,
480 * provide match elements only in related groups, and order match
481 * specifiers from specific to general. Use the macros provided
482 * for that purpose if you can.
484 * The most specific match specifiers use device descriptor
485 * data. These are commonly used with product-specific matches;
486 * the USB_DEVICE macro lets you provide vendor and product IDs,
487 * and you can also match against ranges of product revisions.
488 * These are widely used for devices with application or vendor
489 * specific bDeviceClass values.
491 * Matches based on device class/subclass/protocol specifications
492 * are slightly more general; use the USB_DEVICE_INFO macro, or
493 * its siblings. These are used with single-function devices
494 * where bDeviceClass doesn't specify that each interface has
497 * Matches based on interface class/subclass/protocol are the
498 * most general; they let drivers bind to any interface on a
499 * multiple-function device. Use the USB_INTERFACE_INFO
500 * macro, or its siblings, to match class-per-interface style
501 * devices (as recorded in bInterfaceClass).
503 * Note that an entry created by USB_INTERFACE_INFO won't match
504 * any interface if the device class is set to Vendor-Specific.
505 * This is deliberate; according to the USB spec the meanings of
506 * the interface class/subclass/protocol for these devices are also
507 * vendor-specific, and hence matching against a standard product
508 * class wouldn't work anyway. If you really want to use an
509 * interface-based match for such a device, create a match record
510 * that also specifies the vendor ID. (Unforunately there isn't a
511 * standard macro for creating records like this.)
513 * Within those groups, remember that not all combinations are
514 * meaningful. For example, don't give a product version range
515 * without vendor and product IDs; or specify a protocol without
516 * its associated class and subclass.
518 const struct usb_device_id
*usb_match_id(struct usb_interface
*interface
,
519 const struct usb_device_id
*id
)
521 /* proc_connectinfo in devio.c may call us with id == NULL. */
525 /* It is important to check that id->driver_info is nonzero,
526 since an entry that is all zeroes except for a nonzero
527 id->driver_info is the way to create an entry that
528 indicates that the driver want to examine every
529 device and interface. */
530 for (; id
->idVendor
|| id
->bDeviceClass
|| id
->bInterfaceClass
||
531 id
->driver_info
; id
++) {
532 if (usb_match_one_id(interface
, id
))
538 EXPORT_SYMBOL_GPL_FUTURE(usb_match_id
);
540 static int usb_device_match(struct device
*dev
, struct device_driver
*drv
)
542 /* devices and interfaces are handled separately */
543 if (is_usb_device(dev
)) {
545 /* interface drivers never match devices */
546 if (!is_usb_device_driver(drv
))
549 /* TODO: Add real matching code */
553 struct usb_interface
*intf
;
554 struct usb_driver
*usb_drv
;
555 const struct usb_device_id
*id
;
557 /* device drivers never match interfaces */
558 if (is_usb_device_driver(drv
))
561 intf
= to_usb_interface(dev
);
562 usb_drv
= to_usb_driver(drv
);
564 id
= usb_match_id(intf
, usb_drv
->id_table
);
568 id
= usb_match_dynamic_id(intf
, usb_drv
);
576 #ifdef CONFIG_HOTPLUG
579 * This sends an uevent to userspace, typically helping to load driver
580 * or other modules, configure the device, and more. Drivers can provide
581 * a MODULE_DEVICE_TABLE to help with module loading subtasks.
583 * We're called either from khubd (the typical case) or from root hub
584 * (init, kapmd, modprobe, rmmod, etc), but the agents need to handle
585 * delays in event delivery. Use sysfs (and DEVPATH) to make sure the
586 * device (and this configuration!) are still present.
588 static int usb_uevent(struct device
*dev
, char **envp
, int num_envp
,
589 char *buffer
, int buffer_size
)
591 struct usb_interface
*intf
;
592 struct usb_device
*usb_dev
;
593 struct usb_host_interface
*alt
;
600 /* driver is often null here; dev_dbg() would oops */
601 pr_debug ("usb %s: uevent\n", dev
->bus_id
);
603 if (is_usb_device(dev
)) {
604 usb_dev
= to_usb_device(dev
);
607 intf
= to_usb_interface(dev
);
608 usb_dev
= interface_to_usbdev(intf
);
609 alt
= intf
->cur_altsetting
;
612 if (usb_dev
->devnum
< 0) {
613 pr_debug ("usb %s: already deleted?\n", dev
->bus_id
);
617 pr_debug ("usb %s: bus removed?\n", dev
->bus_id
);
621 #ifdef CONFIG_USB_DEVICEFS
622 /* If this is available, userspace programs can directly read
623 * all the device descriptors we don't tell them about. Or
624 * even act as usermode drivers.
626 * FIXME reduce hardwired intelligence here
628 if (add_uevent_var(envp
, num_envp
, &i
,
629 buffer
, buffer_size
, &length
,
630 "DEVICE=/proc/bus/usb/%03d/%03d",
631 usb_dev
->bus
->busnum
, usb_dev
->devnum
))
635 /* per-device configurations are common */
636 if (add_uevent_var(envp
, num_envp
, &i
,
637 buffer
, buffer_size
, &length
,
639 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
640 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
641 le16_to_cpu(usb_dev
->descriptor
.bcdDevice
)))
644 /* class-based driver binding models */
645 if (add_uevent_var(envp
, num_envp
, &i
,
646 buffer
, buffer_size
, &length
,
648 usb_dev
->descriptor
.bDeviceClass
,
649 usb_dev
->descriptor
.bDeviceSubClass
,
650 usb_dev
->descriptor
.bDeviceProtocol
))
653 if (!is_usb_device(dev
)) {
655 if (add_uevent_var(envp
, num_envp
, &i
,
656 buffer
, buffer_size
, &length
,
657 "INTERFACE=%d/%d/%d",
658 alt
->desc
.bInterfaceClass
,
659 alt
->desc
.bInterfaceSubClass
,
660 alt
->desc
.bInterfaceProtocol
))
663 if (add_uevent_var(envp
, num_envp
, &i
,
664 buffer
, buffer_size
, &length
,
665 "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
666 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
667 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
668 le16_to_cpu(usb_dev
->descriptor
.bcdDevice
),
669 usb_dev
->descriptor
.bDeviceClass
,
670 usb_dev
->descriptor
.bDeviceSubClass
,
671 usb_dev
->descriptor
.bDeviceProtocol
,
672 alt
->desc
.bInterfaceClass
,
673 alt
->desc
.bInterfaceSubClass
,
674 alt
->desc
.bInterfaceProtocol
))
685 static int usb_uevent(struct device
*dev
, char **envp
,
686 int num_envp
, char *buffer
, int buffer_size
)
691 #endif /* CONFIG_HOTPLUG */
694 * usb_register_device_driver - register a USB device (not interface) driver
695 * @new_udriver: USB operations for the device driver
696 * @owner: module owner of this driver.
698 * Registers a USB device driver with the USB core. The list of
699 * unattached devices will be rescanned whenever a new driver is
700 * added, allowing the new driver to attach to any recognized devices.
701 * Returns a negative error code on failure and 0 on success.
703 int usb_register_device_driver(struct usb_device_driver
*new_udriver
,
704 struct module
*owner
)
711 new_udriver
->drvwrap
.for_devices
= 1;
712 new_udriver
->drvwrap
.driver
.name
= (char *) new_udriver
->name
;
713 new_udriver
->drvwrap
.driver
.bus
= &usb_bus_type
;
714 new_udriver
->drvwrap
.driver
.probe
= usb_probe_device
;
715 new_udriver
->drvwrap
.driver
.remove
= usb_unbind_device
;
716 new_udriver
->drvwrap
.driver
.owner
= owner
;
718 retval
= driver_register(&new_udriver
->drvwrap
.driver
);
721 pr_info("%s: registered new device driver %s\n",
722 usbcore_name
, new_udriver
->name
);
723 usbfs_update_special();
725 printk(KERN_ERR
"%s: error %d registering device "
727 usbcore_name
, retval
, new_udriver
->name
);
732 EXPORT_SYMBOL_GPL(usb_register_device_driver
);
735 * usb_deregister_device_driver - unregister a USB device (not interface) driver
736 * @udriver: USB operations of the device driver to unregister
737 * Context: must be able to sleep
739 * Unlinks the specified driver from the internal USB driver list.
741 void usb_deregister_device_driver(struct usb_device_driver
*udriver
)
743 pr_info("%s: deregistering device driver %s\n",
744 usbcore_name
, udriver
->name
);
746 driver_unregister(&udriver
->drvwrap
.driver
);
747 usbfs_update_special();
749 EXPORT_SYMBOL_GPL(usb_deregister_device_driver
);
752 * usb_register_driver - register a USB interface driver
753 * @new_driver: USB operations for the interface driver
754 * @owner: module owner of this driver.
755 * @mod_name: module name string
757 * Registers a USB interface driver with the USB core. The list of
758 * unattached interfaces will be rescanned whenever a new driver is
759 * added, allowing the new driver to attach to any recognized interfaces.
760 * Returns a negative error code on failure and 0 on success.
762 * NOTE: if you want your driver to use the USB major number, you must call
763 * usb_register_dev() to enable that functionality. This function no longer
764 * takes care of that.
766 int usb_register_driver(struct usb_driver
*new_driver
, struct module
*owner
,
767 const char *mod_name
)
774 new_driver
->drvwrap
.for_devices
= 0;
775 new_driver
->drvwrap
.driver
.name
= (char *) new_driver
->name
;
776 new_driver
->drvwrap
.driver
.bus
= &usb_bus_type
;
777 new_driver
->drvwrap
.driver
.probe
= usb_probe_interface
;
778 new_driver
->drvwrap
.driver
.remove
= usb_unbind_interface
;
779 new_driver
->drvwrap
.driver
.owner
= owner
;
780 new_driver
->drvwrap
.driver
.mod_name
= mod_name
;
781 spin_lock_init(&new_driver
->dynids
.lock
);
782 INIT_LIST_HEAD(&new_driver
->dynids
.list
);
784 retval
= driver_register(&new_driver
->drvwrap
.driver
);
787 pr_info("%s: registered new interface driver %s\n",
788 usbcore_name
, new_driver
->name
);
789 usbfs_update_special();
790 usb_create_newid_file(new_driver
);
792 printk(KERN_ERR
"%s: error %d registering interface "
794 usbcore_name
, retval
, new_driver
->name
);
799 EXPORT_SYMBOL_GPL_FUTURE(usb_register_driver
);
802 * usb_deregister - unregister a USB interface driver
803 * @driver: USB operations of the interface driver to unregister
804 * Context: must be able to sleep
806 * Unlinks the specified driver from the internal USB driver list.
808 * NOTE: If you called usb_register_dev(), you still need to call
809 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
810 * this * call will no longer do it for you.
812 void usb_deregister(struct usb_driver
*driver
)
814 pr_info("%s: deregistering interface driver %s\n",
815 usbcore_name
, driver
->name
);
817 usb_remove_newid_file(driver
);
818 usb_free_dynids(driver
);
819 driver_unregister(&driver
->drvwrap
.driver
);
821 usbfs_update_special();
823 EXPORT_SYMBOL_GPL_FUTURE(usb_deregister
);
827 /* Caller has locked udev's pm_mutex */
828 static int usb_suspend_device(struct usb_device
*udev
, pm_message_t msg
)
830 struct usb_device_driver
*udriver
;
833 if (udev
->state
== USB_STATE_NOTATTACHED
||
834 udev
->state
== USB_STATE_SUSPENDED
)
837 /* For devices that don't have a driver, we do a standard suspend. */
838 if (udev
->dev
.driver
== NULL
) {
839 udev
->do_remote_wakeup
= 0;
840 status
= usb_port_suspend(udev
);
844 udriver
= to_usb_device_driver(udev
->dev
.driver
);
845 status
= udriver
->suspend(udev
, msg
);
848 // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
850 udev
->dev
.power
.power_state
.event
= msg
.event
;
854 /* Caller has locked udev's pm_mutex */
855 static int usb_resume_device(struct usb_device
*udev
)
857 struct usb_device_driver
*udriver
;
860 if (udev
->state
== USB_STATE_NOTATTACHED
||
861 udev
->state
!= USB_STATE_SUSPENDED
)
864 /* Can't resume it if it doesn't have a driver. */
865 if (udev
->dev
.driver
== NULL
) {
870 udriver
= to_usb_device_driver(udev
->dev
.driver
);
871 status
= udriver
->resume(udev
);
874 // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
876 udev
->dev
.power
.power_state
.event
= PM_EVENT_ON
;
880 /* Caller has locked intf's usb_device's pm mutex */
881 static int usb_suspend_interface(struct usb_interface
*intf
, pm_message_t msg
)
883 struct usb_driver
*driver
;
886 /* with no hardware, USB interfaces only use FREEZE and ON states */
887 if (interface_to_usbdev(intf
)->state
== USB_STATE_NOTATTACHED
||
891 if (intf
->condition
== USB_INTERFACE_UNBOUND
) /* This can't happen */
893 driver
= to_usb_driver(intf
->dev
.driver
);
895 if (driver
->suspend
&& driver
->resume
) {
896 status
= driver
->suspend(intf
, msg
);
899 else if (!interface_to_usbdev(intf
)->auto_pm
)
900 dev_err(&intf
->dev
, "%s error %d\n",
903 // FIXME else if there's no suspend method, disconnect...
904 // Not possible if auto_pm is set...
905 dev_warn(&intf
->dev
, "no suspend for driver %s?\n",
911 // dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
913 intf
->dev
.power
.power_state
.event
= msg
.event
;
917 /* Caller has locked intf's usb_device's pm_mutex */
918 static int usb_resume_interface(struct usb_interface
*intf
)
920 struct usb_driver
*driver
;
923 if (interface_to_usbdev(intf
)->state
== USB_STATE_NOTATTACHED
||
927 /* Don't let autoresume interfere with unbinding */
928 if (intf
->condition
== USB_INTERFACE_UNBINDING
)
931 /* Can't resume it if it doesn't have a driver. */
932 if (intf
->condition
== USB_INTERFACE_UNBOUND
) {
936 driver
= to_usb_driver(intf
->dev
.driver
);
938 if (driver
->resume
) {
939 status
= driver
->resume(intf
);
941 dev_err(&intf
->dev
, "%s error %d\n",
946 dev_warn(&intf
->dev
, "no resume for driver %s?\n",
952 // dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
954 intf
->dev
.power
.power_state
.event
= PM_EVENT_ON
;
958 #ifdef CONFIG_USB_SUSPEND
960 /* Internal routine to check whether we may autosuspend a device. */
961 static int autosuspend_check(struct usb_device
*udev
)
964 struct usb_interface
*intf
;
966 /* For autosuspend, fail fast if anything is in use or autosuspend
967 * is disabled. Also fail if any interfaces require remote wakeup
968 * but it isn't available.
970 udev
->do_remote_wakeup
= device_may_wakeup(&udev
->dev
);
971 if (udev
->pm_usage_cnt
> 0)
973 if (udev
->autosuspend_delay
< 0)
976 if (udev
->actconfig
) {
977 for (i
= 0; i
< udev
->actconfig
->desc
.bNumInterfaces
; i
++) {
978 intf
= udev
->actconfig
->interface
[i
];
979 if (!is_active(intf
))
981 if (intf
->pm_usage_cnt
> 0)
983 if (intf
->needs_remote_wakeup
&&
984 !udev
->do_remote_wakeup
) {
985 dev_dbg(&udev
->dev
, "remote wakeup needed "
986 "for autosuspend\n");
996 #define autosuspend_check(udev) 0
998 #endif /* CONFIG_USB_SUSPEND */
1001 * usb_suspend_both - suspend a USB device and its interfaces
1002 * @udev: the usb_device to suspend
1003 * @msg: Power Management message describing this state transition
1005 * This is the central routine for suspending USB devices. It calls the
1006 * suspend methods for all the interface drivers in @udev and then calls
1007 * the suspend method for @udev itself. If an error occurs at any stage,
1008 * all the interfaces which were suspended are resumed so that they remain
1009 * in the same state as the device.
1011 * If an autosuspend is in progress (@udev->auto_pm is set), the routine
1012 * checks first to make sure that neither the device itself or any of its
1013 * active interfaces is in use (pm_usage_cnt is greater than 0). If they
1014 * are, the autosuspend fails.
1016 * If the suspend succeeds, the routine recursively queues an autosuspend
1017 * request for @udev's parent device, thereby propagating the change up
1018 * the device tree. If all of the parent's children are now suspended,
1019 * the parent will autosuspend in turn.
1021 * The suspend method calls are subject to mutual exclusion under control
1022 * of @udev's pm_mutex. Many of these calls are also under the protection
1023 * of @udev's device lock (including all requests originating outside the
1024 * USB subsystem), but autosuspend requests generated by a child device or
1025 * interface driver may not be. Usbcore will insure that the method calls
1026 * do not arrive during bind, unbind, or reset operations. However, drivers
1027 * must be prepared to handle suspend calls arriving at unpredictable times.
1028 * The only way to block such calls is to do an autoresume (preventing
1029 * autosuspends) while holding @udev's device lock (preventing outside
1032 * The caller must hold @udev->pm_mutex.
1034 * This routine can run only in process context.
1036 static int usb_suspend_both(struct usb_device
*udev
, pm_message_t msg
)
1040 struct usb_interface
*intf
;
1041 struct usb_device
*parent
= udev
->parent
;
1043 cancel_delayed_work(&udev
->autosuspend
);
1044 if (udev
->state
== USB_STATE_NOTATTACHED
)
1046 if (udev
->state
== USB_STATE_SUSPENDED
)
1049 udev
->do_remote_wakeup
= device_may_wakeup(&udev
->dev
);
1051 if (udev
->auto_pm
) {
1052 status
= autosuspend_check(udev
);
1057 /* Suspend all the interfaces and then udev itself */
1058 if (udev
->actconfig
) {
1059 for (; i
< udev
->actconfig
->desc
.bNumInterfaces
; i
++) {
1060 intf
= udev
->actconfig
->interface
[i
];
1061 status
= usb_suspend_interface(intf
, msg
);
1067 status
= usb_suspend_device(udev
, msg
);
1069 /* If the suspend failed, resume interfaces that did get suspended */
1072 intf
= udev
->actconfig
->interface
[i
];
1073 usb_resume_interface(intf
);
1076 /* If the suspend succeeded, propagate it up the tree */
1078 usb_autosuspend_device(parent
);
1080 // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
1085 * usb_resume_both - resume a USB device and its interfaces
1086 * @udev: the usb_device to resume
1088 * This is the central routine for resuming USB devices. It calls the
1089 * the resume method for @udev and then calls the resume methods for all
1090 * the interface drivers in @udev.
1092 * Before starting the resume, the routine calls itself recursively for
1093 * the parent device of @udev, thereby propagating the change up the device
1094 * tree and assuring that @udev will be able to resume. If the parent is
1095 * unable to resume successfully, the routine fails.
1097 * The resume method calls are subject to mutual exclusion under control
1098 * of @udev's pm_mutex. Many of these calls are also under the protection
1099 * of @udev's device lock (including all requests originating outside the
1100 * USB subsystem), but autoresume requests generated by a child device or
1101 * interface driver may not be. Usbcore will insure that the method calls
1102 * do not arrive during bind, unbind, or reset operations. However, drivers
1103 * must be prepared to handle resume calls arriving at unpredictable times.
1104 * The only way to block such calls is to do an autoresume (preventing
1105 * other autoresumes) while holding @udev's device lock (preventing outside
1108 * The caller must hold @udev->pm_mutex.
1110 * This routine can run only in process context.
1112 static int usb_resume_both(struct usb_device
*udev
)
1116 struct usb_interface
*intf
;
1117 struct usb_device
*parent
= udev
->parent
;
1119 cancel_delayed_work(&udev
->autosuspend
);
1120 if (udev
->state
== USB_STATE_NOTATTACHED
)
1123 /* Propagate the resume up the tree, if necessary */
1124 if (udev
->state
== USB_STATE_SUSPENDED
) {
1126 status
= usb_autoresume_device(parent
);
1128 status
= usb_resume_device(udev
);
1130 usb_autosuspend_device(parent
);
1132 /* It's possible usb_resume_device()
1133 * failed after the port was
1134 * unsuspended, causing udev to be
1135 * logically disconnected. We don't
1136 * want usb_disconnect() to autosuspend
1137 * the parent again, so tell it that
1138 * udev disconnected while still
1141 USB_STATE_NOTATTACHED
)
1142 udev
->discon_suspended
= 1;
1147 /* We can't progagate beyond the USB subsystem,
1148 * so if a root hub's controller is suspended
1149 * then we're stuck. */
1150 if (udev
->dev
.parent
->power
.power_state
.event
!=
1152 status
= -EHOSTUNREACH
;
1154 status
= usb_resume_device(udev
);
1158 /* Needed only for setting udev->dev.power.power_state.event
1159 * and for possible debugging message. */
1160 status
= usb_resume_device(udev
);
1163 if (status
== 0 && udev
->actconfig
) {
1164 for (i
= 0; i
< udev
->actconfig
->desc
.bNumInterfaces
; i
++) {
1165 intf
= udev
->actconfig
->interface
[i
];
1166 usb_resume_interface(intf
);
1170 // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
1174 #ifdef CONFIG_USB_SUSPEND
1176 /* usb_autosuspend_work - callback routine to autosuspend a USB device */
1177 void usb_autosuspend_work(struct work_struct
*work
)
1179 struct usb_device
*udev
=
1180 container_of(work
, struct usb_device
, autosuspend
.work
);
1184 usb_suspend_both(udev
, PMSG_SUSPEND
);
1185 usb_pm_unlock(udev
);
1188 /* Internal routine to adjust a device's usage counter and change
1189 * its autosuspend state.
1191 static int usb_autopm_do_device(struct usb_device
*udev
, int inc_usage_cnt
)
1196 udev
->pm_usage_cnt
+= inc_usage_cnt
;
1197 WARN_ON(udev
->pm_usage_cnt
< 0);
1198 if (inc_usage_cnt
>= 0 && udev
->pm_usage_cnt
> 0) {
1200 status
= usb_resume_both(udev
);
1202 udev
->pm_usage_cnt
-= inc_usage_cnt
;
1203 } else if (inc_usage_cnt
<= 0 && autosuspend_check(udev
) == 0)
1204 queue_delayed_work(ksuspend_usb_wq
, &udev
->autosuspend
,
1205 udev
->autosuspend_delay
);
1206 usb_pm_unlock(udev
);
1211 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
1212 * @udev: the usb_device to autosuspend
1214 * This routine should be called when a core subsystem is finished using
1215 * @udev and wants to allow it to autosuspend. Examples would be when
1216 * @udev's device file in usbfs is closed or after a configuration change.
1218 * @udev's usage counter is decremented. If it or any of the usage counters
1219 * for an active interface is greater than 0, no autosuspend request will be
1220 * queued. (If an interface driver does not support autosuspend then its
1221 * usage counter is permanently positive.) Furthermore, if an interface
1222 * driver requires remote-wakeup capability during autosuspend but remote
1223 * wakeup is disabled, the autosuspend will fail.
1225 * Often the caller will hold @udev's device lock, but this is not
1228 * This routine can run only in process context.
1230 void usb_autosuspend_device(struct usb_device
*udev
)
1234 status
= usb_autopm_do_device(udev
, -1);
1235 // dev_dbg(&udev->dev, "%s: cnt %d\n",
1236 // __FUNCTION__, udev->pm_usage_cnt);
1240 * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
1241 * @udev: the usb_device to autosuspend
1243 * This routine should be called when a core subsystem thinks @udev may
1244 * be ready to autosuspend.
1246 * @udev's usage counter left unchanged. If it or any of the usage counters
1247 * for an active interface is greater than 0, or autosuspend is not allowed
1248 * for any other reason, no autosuspend request will be queued.
1250 * This routine can run only in process context.
1252 void usb_try_autosuspend_device(struct usb_device
*udev
)
1254 usb_autopm_do_device(udev
, 0);
1255 // dev_dbg(&udev->dev, "%s: cnt %d\n",
1256 // __FUNCTION__, udev->pm_usage_cnt);
1260 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
1261 * @udev: the usb_device to autoresume
1263 * This routine should be called when a core subsystem wants to use @udev
1264 * and needs to guarantee that it is not suspended. No autosuspend will
1265 * occur until usb_autosuspend_device is called. (Note that this will not
1266 * prevent suspend events originating in the PM core.) Examples would be
1267 * when @udev's device file in usbfs is opened or when a remote-wakeup
1268 * request is received.
1270 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1271 * However if the autoresume fails then the usage counter is re-decremented.
1273 * Often the caller will hold @udev's device lock, but this is not
1274 * necessary (and attempting it might cause deadlock).
1276 * This routine can run only in process context.
1278 int usb_autoresume_device(struct usb_device
*udev
)
1282 status
= usb_autopm_do_device(udev
, 1);
1283 // dev_dbg(&udev->dev, "%s: status %d cnt %d\n",
1284 // __FUNCTION__, status, udev->pm_usage_cnt);
1288 /* Internal routine to adjust an interface's usage counter and change
1289 * its device's autosuspend state.
1291 static int usb_autopm_do_interface(struct usb_interface
*intf
,
1294 struct usb_device
*udev
= interface_to_usbdev(intf
);
1298 if (intf
->condition
== USB_INTERFACE_UNBOUND
)
1301 intf
->pm_usage_cnt
+= inc_usage_cnt
;
1302 if (inc_usage_cnt
>= 0 && intf
->pm_usage_cnt
> 0) {
1304 status
= usb_resume_both(udev
);
1306 intf
->pm_usage_cnt
-= inc_usage_cnt
;
1307 } else if (inc_usage_cnt
<= 0 && autosuspend_check(udev
) == 0)
1308 queue_delayed_work(ksuspend_usb_wq
, &udev
->autosuspend
,
1309 udev
->autosuspend_delay
);
1311 usb_pm_unlock(udev
);
1316 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
1317 * @intf: the usb_interface whose counter should be decremented
1319 * This routine should be called by an interface driver when it is
1320 * finished using @intf and wants to allow it to autosuspend. A typical
1321 * example would be a character-device driver when its device file is
1324 * The routine decrements @intf's usage counter. When the counter reaches
1325 * 0, a delayed autosuspend request for @intf's device is queued. When
1326 * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
1327 * the other usage counters for the sibling interfaces and @intf's
1328 * usb_device, the device and all its interfaces will be autosuspended.
1330 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1331 * core will not change its value other than the increment and decrement
1332 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1333 * may use this simple counter-oriented discipline or may set the value
1336 * If the driver has set @intf->needs_remote_wakeup then autosuspend will
1337 * take place only if the device's remote-wakeup facility is enabled.
1339 * Suspend method calls queued by this routine can arrive at any time
1340 * while @intf is resumed and its usage counter is equal to 0. They are
1341 * not protected by the usb_device's lock but only by its pm_mutex.
1342 * Drivers must provide their own synchronization.
1344 * This routine can run only in process context.
1346 void usb_autopm_put_interface(struct usb_interface
*intf
)
1350 status
= usb_autopm_do_interface(intf
, -1);
1351 // dev_dbg(&intf->dev, "%s: status %d cnt %d\n",
1352 // __FUNCTION__, status, intf->pm_usage_cnt);
1354 EXPORT_SYMBOL_GPL(usb_autopm_put_interface
);
1357 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
1358 * @intf: the usb_interface whose counter should be incremented
1360 * This routine should be called by an interface driver when it wants to
1361 * use @intf and needs to guarantee that it is not suspended. In addition,
1362 * the routine prevents @intf from being autosuspended subsequently. (Note
1363 * that this will not prevent suspend events originating in the PM core.)
1364 * This prevention will persist until usb_autopm_put_interface() is called
1365 * or @intf is unbound. A typical example would be a character-device
1366 * driver when its device file is opened.
1368 * The routine increments @intf's usage counter. So long as the counter
1369 * is greater than 0, autosuspend will not be allowed for @intf or its
1370 * usb_device. When the driver is finished using @intf it should call
1371 * usb_autopm_put_interface() to decrement the usage counter and queue
1372 * a delayed autosuspend request (if the counter is <= 0).
1374 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1375 * core will not change its value other than the increment and decrement
1376 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1377 * may use this simple counter-oriented discipline or may set the value
1380 * Resume method calls generated by this routine can arrive at any time
1381 * while @intf is suspended. They are not protected by the usb_device's
1382 * lock but only by its pm_mutex. Drivers must provide their own
1385 * This routine can run only in process context.
1387 int usb_autopm_get_interface(struct usb_interface
*intf
)
1391 status
= usb_autopm_do_interface(intf
, 1);
1392 // dev_dbg(&intf->dev, "%s: status %d cnt %d\n",
1393 // __FUNCTION__, status, intf->pm_usage_cnt);
1396 EXPORT_SYMBOL_GPL(usb_autopm_get_interface
);
1399 * usb_autopm_set_interface - set a USB interface's autosuspend state
1400 * @intf: the usb_interface whose state should be set
1402 * This routine sets the autosuspend state of @intf's device according
1403 * to @intf's usage counter, which the caller must have set previously.
1404 * If the counter is <= 0, the device is autosuspended (if it isn't
1405 * already suspended and if nothing else prevents the autosuspend). If
1406 * the counter is > 0, the device is autoresumed (if it isn't already
1409 int usb_autopm_set_interface(struct usb_interface
*intf
)
1413 status
= usb_autopm_do_interface(intf
, 0);
1414 // dev_dbg(&intf->dev, "%s: status %d cnt %d\n",
1415 // __FUNCTION__, status, intf->pm_usage_cnt);
1418 EXPORT_SYMBOL_GPL(usb_autopm_set_interface
);
1422 void usb_autosuspend_work(struct work_struct
*work
)
1425 #endif /* CONFIG_USB_SUSPEND */
1428 * usb_external_suspend_device - external suspend of a USB device and its interfaces
1429 * @udev: the usb_device to suspend
1430 * @msg: Power Management message describing this state transition
1432 * This routine handles external suspend requests: ones not generated
1433 * internally by a USB driver (autosuspend) but rather coming from the user
1434 * (via sysfs) or the PM core (system sleep). The suspend will be carried
1435 * out regardless of @udev's usage counter or those of its interfaces,
1436 * and regardless of whether or not remote wakeup is enabled. Of course,
1437 * interface drivers still have the option of failing the suspend (if
1438 * there are unsuspended children, for example).
1440 * The caller must hold @udev's device lock.
1442 int usb_external_suspend_device(struct usb_device
*udev
, pm_message_t msg
)
1448 status
= usb_suspend_both(udev
, msg
);
1449 usb_pm_unlock(udev
);
1454 * usb_external_resume_device - external resume of a USB device and its interfaces
1455 * @udev: the usb_device to resume
1457 * This routine handles external resume requests: ones not generated
1458 * internally by a USB driver (autoresume) but rather coming from the user
1459 * (via sysfs), the PM core (system resume), or the device itself (remote
1460 * wakeup). @udev's usage counter is unaffected.
1462 * The caller must hold @udev's device lock.
1464 int usb_external_resume_device(struct usb_device
*udev
)
1470 status
= usb_resume_both(udev
);
1471 usb_pm_unlock(udev
);
1473 /* Now that the device is awake, we can start trying to autosuspend
1476 usb_try_autosuspend_device(udev
);
1480 static int usb_suspend(struct device
*dev
, pm_message_t message
)
1482 if (!is_usb_device(dev
)) /* Ignore PM for interfaces */
1484 return usb_external_suspend_device(to_usb_device(dev
), message
);
1487 static int usb_resume(struct device
*dev
)
1489 if (!is_usb_device(dev
)) /* Ignore PM for interfaces */
1491 return usb_external_resume_device(to_usb_device(dev
));
1496 #define usb_suspend NULL
1497 #define usb_resume NULL
1499 #endif /* CONFIG_PM */
1501 struct bus_type usb_bus_type
= {
1503 .match
= usb_device_match
,
1504 .uevent
= usb_uevent
,
1505 .suspend
= usb_suspend
,
1506 .resume
= usb_resume
,