98760553bc95f84b098e4b39999c1163122c3344
[deliverable/linux.git] / drivers / usb / core / driver.c
1 /*
2 * drivers/usb/driver.c - most of the driver model stuff for usb
3 *
4 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
5 *
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
17 *
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
21 * real drivers.
22 *
23 */
24
25 #include <linux/device.h>
26 #include <linux/usb.h>
27 #include <linux/usb/quirks.h>
28 #include <linux/workqueue.h>
29 #include "hcd.h"
30 #include "usb.h"
31
32
33 #ifdef CONFIG_HOTPLUG
34
35 /*
36 * Adds a new dynamic USBdevice ID to this driver,
37 * and cause the driver to probe for all devices again.
38 */
39 ssize_t usb_store_new_id(struct usb_dynids *dynids,
40 struct device_driver *driver,
41 const char *buf, size_t count)
42 {
43 struct usb_dynid *dynid;
44 u32 idVendor = 0;
45 u32 idProduct = 0;
46 int fields = 0;
47 int retval = 0;
48
49 fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
50 if (fields < 2)
51 return -EINVAL;
52
53 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
54 if (!dynid)
55 return -ENOMEM;
56
57 INIT_LIST_HEAD(&dynid->node);
58 dynid->id.idVendor = idVendor;
59 dynid->id.idProduct = idProduct;
60 dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
61
62 spin_lock(&dynids->lock);
63 list_add_tail(&dynid->node, &dynids->list);
64 spin_unlock(&dynids->lock);
65
66 if (get_driver(driver)) {
67 retval = driver_attach(driver);
68 put_driver(driver);
69 }
70
71 if (retval)
72 return retval;
73 return count;
74 }
75 EXPORT_SYMBOL_GPL(usb_store_new_id);
76
77 static ssize_t store_new_id(struct device_driver *driver,
78 const char *buf, size_t count)
79 {
80 struct usb_driver *usb_drv = to_usb_driver(driver);
81
82 return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
83 }
84 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
85
86 static int usb_create_newid_file(struct usb_driver *usb_drv)
87 {
88 int error = 0;
89
90 if (usb_drv->no_dynamic_id)
91 goto exit;
92
93 if (usb_drv->probe != NULL)
94 error = driver_create_file(&usb_drv->drvwrap.driver,
95 &driver_attr_new_id);
96 exit:
97 return error;
98 }
99
100 static void usb_remove_newid_file(struct usb_driver *usb_drv)
101 {
102 if (usb_drv->no_dynamic_id)
103 return;
104
105 if (usb_drv->probe != NULL)
106 driver_remove_file(&usb_drv->drvwrap.driver,
107 &driver_attr_new_id);
108 }
109
110 static void usb_free_dynids(struct usb_driver *usb_drv)
111 {
112 struct usb_dynid *dynid, *n;
113
114 spin_lock(&usb_drv->dynids.lock);
115 list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
116 list_del(&dynid->node);
117 kfree(dynid);
118 }
119 spin_unlock(&usb_drv->dynids.lock);
120 }
121 #else
122 static inline int usb_create_newid_file(struct usb_driver *usb_drv)
123 {
124 return 0;
125 }
126
127 static void usb_remove_newid_file(struct usb_driver *usb_drv)
128 {
129 }
130
131 static inline void usb_free_dynids(struct usb_driver *usb_drv)
132 {
133 }
134 #endif
135
136 static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
137 struct usb_driver *drv)
138 {
139 struct usb_dynid *dynid;
140
141 spin_lock(&drv->dynids.lock);
142 list_for_each_entry(dynid, &drv->dynids.list, node) {
143 if (usb_match_one_id(intf, &dynid->id)) {
144 spin_unlock(&drv->dynids.lock);
145 return &dynid->id;
146 }
147 }
148 spin_unlock(&drv->dynids.lock);
149 return NULL;
150 }
151
152
153 /* called from driver core with dev locked */
154 static int usb_probe_device(struct device *dev)
155 {
156 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
157 struct usb_device *udev;
158 int error = -ENODEV;
159
160 dev_dbg(dev, "%s\n", __func__);
161
162 if (!is_usb_device(dev)) /* Sanity check */
163 return error;
164
165 udev = to_usb_device(dev);
166
167 /* TODO: Add real matching code */
168
169 /* The device should always appear to be in use
170 * unless the driver suports autosuspend.
171 */
172 udev->pm_usage_cnt = !(udriver->supports_autosuspend);
173
174 error = udriver->probe(udev);
175 return error;
176 }
177
178 /* called from driver core with dev locked */
179 static int usb_unbind_device(struct device *dev)
180 {
181 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
182
183 udriver->disconnect(to_usb_device(dev));
184 return 0;
185 }
186
187 /*
188 * Cancel any pending scheduled resets
189 *
190 * [see usb_queue_reset_device()]
191 *
192 * Called after unconfiguring / when releasing interfaces. See
193 * comments in __usb_queue_reset_device() regarding
194 * udev->reset_running.
195 */
196 static void usb_cancel_queued_reset(struct usb_interface *iface)
197 {
198 if (iface->reset_running == 0)
199 cancel_work_sync(&iface->reset_ws);
200 }
201
202 /* called from driver core with dev locked */
203 static int usb_probe_interface(struct device *dev)
204 {
205 struct usb_driver *driver = to_usb_driver(dev->driver);
206 struct usb_interface *intf;
207 struct usb_device *udev;
208 const struct usb_device_id *id;
209 int error = -ENODEV;
210
211 dev_dbg(dev, "%s\n", __func__);
212
213 if (is_usb_device(dev)) /* Sanity check */
214 return error;
215
216 intf = to_usb_interface(dev);
217 udev = interface_to_usbdev(intf);
218 intf->needs_binding = 0;
219
220 if (udev->authorized == 0) {
221 dev_err(&intf->dev, "Device is not authorized for usage\n");
222 return -ENODEV;
223 }
224
225 id = usb_match_id(intf, driver->id_table);
226 if (!id)
227 id = usb_match_dynamic_id(intf, driver);
228 if (id) {
229 dev_dbg(dev, "%s - got id\n", __func__);
230
231 error = usb_autoresume_device(udev);
232 if (error)
233 return error;
234
235 /* Interface "power state" doesn't correspond to any hardware
236 * state whatsoever. We use it to record when it's bound to
237 * a driver that may start I/0: it's not frozen/quiesced.
238 */
239 mark_active(intf);
240 intf->condition = USB_INTERFACE_BINDING;
241
242 /* The interface should always appear to be in use
243 * unless the driver suports autosuspend.
244 */
245 intf->pm_usage_cnt = !(driver->supports_autosuspend);
246
247 /* Carry out a deferred switch to altsetting 0 */
248 if (intf->needs_altsetting0) {
249 usb_set_interface(udev, intf->altsetting[0].
250 desc.bInterfaceNumber, 0);
251 intf->needs_altsetting0 = 0;
252 }
253
254 error = driver->probe(intf, id);
255 if (error) {
256 mark_quiesced(intf);
257 intf->needs_remote_wakeup = 0;
258 intf->condition = USB_INTERFACE_UNBOUND;
259 usb_cancel_queued_reset(intf);
260 } else
261 intf->condition = USB_INTERFACE_BOUND;
262
263 usb_autosuspend_device(udev);
264 }
265
266 return error;
267 }
268
269 /* called from driver core with dev locked */
270 static int usb_unbind_interface(struct device *dev)
271 {
272 struct usb_driver *driver = to_usb_driver(dev->driver);
273 struct usb_interface *intf = to_usb_interface(dev);
274 struct usb_device *udev;
275 int error;
276
277 intf->condition = USB_INTERFACE_UNBINDING;
278
279 /* Autoresume for set_interface call below */
280 udev = interface_to_usbdev(intf);
281 error = usb_autoresume_device(udev);
282
283 /* Terminate all URBs for this interface unless the driver
284 * supports "soft" unbinding.
285 */
286 if (!driver->soft_unbind)
287 usb_disable_interface(udev, intf);
288
289 driver->disconnect(intf);
290 usb_cancel_queued_reset(intf);
291
292 /* Reset other interface state.
293 * We cannot do a Set-Interface if the device is suspended or
294 * if it is prepared for a system sleep (since installing a new
295 * altsetting means creating new endpoint device entries).
296 * When either of these happens, defer the Set-Interface.
297 */
298 if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
299 /* Already in altsetting 0 so skip Set-Interface.
300 * Just re-enable it without affecting the endpoint toggles.
301 */
302 usb_enable_interface(udev, intf, false);
303 } else if (!error && intf->dev.power.status == DPM_ON)
304 usb_set_interface(udev, intf->altsetting[0].
305 desc.bInterfaceNumber, 0);
306 else
307 intf->needs_altsetting0 = 1;
308 usb_set_intfdata(intf, NULL);
309
310 intf->condition = USB_INTERFACE_UNBOUND;
311 mark_quiesced(intf);
312 intf->needs_remote_wakeup = 0;
313
314 if (!error)
315 usb_autosuspend_device(udev);
316
317 return 0;
318 }
319
320 /**
321 * usb_driver_claim_interface - bind a driver to an interface
322 * @driver: the driver to be bound
323 * @iface: the interface to which it will be bound; must be in the
324 * usb device's active configuration
325 * @priv: driver data associated with that interface
326 *
327 * This is used by usb device drivers that need to claim more than one
328 * interface on a device when probing (audio and acm are current examples).
329 * No device driver should directly modify internal usb_interface or
330 * usb_device structure members.
331 *
332 * Few drivers should need to use this routine, since the most natural
333 * way to bind to an interface is to return the private data from
334 * the driver's probe() method.
335 *
336 * Callers must own the device lock, so driver probe() entries don't need
337 * extra locking, but other call contexts may need to explicitly claim that
338 * lock.
339 */
340 int usb_driver_claim_interface(struct usb_driver *driver,
341 struct usb_interface *iface, void *priv)
342 {
343 struct device *dev = &iface->dev;
344 struct usb_device *udev = interface_to_usbdev(iface);
345 int retval = 0;
346
347 if (dev->driver)
348 return -EBUSY;
349
350 dev->driver = &driver->drvwrap.driver;
351 usb_set_intfdata(iface, priv);
352 iface->needs_binding = 0;
353
354 usb_pm_lock(udev);
355 iface->condition = USB_INTERFACE_BOUND;
356 mark_active(iface);
357 iface->pm_usage_cnt = !(driver->supports_autosuspend);
358 usb_pm_unlock(udev);
359
360 /* if interface was already added, bind now; else let
361 * the future device_add() bind it, bypassing probe()
362 */
363 if (device_is_registered(dev))
364 retval = device_bind_driver(dev);
365
366 return retval;
367 }
368 EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
369
370 /**
371 * usb_driver_release_interface - unbind a driver from an interface
372 * @driver: the driver to be unbound
373 * @iface: the interface from which it will be unbound
374 *
375 * This can be used by drivers to release an interface without waiting
376 * for their disconnect() methods to be called. In typical cases this
377 * also causes the driver disconnect() method to be called.
378 *
379 * This call is synchronous, and may not be used in an interrupt context.
380 * Callers must own the device lock, so driver disconnect() entries don't
381 * need extra locking, but other call contexts may need to explicitly claim
382 * that lock.
383 */
384 void usb_driver_release_interface(struct usb_driver *driver,
385 struct usb_interface *iface)
386 {
387 struct device *dev = &iface->dev;
388 struct usb_device *udev = interface_to_usbdev(iface);
389
390 /* this should never happen, don't release something that's not ours */
391 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
392 return;
393
394 /* don't release from within disconnect() */
395 if (iface->condition != USB_INTERFACE_BOUND)
396 return;
397
398 /* don't release if the interface hasn't been added yet */
399 if (device_is_registered(dev)) {
400 iface->condition = USB_INTERFACE_UNBINDING;
401 device_release_driver(dev);
402 } else {
403 iface->condition = USB_INTERFACE_UNBOUND;
404 usb_cancel_queued_reset(iface);
405 }
406 dev->driver = NULL;
407 usb_set_intfdata(iface, NULL);
408
409 usb_pm_lock(udev);
410 iface->condition = USB_INTERFACE_UNBOUND;
411 mark_quiesced(iface);
412 iface->needs_remote_wakeup = 0;
413 usb_pm_unlock(udev);
414 }
415 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
416
417 /* returns 0 if no match, 1 if match */
418 int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
419 {
420 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
421 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
422 return 0;
423
424 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
425 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
426 return 0;
427
428 /* No need to test id->bcdDevice_lo != 0, since 0 is never
429 greater than any unsigned number. */
430 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
431 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
432 return 0;
433
434 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
435 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
436 return 0;
437
438 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
439 (id->bDeviceClass != dev->descriptor.bDeviceClass))
440 return 0;
441
442 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
443 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
444 return 0;
445
446 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
447 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
448 return 0;
449
450 return 1;
451 }
452
453 /* returns 0 if no match, 1 if match */
454 int usb_match_one_id(struct usb_interface *interface,
455 const struct usb_device_id *id)
456 {
457 struct usb_host_interface *intf;
458 struct usb_device *dev;
459
460 /* proc_connectinfo in devio.c may call us with id == NULL. */
461 if (id == NULL)
462 return 0;
463
464 intf = interface->cur_altsetting;
465 dev = interface_to_usbdev(interface);
466
467 if (!usb_match_device(dev, id))
468 return 0;
469
470 /* The interface class, subclass, and protocol should never be
471 * checked for a match if the device class is Vendor Specific,
472 * unless the match record specifies the Vendor ID. */
473 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
474 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
475 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
476 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
477 USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
478 return 0;
479
480 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
481 (id->bInterfaceClass != intf->desc.bInterfaceClass))
482 return 0;
483
484 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
485 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
486 return 0;
487
488 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
489 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
490 return 0;
491
492 return 1;
493 }
494 EXPORT_SYMBOL_GPL(usb_match_one_id);
495
496 /**
497 * usb_match_id - find first usb_device_id matching device or interface
498 * @interface: the interface of interest
499 * @id: array of usb_device_id structures, terminated by zero entry
500 *
501 * usb_match_id searches an array of usb_device_id's and returns
502 * the first one matching the device or interface, or null.
503 * This is used when binding (or rebinding) a driver to an interface.
504 * Most USB device drivers will use this indirectly, through the usb core,
505 * but some layered driver frameworks use it directly.
506 * These device tables are exported with MODULE_DEVICE_TABLE, through
507 * modutils, to support the driver loading functionality of USB hotplugging.
508 *
509 * What Matches:
510 *
511 * The "match_flags" element in a usb_device_id controls which
512 * members are used. If the corresponding bit is set, the
513 * value in the device_id must match its corresponding member
514 * in the device or interface descriptor, or else the device_id
515 * does not match.
516 *
517 * "driver_info" is normally used only by device drivers,
518 * but you can create a wildcard "matches anything" usb_device_id
519 * as a driver's "modules.usbmap" entry if you provide an id with
520 * only a nonzero "driver_info" field. If you do this, the USB device
521 * driver's probe() routine should use additional intelligence to
522 * decide whether to bind to the specified interface.
523 *
524 * What Makes Good usb_device_id Tables:
525 *
526 * The match algorithm is very simple, so that intelligence in
527 * driver selection must come from smart driver id records.
528 * Unless you have good reasons to use another selection policy,
529 * provide match elements only in related groups, and order match
530 * specifiers from specific to general. Use the macros provided
531 * for that purpose if you can.
532 *
533 * The most specific match specifiers use device descriptor
534 * data. These are commonly used with product-specific matches;
535 * the USB_DEVICE macro lets you provide vendor and product IDs,
536 * and you can also match against ranges of product revisions.
537 * These are widely used for devices with application or vendor
538 * specific bDeviceClass values.
539 *
540 * Matches based on device class/subclass/protocol specifications
541 * are slightly more general; use the USB_DEVICE_INFO macro, or
542 * its siblings. These are used with single-function devices
543 * where bDeviceClass doesn't specify that each interface has
544 * its own class.
545 *
546 * Matches based on interface class/subclass/protocol are the
547 * most general; they let drivers bind to any interface on a
548 * multiple-function device. Use the USB_INTERFACE_INFO
549 * macro, or its siblings, to match class-per-interface style
550 * devices (as recorded in bInterfaceClass).
551 *
552 * Note that an entry created by USB_INTERFACE_INFO won't match
553 * any interface if the device class is set to Vendor-Specific.
554 * This is deliberate; according to the USB spec the meanings of
555 * the interface class/subclass/protocol for these devices are also
556 * vendor-specific, and hence matching against a standard product
557 * class wouldn't work anyway. If you really want to use an
558 * interface-based match for such a device, create a match record
559 * that also specifies the vendor ID. (Unforunately there isn't a
560 * standard macro for creating records like this.)
561 *
562 * Within those groups, remember that not all combinations are
563 * meaningful. For example, don't give a product version range
564 * without vendor and product IDs; or specify a protocol without
565 * its associated class and subclass.
566 */
567 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
568 const struct usb_device_id *id)
569 {
570 /* proc_connectinfo in devio.c may call us with id == NULL. */
571 if (id == NULL)
572 return NULL;
573
574 /* It is important to check that id->driver_info is nonzero,
575 since an entry that is all zeroes except for a nonzero
576 id->driver_info is the way to create an entry that
577 indicates that the driver want to examine every
578 device and interface. */
579 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
580 id->bInterfaceClass || id->driver_info; id++) {
581 if (usb_match_one_id(interface, id))
582 return id;
583 }
584
585 return NULL;
586 }
587 EXPORT_SYMBOL_GPL(usb_match_id);
588
589 static int usb_device_match(struct device *dev, struct device_driver *drv)
590 {
591 /* devices and interfaces are handled separately */
592 if (is_usb_device(dev)) {
593
594 /* interface drivers never match devices */
595 if (!is_usb_device_driver(drv))
596 return 0;
597
598 /* TODO: Add real matching code */
599 return 1;
600
601 } else {
602 struct usb_interface *intf;
603 struct usb_driver *usb_drv;
604 const struct usb_device_id *id;
605
606 /* device drivers never match interfaces */
607 if (is_usb_device_driver(drv))
608 return 0;
609
610 intf = to_usb_interface(dev);
611 usb_drv = to_usb_driver(drv);
612
613 id = usb_match_id(intf, usb_drv->id_table);
614 if (id)
615 return 1;
616
617 id = usb_match_dynamic_id(intf, usb_drv);
618 if (id)
619 return 1;
620 }
621
622 return 0;
623 }
624
625 #ifdef CONFIG_HOTPLUG
626 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
627 {
628 struct usb_device *usb_dev;
629
630 /* driver is often null here; dev_dbg() would oops */
631 pr_debug("usb %s: uevent\n", dev_name(dev));
632
633 if (is_usb_device(dev))
634 usb_dev = to_usb_device(dev);
635 else {
636 struct usb_interface *intf = to_usb_interface(dev);
637 usb_dev = interface_to_usbdev(intf);
638 }
639
640 if (usb_dev->devnum < 0) {
641 pr_debug("usb %s: already deleted?\n", dev_name(dev));
642 return -ENODEV;
643 }
644 if (!usb_dev->bus) {
645 pr_debug("usb %s: bus removed?\n", dev_name(dev));
646 return -ENODEV;
647 }
648
649 #ifdef CONFIG_USB_DEVICEFS
650 /* If this is available, userspace programs can directly read
651 * all the device descriptors we don't tell them about. Or
652 * act as usermode drivers.
653 */
654 if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
655 usb_dev->bus->busnum, usb_dev->devnum))
656 return -ENOMEM;
657 #endif
658
659 /* per-device configurations are common */
660 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
661 le16_to_cpu(usb_dev->descriptor.idVendor),
662 le16_to_cpu(usb_dev->descriptor.idProduct),
663 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
664 return -ENOMEM;
665
666 /* class-based driver binding models */
667 if (add_uevent_var(env, "TYPE=%d/%d/%d",
668 usb_dev->descriptor.bDeviceClass,
669 usb_dev->descriptor.bDeviceSubClass,
670 usb_dev->descriptor.bDeviceProtocol))
671 return -ENOMEM;
672
673 return 0;
674 }
675
676 #else
677
678 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
679 {
680 return -ENODEV;
681 }
682 #endif /* CONFIG_HOTPLUG */
683
684 /**
685 * usb_register_device_driver - register a USB device (not interface) driver
686 * @new_udriver: USB operations for the device driver
687 * @owner: module owner of this driver.
688 *
689 * Registers a USB device driver with the USB core. The list of
690 * unattached devices will be rescanned whenever a new driver is
691 * added, allowing the new driver to attach to any recognized devices.
692 * Returns a negative error code on failure and 0 on success.
693 */
694 int usb_register_device_driver(struct usb_device_driver *new_udriver,
695 struct module *owner)
696 {
697 int retval = 0;
698
699 if (usb_disabled())
700 return -ENODEV;
701
702 new_udriver->drvwrap.for_devices = 1;
703 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
704 new_udriver->drvwrap.driver.bus = &usb_bus_type;
705 new_udriver->drvwrap.driver.probe = usb_probe_device;
706 new_udriver->drvwrap.driver.remove = usb_unbind_device;
707 new_udriver->drvwrap.driver.owner = owner;
708
709 retval = driver_register(&new_udriver->drvwrap.driver);
710
711 if (!retval) {
712 pr_info("%s: registered new device driver %s\n",
713 usbcore_name, new_udriver->name);
714 usbfs_update_special();
715 } else {
716 printk(KERN_ERR "%s: error %d registering device "
717 " driver %s\n",
718 usbcore_name, retval, new_udriver->name);
719 }
720
721 return retval;
722 }
723 EXPORT_SYMBOL_GPL(usb_register_device_driver);
724
725 /**
726 * usb_deregister_device_driver - unregister a USB device (not interface) driver
727 * @udriver: USB operations of the device driver to unregister
728 * Context: must be able to sleep
729 *
730 * Unlinks the specified driver from the internal USB driver list.
731 */
732 void usb_deregister_device_driver(struct usb_device_driver *udriver)
733 {
734 pr_info("%s: deregistering device driver %s\n",
735 usbcore_name, udriver->name);
736
737 driver_unregister(&udriver->drvwrap.driver);
738 usbfs_update_special();
739 }
740 EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
741
742 /**
743 * usb_register_driver - register a USB interface driver
744 * @new_driver: USB operations for the interface driver
745 * @owner: module owner of this driver.
746 * @mod_name: module name string
747 *
748 * Registers a USB interface driver with the USB core. The list of
749 * unattached interfaces will be rescanned whenever a new driver is
750 * added, allowing the new driver to attach to any recognized interfaces.
751 * Returns a negative error code on failure and 0 on success.
752 *
753 * NOTE: if you want your driver to use the USB major number, you must call
754 * usb_register_dev() to enable that functionality. This function no longer
755 * takes care of that.
756 */
757 int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
758 const char *mod_name)
759 {
760 int retval = 0;
761
762 if (usb_disabled())
763 return -ENODEV;
764
765 new_driver->drvwrap.for_devices = 0;
766 new_driver->drvwrap.driver.name = (char *) new_driver->name;
767 new_driver->drvwrap.driver.bus = &usb_bus_type;
768 new_driver->drvwrap.driver.probe = usb_probe_interface;
769 new_driver->drvwrap.driver.remove = usb_unbind_interface;
770 new_driver->drvwrap.driver.owner = owner;
771 new_driver->drvwrap.driver.mod_name = mod_name;
772 spin_lock_init(&new_driver->dynids.lock);
773 INIT_LIST_HEAD(&new_driver->dynids.list);
774
775 retval = driver_register(&new_driver->drvwrap.driver);
776
777 if (!retval) {
778 pr_info("%s: registered new interface driver %s\n",
779 usbcore_name, new_driver->name);
780 usbfs_update_special();
781 usb_create_newid_file(new_driver);
782 } else {
783 printk(KERN_ERR "%s: error %d registering interface "
784 " driver %s\n",
785 usbcore_name, retval, new_driver->name);
786 }
787
788 return retval;
789 }
790 EXPORT_SYMBOL_GPL(usb_register_driver);
791
792 /**
793 * usb_deregister - unregister a USB interface driver
794 * @driver: USB operations of the interface driver to unregister
795 * Context: must be able to sleep
796 *
797 * Unlinks the specified driver from the internal USB driver list.
798 *
799 * NOTE: If you called usb_register_dev(), you still need to call
800 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
801 * this * call will no longer do it for you.
802 */
803 void usb_deregister(struct usb_driver *driver)
804 {
805 pr_info("%s: deregistering interface driver %s\n",
806 usbcore_name, driver->name);
807
808 usb_remove_newid_file(driver);
809 usb_free_dynids(driver);
810 driver_unregister(&driver->drvwrap.driver);
811
812 usbfs_update_special();
813 }
814 EXPORT_SYMBOL_GPL(usb_deregister);
815
816 /* Forced unbinding of a USB interface driver, either because
817 * it doesn't support pre_reset/post_reset/reset_resume or
818 * because it doesn't support suspend/resume.
819 *
820 * The caller must hold @intf's device's lock, but not its pm_mutex
821 * and not @intf->dev.sem.
822 */
823 void usb_forced_unbind_intf(struct usb_interface *intf)
824 {
825 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
826
827 dev_dbg(&intf->dev, "forced unbind\n");
828 usb_driver_release_interface(driver, intf);
829
830 /* Mark the interface for later rebinding */
831 intf->needs_binding = 1;
832 }
833
834 /* Delayed forced unbinding of a USB interface driver and scan
835 * for rebinding.
836 *
837 * The caller must hold @intf's device's lock, but not its pm_mutex
838 * and not @intf->dev.sem.
839 *
840 * Note: Rebinds will be skipped if a system sleep transition is in
841 * progress and the PM "complete" callback hasn't occurred yet.
842 */
843 void usb_rebind_intf(struct usb_interface *intf)
844 {
845 int rc;
846
847 /* Delayed unbind of an existing driver */
848 if (intf->dev.driver) {
849 struct usb_driver *driver =
850 to_usb_driver(intf->dev.driver);
851
852 dev_dbg(&intf->dev, "forced unbind\n");
853 usb_driver_release_interface(driver, intf);
854 }
855
856 /* Try to rebind the interface */
857 if (intf->dev.power.status == DPM_ON) {
858 intf->needs_binding = 0;
859 rc = device_attach(&intf->dev);
860 if (rc < 0)
861 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
862 }
863 }
864
865 #ifdef CONFIG_PM
866
867 #define DO_UNBIND 0
868 #define DO_REBIND 1
869
870 /* Unbind drivers for @udev's interfaces that don't support suspend/resume,
871 * or rebind interfaces that have been unbound, according to @action.
872 *
873 * The caller must hold @udev's device lock.
874 */
875 static void do_unbind_rebind(struct usb_device *udev, int action)
876 {
877 struct usb_host_config *config;
878 int i;
879 struct usb_interface *intf;
880 struct usb_driver *drv;
881
882 config = udev->actconfig;
883 if (config) {
884 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
885 intf = config->interface[i];
886 switch (action) {
887 case DO_UNBIND:
888 if (intf->dev.driver) {
889 drv = to_usb_driver(intf->dev.driver);
890 if (!drv->suspend || !drv->resume)
891 usb_forced_unbind_intf(intf);
892 }
893 break;
894 case DO_REBIND:
895 if (intf->needs_binding)
896 usb_rebind_intf(intf);
897 break;
898 }
899 }
900 }
901 }
902
903 /* Caller has locked udev's pm_mutex */
904 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
905 {
906 struct usb_device_driver *udriver;
907 int status = 0;
908
909 if (udev->state == USB_STATE_NOTATTACHED ||
910 udev->state == USB_STATE_SUSPENDED)
911 goto done;
912
913 /* For devices that don't have a driver, we do a generic suspend. */
914 if (udev->dev.driver)
915 udriver = to_usb_device_driver(udev->dev.driver);
916 else {
917 udev->do_remote_wakeup = 0;
918 udriver = &usb_generic_driver;
919 }
920 status = udriver->suspend(udev, msg);
921
922 done:
923 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
924 return status;
925 }
926
927 /* Caller has locked udev's pm_mutex */
928 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
929 {
930 struct usb_device_driver *udriver;
931 int status = 0;
932
933 if (udev->state == USB_STATE_NOTATTACHED)
934 goto done;
935
936 /* Can't resume it if it doesn't have a driver. */
937 if (udev->dev.driver == NULL) {
938 status = -ENOTCONN;
939 goto done;
940 }
941
942 if (udev->quirks & USB_QUIRK_RESET_RESUME)
943 udev->reset_resume = 1;
944
945 udriver = to_usb_device_driver(udev->dev.driver);
946 status = udriver->resume(udev, msg);
947
948 done:
949 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
950 if (status == 0)
951 udev->autoresume_disabled = 0;
952 return status;
953 }
954
955 /* Caller has locked intf's usb_device's pm mutex */
956 static int usb_suspend_interface(struct usb_device *udev,
957 struct usb_interface *intf, pm_message_t msg)
958 {
959 struct usb_driver *driver;
960 int status = 0;
961
962 /* with no hardware, USB interfaces only use FREEZE and ON states */
963 if (udev->state == USB_STATE_NOTATTACHED || !is_active(intf))
964 goto done;
965
966 /* This can happen; see usb_driver_release_interface() */
967 if (intf->condition == USB_INTERFACE_UNBOUND)
968 goto done;
969 driver = to_usb_driver(intf->dev.driver);
970
971 if (driver->suspend) {
972 status = driver->suspend(intf, msg);
973 if (status == 0)
974 mark_quiesced(intf);
975 else if (!(msg.event & PM_EVENT_AUTO))
976 dev_err(&intf->dev, "%s error %d\n",
977 "suspend", status);
978 } else {
979 /* Later we will unbind the driver and reprobe */
980 intf->needs_binding = 1;
981 dev_warn(&intf->dev, "no %s for driver %s?\n",
982 "suspend", driver->name);
983 mark_quiesced(intf);
984 }
985
986 done:
987 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
988 return status;
989 }
990
991 /* Caller has locked intf's usb_device's pm_mutex */
992 static int usb_resume_interface(struct usb_device *udev,
993 struct usb_interface *intf, pm_message_t msg, int reset_resume)
994 {
995 struct usb_driver *driver;
996 int status = 0;
997
998 if (udev->state == USB_STATE_NOTATTACHED || is_active(intf))
999 goto done;
1000
1001 /* Don't let autoresume interfere with unbinding */
1002 if (intf->condition == USB_INTERFACE_UNBINDING)
1003 goto done;
1004
1005 /* Can't resume it if it doesn't have a driver. */
1006 if (intf->condition == USB_INTERFACE_UNBOUND) {
1007
1008 /* Carry out a deferred switch to altsetting 0 */
1009 if (intf->needs_altsetting0 &&
1010 intf->dev.power.status == DPM_ON) {
1011 usb_set_interface(udev, intf->altsetting[0].
1012 desc.bInterfaceNumber, 0);
1013 intf->needs_altsetting0 = 0;
1014 }
1015 goto done;
1016 }
1017
1018 /* Don't resume if the interface is marked for rebinding */
1019 if (intf->needs_binding)
1020 goto done;
1021 driver = to_usb_driver(intf->dev.driver);
1022
1023 if (reset_resume) {
1024 if (driver->reset_resume) {
1025 status = driver->reset_resume(intf);
1026 if (status)
1027 dev_err(&intf->dev, "%s error %d\n",
1028 "reset_resume", status);
1029 } else {
1030 intf->needs_binding = 1;
1031 dev_warn(&intf->dev, "no %s for driver %s?\n",
1032 "reset_resume", driver->name);
1033 }
1034 } else {
1035 if (driver->resume) {
1036 status = driver->resume(intf);
1037 if (status)
1038 dev_err(&intf->dev, "%s error %d\n",
1039 "resume", status);
1040 } else {
1041 intf->needs_binding = 1;
1042 dev_warn(&intf->dev, "no %s for driver %s?\n",
1043 "resume", driver->name);
1044 }
1045 }
1046
1047 done:
1048 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1049 if (status == 0 && intf->condition == USB_INTERFACE_BOUND)
1050 mark_active(intf);
1051
1052 /* Later we will unbind the driver and/or reprobe, if necessary */
1053 return status;
1054 }
1055
1056 #ifdef CONFIG_USB_SUSPEND
1057
1058 /* Internal routine to check whether we may autosuspend a device. */
1059 static int autosuspend_check(struct usb_device *udev, int reschedule)
1060 {
1061 int i;
1062 struct usb_interface *intf;
1063 unsigned long suspend_time, j;
1064
1065 /* For autosuspend, fail fast if anything is in use or autosuspend
1066 * is disabled. Also fail if any interfaces require remote wakeup
1067 * but it isn't available.
1068 */
1069 if (udev->pm_usage_cnt > 0)
1070 return -EBUSY;
1071 if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
1072 return -EPERM;
1073
1074 suspend_time = udev->last_busy + udev->autosuspend_delay;
1075 if (udev->actconfig) {
1076 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1077 intf = udev->actconfig->interface[i];
1078 if (!is_active(intf))
1079 continue;
1080 if (intf->pm_usage_cnt > 0)
1081 return -EBUSY;
1082 if (intf->needs_remote_wakeup &&
1083 !udev->do_remote_wakeup) {
1084 dev_dbg(&udev->dev, "remote wakeup needed "
1085 "for autosuspend\n");
1086 return -EOPNOTSUPP;
1087 }
1088
1089 /* Don't allow autosuspend if the device will need
1090 * a reset-resume and any of its interface drivers
1091 * doesn't include support.
1092 */
1093 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1094 struct usb_driver *driver;
1095
1096 driver = to_usb_driver(intf->dev.driver);
1097 if (!driver->reset_resume ||
1098 intf->needs_remote_wakeup)
1099 return -EOPNOTSUPP;
1100 }
1101 }
1102 }
1103
1104 /* If everything is okay but the device hasn't been idle for long
1105 * enough, queue a delayed autosuspend request. If the device
1106 * _has_ been idle for long enough and the reschedule flag is set,
1107 * likewise queue a delayed (1 second) autosuspend request.
1108 */
1109 j = jiffies;
1110 if (time_before(j, suspend_time))
1111 reschedule = 1;
1112 else
1113 suspend_time = j + HZ;
1114 if (reschedule) {
1115 if (!timer_pending(&udev->autosuspend.timer)) {
1116 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
1117 round_jiffies_up_relative(suspend_time - j));
1118 }
1119 return -EAGAIN;
1120 }
1121 return 0;
1122 }
1123
1124 #else
1125
1126 static inline int autosuspend_check(struct usb_device *udev, int reschedule)
1127 {
1128 return 0;
1129 }
1130
1131 #endif /* CONFIG_USB_SUSPEND */
1132
1133 /**
1134 * usb_suspend_both - suspend a USB device and its interfaces
1135 * @udev: the usb_device to suspend
1136 * @msg: Power Management message describing this state transition
1137 *
1138 * This is the central routine for suspending USB devices. It calls the
1139 * suspend methods for all the interface drivers in @udev and then calls
1140 * the suspend method for @udev itself. If an error occurs at any stage,
1141 * all the interfaces which were suspended are resumed so that they remain
1142 * in the same state as the device.
1143 *
1144 * If an autosuspend is in progress the routine checks first to make sure
1145 * that neither the device itself or any of its active interfaces is in use
1146 * (pm_usage_cnt is greater than 0). If they are, the autosuspend fails.
1147 *
1148 * If the suspend succeeds, the routine recursively queues an autosuspend
1149 * request for @udev's parent device, thereby propagating the change up
1150 * the device tree. If all of the parent's children are now suspended,
1151 * the parent will autosuspend in turn.
1152 *
1153 * The suspend method calls are subject to mutual exclusion under control
1154 * of @udev's pm_mutex. Many of these calls are also under the protection
1155 * of @udev's device lock (including all requests originating outside the
1156 * USB subsystem), but autosuspend requests generated by a child device or
1157 * interface driver may not be. Usbcore will insure that the method calls
1158 * do not arrive during bind, unbind, or reset operations. However, drivers
1159 * must be prepared to handle suspend calls arriving at unpredictable times.
1160 * The only way to block such calls is to do an autoresume (preventing
1161 * autosuspends) while holding @udev's device lock (preventing outside
1162 * suspends).
1163 *
1164 * The caller must hold @udev->pm_mutex.
1165 *
1166 * This routine can run only in process context.
1167 */
1168 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1169 {
1170 int status = 0;
1171 int i = 0;
1172 struct usb_interface *intf;
1173 struct usb_device *parent = udev->parent;
1174
1175 if (udev->state == USB_STATE_NOTATTACHED ||
1176 udev->state == USB_STATE_SUSPENDED)
1177 goto done;
1178
1179 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
1180
1181 if (msg.event & PM_EVENT_AUTO) {
1182 status = autosuspend_check(udev, 0);
1183 if (status < 0)
1184 goto done;
1185 }
1186
1187 /* Suspend all the interfaces and then udev itself */
1188 if (udev->actconfig) {
1189 for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
1190 intf = udev->actconfig->interface[i];
1191 status = usb_suspend_interface(udev, intf, msg);
1192 if (status != 0)
1193 break;
1194 }
1195 }
1196 if (status == 0)
1197 status = usb_suspend_device(udev, msg);
1198
1199 /* If the suspend failed, resume interfaces that did get suspended */
1200 if (status != 0) {
1201 pm_message_t msg2;
1202
1203 msg2.event = msg.event ^ (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1204 while (--i >= 0) {
1205 intf = udev->actconfig->interface[i];
1206 usb_resume_interface(udev, intf, msg2, 0);
1207 }
1208
1209 /* Try another autosuspend when the interfaces aren't busy */
1210 if (msg.event & PM_EVENT_AUTO)
1211 autosuspend_check(udev, status == -EBUSY);
1212
1213 /* If the suspend succeeded then prevent any more URB submissions,
1214 * flush any outstanding URBs, and propagate the suspend up the tree.
1215 */
1216 } else {
1217 cancel_delayed_work(&udev->autosuspend);
1218 udev->can_submit = 0;
1219 for (i = 0; i < 16; ++i) {
1220 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1221 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1222 }
1223
1224 /* If this is just a FREEZE or a PRETHAW, udev might
1225 * not really be suspended. Only true suspends get
1226 * propagated up the device tree.
1227 */
1228 if (parent && udev->state == USB_STATE_SUSPENDED)
1229 usb_autosuspend_device(parent);
1230 }
1231
1232 done:
1233 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1234 return status;
1235 }
1236
1237 /**
1238 * usb_resume_both - resume a USB device and its interfaces
1239 * @udev: the usb_device to resume
1240 * @msg: Power Management message describing this state transition
1241 *
1242 * This is the central routine for resuming USB devices. It calls the
1243 * the resume method for @udev and then calls the resume methods for all
1244 * the interface drivers in @udev.
1245 *
1246 * Before starting the resume, the routine calls itself recursively for
1247 * the parent device of @udev, thereby propagating the change up the device
1248 * tree and assuring that @udev will be able to resume. If the parent is
1249 * unable to resume successfully, the routine fails.
1250 *
1251 * The resume method calls are subject to mutual exclusion under control
1252 * of @udev's pm_mutex. Many of these calls are also under the protection
1253 * of @udev's device lock (including all requests originating outside the
1254 * USB subsystem), but autoresume requests generated by a child device or
1255 * interface driver may not be. Usbcore will insure that the method calls
1256 * do not arrive during bind, unbind, or reset operations. However, drivers
1257 * must be prepared to handle resume calls arriving at unpredictable times.
1258 * The only way to block such calls is to do an autoresume (preventing
1259 * other autoresumes) while holding @udev's device lock (preventing outside
1260 * resumes).
1261 *
1262 * The caller must hold @udev->pm_mutex.
1263 *
1264 * This routine can run only in process context.
1265 */
1266 static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1267 {
1268 int status = 0;
1269 int i;
1270 struct usb_interface *intf;
1271 struct usb_device *parent = udev->parent;
1272
1273 cancel_delayed_work(&udev->autosuspend);
1274 if (udev->state == USB_STATE_NOTATTACHED) {
1275 status = -ENODEV;
1276 goto done;
1277 }
1278 udev->can_submit = 1;
1279
1280 /* Propagate the resume up the tree, if necessary */
1281 if (udev->state == USB_STATE_SUSPENDED) {
1282 if ((msg.event & PM_EVENT_AUTO) &&
1283 udev->autoresume_disabled) {
1284 status = -EPERM;
1285 goto done;
1286 }
1287 if (parent) {
1288 status = usb_autoresume_device(parent);
1289 if (status == 0) {
1290 status = usb_resume_device(udev, msg);
1291 if (status || udev->state ==
1292 USB_STATE_NOTATTACHED) {
1293 usb_autosuspend_device(parent);
1294
1295 /* It's possible usb_resume_device()
1296 * failed after the port was
1297 * unsuspended, causing udev to be
1298 * logically disconnected. We don't
1299 * want usb_disconnect() to autosuspend
1300 * the parent again, so tell it that
1301 * udev disconnected while still
1302 * suspended. */
1303 if (udev->state ==
1304 USB_STATE_NOTATTACHED)
1305 udev->discon_suspended = 1;
1306 }
1307 }
1308 } else {
1309
1310 /* We can't progagate beyond the USB subsystem,
1311 * so if a root hub's controller is suspended
1312 * then we're stuck. */
1313 status = usb_resume_device(udev, msg);
1314 }
1315 } else if (udev->reset_resume)
1316 status = usb_resume_device(udev, msg);
1317
1318 if (status == 0 && udev->actconfig) {
1319 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1320 intf = udev->actconfig->interface[i];
1321 usb_resume_interface(udev, intf, msg,
1322 udev->reset_resume);
1323 }
1324 }
1325
1326 done:
1327 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1328 if (!status)
1329 udev->reset_resume = 0;
1330 return status;
1331 }
1332
1333 #ifdef CONFIG_USB_SUSPEND
1334
1335 /* Internal routine to adjust a device's usage counter and change
1336 * its autosuspend state.
1337 */
1338 static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
1339 {
1340 int status = 0;
1341
1342 usb_pm_lock(udev);
1343 udev->auto_pm = 1;
1344 udev->pm_usage_cnt += inc_usage_cnt;
1345 WARN_ON(udev->pm_usage_cnt < 0);
1346 if (inc_usage_cnt)
1347 udev->last_busy = jiffies;
1348 if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
1349 if (udev->state == USB_STATE_SUSPENDED)
1350 status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1351 if (status != 0)
1352 udev->pm_usage_cnt -= inc_usage_cnt;
1353 else if (inc_usage_cnt)
1354 udev->last_busy = jiffies;
1355 } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
1356 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1357 }
1358 usb_pm_unlock(udev);
1359 return status;
1360 }
1361
1362 /* usb_autosuspend_work - callback routine to autosuspend a USB device */
1363 void usb_autosuspend_work(struct work_struct *work)
1364 {
1365 struct usb_device *udev =
1366 container_of(work, struct usb_device, autosuspend.work);
1367
1368 usb_autopm_do_device(udev, 0);
1369 }
1370
1371 /* usb_autoresume_work - callback routine to autoresume a USB device */
1372 void usb_autoresume_work(struct work_struct *work)
1373 {
1374 struct usb_device *udev =
1375 container_of(work, struct usb_device, autoresume);
1376
1377 /* Wake it up, let the drivers do their thing, and then put it
1378 * back to sleep.
1379 */
1380 if (usb_autopm_do_device(udev, 1) == 0)
1381 usb_autopm_do_device(udev, -1);
1382 }
1383
1384 /**
1385 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
1386 * @udev: the usb_device to autosuspend
1387 *
1388 * This routine should be called when a core subsystem is finished using
1389 * @udev and wants to allow it to autosuspend. Examples would be when
1390 * @udev's device file in usbfs is closed or after a configuration change.
1391 *
1392 * @udev's usage counter is decremented. If it or any of the usage counters
1393 * for an active interface is greater than 0, no autosuspend request will be
1394 * queued. (If an interface driver does not support autosuspend then its
1395 * usage counter is permanently positive.) Furthermore, if an interface
1396 * driver requires remote-wakeup capability during autosuspend but remote
1397 * wakeup is disabled, the autosuspend will fail.
1398 *
1399 * Often the caller will hold @udev's device lock, but this is not
1400 * necessary.
1401 *
1402 * This routine can run only in process context.
1403 */
1404 void usb_autosuspend_device(struct usb_device *udev)
1405 {
1406 int status;
1407
1408 status = usb_autopm_do_device(udev, -1);
1409 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1410 __func__, udev->pm_usage_cnt);
1411 }
1412
1413 /**
1414 * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
1415 * @udev: the usb_device to autosuspend
1416 *
1417 * This routine should be called when a core subsystem thinks @udev may
1418 * be ready to autosuspend.
1419 *
1420 * @udev's usage counter left unchanged. If it or any of the usage counters
1421 * for an active interface is greater than 0, or autosuspend is not allowed
1422 * for any other reason, no autosuspend request will be queued.
1423 *
1424 * This routine can run only in process context.
1425 */
1426 void usb_try_autosuspend_device(struct usb_device *udev)
1427 {
1428 usb_autopm_do_device(udev, 0);
1429 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1430 __func__, udev->pm_usage_cnt);
1431 }
1432
1433 /**
1434 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
1435 * @udev: the usb_device to autoresume
1436 *
1437 * This routine should be called when a core subsystem wants to use @udev
1438 * and needs to guarantee that it is not suspended. No autosuspend will
1439 * occur until usb_autosuspend_device is called. (Note that this will not
1440 * prevent suspend events originating in the PM core.) Examples would be
1441 * when @udev's device file in usbfs is opened or when a remote-wakeup
1442 * request is received.
1443 *
1444 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1445 * However if the autoresume fails then the usage counter is re-decremented.
1446 *
1447 * Often the caller will hold @udev's device lock, but this is not
1448 * necessary (and attempting it might cause deadlock).
1449 *
1450 * This routine can run only in process context.
1451 */
1452 int usb_autoresume_device(struct usb_device *udev)
1453 {
1454 int status;
1455
1456 status = usb_autopm_do_device(udev, 1);
1457 dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
1458 __func__, status, udev->pm_usage_cnt);
1459 return status;
1460 }
1461
1462 /* Internal routine to adjust an interface's usage counter and change
1463 * its device's autosuspend state.
1464 */
1465 static int usb_autopm_do_interface(struct usb_interface *intf,
1466 int inc_usage_cnt)
1467 {
1468 struct usb_device *udev = interface_to_usbdev(intf);
1469 int status = 0;
1470
1471 usb_pm_lock(udev);
1472 if (intf->condition == USB_INTERFACE_UNBOUND)
1473 status = -ENODEV;
1474 else {
1475 udev->auto_pm = 1;
1476 intf->pm_usage_cnt += inc_usage_cnt;
1477 udev->last_busy = jiffies;
1478 if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
1479 if (udev->state == USB_STATE_SUSPENDED)
1480 status = usb_resume_both(udev,
1481 PMSG_AUTO_RESUME);
1482 if (status != 0)
1483 intf->pm_usage_cnt -= inc_usage_cnt;
1484 else
1485 udev->last_busy = jiffies;
1486 } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
1487 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1488 }
1489 }
1490 usb_pm_unlock(udev);
1491 return status;
1492 }
1493
1494 /**
1495 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
1496 * @intf: the usb_interface whose counter should be decremented
1497 *
1498 * This routine should be called by an interface driver when it is
1499 * finished using @intf and wants to allow it to autosuspend. A typical
1500 * example would be a character-device driver when its device file is
1501 * closed.
1502 *
1503 * The routine decrements @intf's usage counter. When the counter reaches
1504 * 0, a delayed autosuspend request for @intf's device is queued. When
1505 * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
1506 * the other usage counters for the sibling interfaces and @intf's
1507 * usb_device, the device and all its interfaces will be autosuspended.
1508 *
1509 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1510 * core will not change its value other than the increment and decrement
1511 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1512 * may use this simple counter-oriented discipline or may set the value
1513 * any way it likes.
1514 *
1515 * If the driver has set @intf->needs_remote_wakeup then autosuspend will
1516 * take place only if the device's remote-wakeup facility is enabled.
1517 *
1518 * Suspend method calls queued by this routine can arrive at any time
1519 * while @intf is resumed and its usage counter is equal to 0. They are
1520 * not protected by the usb_device's lock but only by its pm_mutex.
1521 * Drivers must provide their own synchronization.
1522 *
1523 * This routine can run only in process context.
1524 */
1525 void usb_autopm_put_interface(struct usb_interface *intf)
1526 {
1527 int status;
1528
1529 status = usb_autopm_do_interface(intf, -1);
1530 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1531 __func__, status, intf->pm_usage_cnt);
1532 }
1533 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1534
1535 /**
1536 * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
1537 * @intf: the usb_interface whose counter should be decremented
1538 *
1539 * This routine does essentially the same thing as
1540 * usb_autopm_put_interface(): it decrements @intf's usage counter and
1541 * queues a delayed autosuspend request if the counter is <= 0. The
1542 * difference is that it does not acquire the device's pm_mutex;
1543 * callers must handle all synchronization issues themselves.
1544 *
1545 * Typically a driver would call this routine during an URB's completion
1546 * handler, if no more URBs were pending.
1547 *
1548 * This routine can run in atomic context.
1549 */
1550 void usb_autopm_put_interface_async(struct usb_interface *intf)
1551 {
1552 struct usb_device *udev = interface_to_usbdev(intf);
1553 int status = 0;
1554
1555 if (intf->condition == USB_INTERFACE_UNBOUND) {
1556 status = -ENODEV;
1557 } else {
1558 udev->last_busy = jiffies;
1559 --intf->pm_usage_cnt;
1560 if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
1561 status = -EPERM;
1562 else if (intf->pm_usage_cnt <= 0 &&
1563 !timer_pending(&udev->autosuspend.timer)) {
1564 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
1565 round_jiffies_up_relative(
1566 udev->autosuspend_delay));
1567 }
1568 }
1569 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1570 __func__, status, intf->pm_usage_cnt);
1571 }
1572 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1573
1574 /**
1575 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
1576 * @intf: the usb_interface whose counter should be incremented
1577 *
1578 * This routine should be called by an interface driver when it wants to
1579 * use @intf and needs to guarantee that it is not suspended. In addition,
1580 * the routine prevents @intf from being autosuspended subsequently. (Note
1581 * that this will not prevent suspend events originating in the PM core.)
1582 * This prevention will persist until usb_autopm_put_interface() is called
1583 * or @intf is unbound. A typical example would be a character-device
1584 * driver when its device file is opened.
1585 *
1586 *
1587 * The routine increments @intf's usage counter. (However if the
1588 * autoresume fails then the counter is re-decremented.) So long as the
1589 * counter is greater than 0, autosuspend will not be allowed for @intf
1590 * or its usb_device. When the driver is finished using @intf it should
1591 * call usb_autopm_put_interface() to decrement the usage counter and
1592 * queue a delayed autosuspend request (if the counter is <= 0).
1593 *
1594 *
1595 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1596 * core will not change its value other than the increment and decrement
1597 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1598 * may use this simple counter-oriented discipline or may set the value
1599 * any way it likes.
1600 *
1601 * Resume method calls generated by this routine can arrive at any time
1602 * while @intf is suspended. They are not protected by the usb_device's
1603 * lock but only by its pm_mutex. Drivers must provide their own
1604 * synchronization.
1605 *
1606 * This routine can run only in process context.
1607 */
1608 int usb_autopm_get_interface(struct usb_interface *intf)
1609 {
1610 int status;
1611
1612 status = usb_autopm_do_interface(intf, 1);
1613 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1614 __func__, status, intf->pm_usage_cnt);
1615 return status;
1616 }
1617 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1618
1619 /**
1620 * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
1621 * @intf: the usb_interface whose counter should be incremented
1622 *
1623 * This routine does much the same thing as
1624 * usb_autopm_get_interface(): it increments @intf's usage counter and
1625 * queues an autoresume request if the result is > 0. The differences
1626 * are that it does not acquire the device's pm_mutex (callers must
1627 * handle all synchronization issues themselves), and it does not
1628 * autoresume the device directly (it only queues a request). After a
1629 * successful call, the device will generally not yet be resumed.
1630 *
1631 * This routine can run in atomic context.
1632 */
1633 int usb_autopm_get_interface_async(struct usb_interface *intf)
1634 {
1635 struct usb_device *udev = interface_to_usbdev(intf);
1636 int status = 0;
1637
1638 if (intf->condition == USB_INTERFACE_UNBOUND)
1639 status = -ENODEV;
1640 else if (udev->autoresume_disabled)
1641 status = -EPERM;
1642 else if (++intf->pm_usage_cnt > 0 && udev->state == USB_STATE_SUSPENDED)
1643 queue_work(ksuspend_usb_wq, &udev->autoresume);
1644 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1645 __func__, status, intf->pm_usage_cnt);
1646 return status;
1647 }
1648 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1649
1650 /**
1651 * usb_autopm_set_interface - set a USB interface's autosuspend state
1652 * @intf: the usb_interface whose state should be set
1653 *
1654 * This routine sets the autosuspend state of @intf's device according
1655 * to @intf's usage counter, which the caller must have set previously.
1656 * If the counter is <= 0, the device is autosuspended (if it isn't
1657 * already suspended and if nothing else prevents the autosuspend). If
1658 * the counter is > 0, the device is autoresumed (if it isn't already
1659 * awake).
1660 */
1661 int usb_autopm_set_interface(struct usb_interface *intf)
1662 {
1663 int status;
1664
1665 status = usb_autopm_do_interface(intf, 0);
1666 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1667 __func__, status, intf->pm_usage_cnt);
1668 return status;
1669 }
1670 EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
1671
1672 #else
1673
1674 void usb_autosuspend_work(struct work_struct *work)
1675 {}
1676
1677 void usb_autoresume_work(struct work_struct *work)
1678 {}
1679
1680 #endif /* CONFIG_USB_SUSPEND */
1681
1682 /**
1683 * usb_external_suspend_device - external suspend of a USB device and its interfaces
1684 * @udev: the usb_device to suspend
1685 * @msg: Power Management message describing this state transition
1686 *
1687 * This routine handles external suspend requests: ones not generated
1688 * internally by a USB driver (autosuspend) but rather coming from the user
1689 * (via sysfs) or the PM core (system sleep). The suspend will be carried
1690 * out regardless of @udev's usage counter or those of its interfaces,
1691 * and regardless of whether or not remote wakeup is enabled. Of course,
1692 * interface drivers still have the option of failing the suspend (if
1693 * there are unsuspended children, for example).
1694 *
1695 * The caller must hold @udev's device lock.
1696 */
1697 int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
1698 {
1699 int status;
1700
1701 do_unbind_rebind(udev, DO_UNBIND);
1702 usb_pm_lock(udev);
1703 udev->auto_pm = 0;
1704 status = usb_suspend_both(udev, msg);
1705 usb_pm_unlock(udev);
1706 return status;
1707 }
1708
1709 /**
1710 * usb_external_resume_device - external resume of a USB device and its interfaces
1711 * @udev: the usb_device to resume
1712 * @msg: Power Management message describing this state transition
1713 *
1714 * This routine handles external resume requests: ones not generated
1715 * internally by a USB driver (autoresume) but rather coming from the user
1716 * (via sysfs), the PM core (system resume), or the device itself (remote
1717 * wakeup). @udev's usage counter is unaffected.
1718 *
1719 * The caller must hold @udev's device lock.
1720 */
1721 int usb_external_resume_device(struct usb_device *udev, pm_message_t msg)
1722 {
1723 int status;
1724
1725 usb_pm_lock(udev);
1726 udev->auto_pm = 0;
1727 status = usb_resume_both(udev, msg);
1728 udev->last_busy = jiffies;
1729 usb_pm_unlock(udev);
1730 if (status == 0)
1731 do_unbind_rebind(udev, DO_REBIND);
1732
1733 /* Now that the device is awake, we can start trying to autosuspend
1734 * it again. */
1735 if (status == 0)
1736 usb_try_autosuspend_device(udev);
1737 return status;
1738 }
1739
1740 int usb_suspend(struct device *dev, pm_message_t msg)
1741 {
1742 struct usb_device *udev;
1743
1744 udev = to_usb_device(dev);
1745
1746 /* If udev is already suspended, we can skip this suspend and
1747 * we should also skip the upcoming system resume. High-speed
1748 * root hubs are an exception; they need to resume whenever the
1749 * system wakes up in order for USB-PERSIST port handover to work
1750 * properly.
1751 */
1752 if (udev->state == USB_STATE_SUSPENDED) {
1753 if (udev->parent || udev->speed != USB_SPEED_HIGH)
1754 udev->skip_sys_resume = 1;
1755 return 0;
1756 }
1757
1758 udev->skip_sys_resume = 0;
1759 return usb_external_suspend_device(udev, msg);
1760 }
1761
1762 int usb_resume(struct device *dev, pm_message_t msg)
1763 {
1764 struct usb_device *udev;
1765
1766 udev = to_usb_device(dev);
1767
1768 /* If udev->skip_sys_resume is set then udev was already suspended
1769 * when the system sleep started, so we don't want to resume it
1770 * during this system wakeup.
1771 */
1772 if (udev->skip_sys_resume)
1773 return 0;
1774 return usb_external_resume_device(udev, msg);
1775 }
1776
1777 #endif /* CONFIG_PM */
1778
1779 struct bus_type usb_bus_type = {
1780 .name = "usb",
1781 .match = usb_device_match,
1782 .uevent = usb_uevent,
1783 };
This page took 0.06631 seconds and 5 git commands to generate.