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