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