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