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