blob: 801b6f142fa7f874650a99c4d28c268c887a3114 [file] [log] [blame]
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -08001/*
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
Alan Stern36e56a32006-07-01 22:08:06 -040020 * matching, probing, releasing, suspending and resuming for
21 * real drivers.
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -080022 *
23 */
24
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -080025#include <linux/device.h>
26#include <linux/usb.h>
Alan Stern6bc6cff2007-05-04 11:53:03 -040027#include <linux/usb/quirks.h>
Alan Sternbd859282006-09-19 10:14:07 -040028#include <linux/workqueue.h>
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -080029#include "hcd.h"
30#include "usb.h"
31
Alan Stern20dfdad2007-05-22 11:50:17 -040032
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080033#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 */
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +010039ssize_t usb_store_new_id(struct usb_dynids *dynids,
40 struct device_driver *driver,
41 const char *buf, size_t count)
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080042{
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080043 struct usb_dynid *dynid;
44 u32 idVendor = 0;
45 u32 idProduct = 0;
46 int fields = 0;
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -070047 int retval = 0;
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080048
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
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +010062 spin_lock(&dynids->lock);
Nathael Pajanie5dd0112007-09-04 11:46:23 +020063 list_add_tail(&dynid->node, &dynids->list);
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +010064 spin_unlock(&dynids->lock);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080065
66 if (get_driver(driver)) {
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -070067 retval = driver_attach(driver);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080068 put_driver(driver);
69 }
70
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -070071 if (retval)
72 return retval;
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080073 return count;
74}
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +010075EXPORT_SYMBOL_GPL(usb_store_new_id);
76
77static 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}
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080084static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
85
86static int usb_create_newid_file(struct usb_driver *usb_drv)
87{
88 int error = 0;
89
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -080090 if (usb_drv->no_dynamic_id)
91 goto exit;
92
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080093 if (usb_drv->probe != NULL)
Greg Kroah-Hartman15147ff2007-11-28 12:23:18 -080094 error = driver_create_file(&usb_drv->drvwrap.driver,
95 &driver_attr_new_id);
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -080096exit:
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -080097 return error;
98}
99
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800100static 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)
Greg Kroah-Hartman15147ff2007-11-28 12:23:18 -0800106 driver_remove_file(&usb_drv->drvwrap.driver,
107 &driver_attr_new_id);
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800108}
109
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800110static 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
122static inline int usb_create_newid_file(struct usb_driver *usb_drv)
123{
124 return 0;
125}
126
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800127static void usb_remove_newid_file(struct usb_driver *usb_drv)
128{
129}
130
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800131static inline void usb_free_dynids(struct usb_driver *usb_drv)
132{
133}
134#endif
135
136static 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
Alan Stern8bb54ab2006-07-01 22:08:49 -0400153/* called from driver core with dev locked */
154static 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", __FUNCTION__);
161
162 if (!is_usb_device(dev)) /* Sanity check */
163 return error;
164
165 udev = to_usb_device(dev);
166
Alan Stern8bb54ab2006-07-01 22:08:49 -0400167 /* TODO: Add real matching code */
168
Alan Stern645daaa2006-08-30 15:47:02 -0400169 /* 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
Alan Stern8bb54ab2006-07-01 22:08:49 -0400174 error = udriver->probe(udev);
175 return error;
176}
177
178/* called from driver core with dev locked */
179static 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/* called from driver core with dev locked */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800189static int usb_probe_interface(struct device *dev)
190{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400191 struct usb_driver *driver = to_usb_driver(dev->driver);
192 struct usb_interface *intf;
Alan Stern645daaa2006-08-30 15:47:02 -0400193 struct usb_device *udev;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800194 const struct usb_device_id *id;
195 int error = -ENODEV;
196
197 dev_dbg(dev, "%s\n", __FUNCTION__);
198
Alan Stern8bb54ab2006-07-01 22:08:49 -0400199 if (is_usb_device(dev)) /* Sanity check */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800200 return error;
Alan Stern8bb54ab2006-07-01 22:08:49 -0400201
202 intf = to_usb_interface(dev);
Alan Stern645daaa2006-08-30 15:47:02 -0400203 udev = interface_to_usbdev(intf);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800204
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800205 if (udev->authorized == 0) {
206 dev_err(&intf->dev, "Device is not authorized for usage\n");
207 return -ENODEV;
208 }
Inaky Perez-Gonzalez72230ab2007-07-31 20:34:03 -0700209
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800210 id = usb_match_id(intf, driver->id_table);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800211 if (!id)
212 id = usb_match_dynamic_id(intf, driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800213 if (id) {
214 dev_dbg(dev, "%s - got id\n", __FUNCTION__);
215
Alan Stern94fcda12006-11-20 11:38:46 -0500216 error = usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -0400217 if (error)
218 return error;
219
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800220 /* Interface "power state" doesn't correspond to any hardware
221 * state whatsoever. We use it to record when it's bound to
222 * a driver that may start I/0: it's not frozen/quiesced.
223 */
224 mark_active(intf);
225 intf->condition = USB_INTERFACE_BINDING;
Alan Stern645daaa2006-08-30 15:47:02 -0400226
227 /* The interface should always appear to be in use
228 * unless the driver suports autosuspend.
229 */
230 intf->pm_usage_cnt = !(driver->supports_autosuspend);
231
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800232 error = driver->probe(intf, id);
233 if (error) {
234 mark_quiesced(intf);
Alan Stern645daaa2006-08-30 15:47:02 -0400235 intf->needs_remote_wakeup = 0;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800236 intf->condition = USB_INTERFACE_UNBOUND;
237 } else
238 intf->condition = USB_INTERFACE_BOUND;
Alan Stern645daaa2006-08-30 15:47:02 -0400239
Alan Stern94fcda12006-11-20 11:38:46 -0500240 usb_autosuspend_device(udev);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800241 }
242
243 return error;
244}
245
Alan Stern8bb54ab2006-07-01 22:08:49 -0400246/* called from driver core with dev locked */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800247static int usb_unbind_interface(struct device *dev)
248{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400249 struct usb_driver *driver = to_usb_driver(dev->driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800250 struct usb_interface *intf = to_usb_interface(dev);
Alan Stern645daaa2006-08-30 15:47:02 -0400251 struct usb_device *udev;
252 int error;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800253
254 intf->condition = USB_INTERFACE_UNBINDING;
255
Alan Stern645daaa2006-08-30 15:47:02 -0400256 /* Autoresume for set_interface call below */
257 udev = interface_to_usbdev(intf);
Alan Stern94fcda12006-11-20 11:38:46 -0500258 error = usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -0400259
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800260 /* release all urbs for this interface */
261 usb_disable_interface(interface_to_usbdev(intf), intf);
262
Alan Stern8bb54ab2006-07-01 22:08:49 -0400263 driver->disconnect(intf);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800264
265 /* reset other interface state */
266 usb_set_interface(interface_to_usbdev(intf),
267 intf->altsetting[0].desc.bInterfaceNumber,
268 0);
269 usb_set_intfdata(intf, NULL);
Alan Stern645daaa2006-08-30 15:47:02 -0400270
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800271 intf->condition = USB_INTERFACE_UNBOUND;
272 mark_quiesced(intf);
Alan Stern645daaa2006-08-30 15:47:02 -0400273 intf->needs_remote_wakeup = 0;
274
275 if (!error)
Alan Stern94fcda12006-11-20 11:38:46 -0500276 usb_autosuspend_device(udev);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800277
278 return 0;
279}
280
Alan Stern36e56a32006-07-01 22:08:06 -0400281/**
282 * usb_driver_claim_interface - bind a driver to an interface
283 * @driver: the driver to be bound
284 * @iface: the interface to which it will be bound; must be in the
285 * usb device's active configuration
286 * @priv: driver data associated with that interface
287 *
288 * This is used by usb device drivers that need to claim more than one
289 * interface on a device when probing (audio and acm are current examples).
290 * No device driver should directly modify internal usb_interface or
291 * usb_device structure members.
292 *
293 * Few drivers should need to use this routine, since the most natural
294 * way to bind to an interface is to return the private data from
295 * the driver's probe() method.
296 *
Greg Kroah-Hartman341487a2007-04-09 11:52:31 -0400297 * Callers must own the device lock, so driver probe() entries don't need
298 * extra locking, but other call contexts may need to explicitly claim that
299 * lock.
Alan Stern36e56a32006-07-01 22:08:06 -0400300 */
301int usb_driver_claim_interface(struct usb_driver *driver,
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800302 struct usb_interface *iface, void *priv)
Alan Stern36e56a32006-07-01 22:08:06 -0400303{
304 struct device *dev = &iface->dev;
Alan Stern645daaa2006-08-30 15:47:02 -0400305 struct usb_device *udev = interface_to_usbdev(iface);
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700306 int retval = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400307
308 if (dev->driver)
309 return -EBUSY;
310
Alan Stern8bb54ab2006-07-01 22:08:49 -0400311 dev->driver = &driver->drvwrap.driver;
Alan Stern36e56a32006-07-01 22:08:06 -0400312 usb_set_intfdata(iface, priv);
Alan Stern645daaa2006-08-30 15:47:02 -0400313
Alan Sterne0318eb2006-09-26 14:50:20 -0400314 usb_pm_lock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400315 iface->condition = USB_INTERFACE_BOUND;
316 mark_active(iface);
Alan Stern645daaa2006-08-30 15:47:02 -0400317 iface->pm_usage_cnt = !(driver->supports_autosuspend);
Alan Sterne0318eb2006-09-26 14:50:20 -0400318 usb_pm_unlock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400319
320 /* if interface was already added, bind now; else let
321 * the future device_add() bind it, bypassing probe()
322 */
323 if (device_is_registered(dev))
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700324 retval = device_bind_driver(dev);
Alan Stern36e56a32006-07-01 22:08:06 -0400325
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700326 return retval;
Alan Stern36e56a32006-07-01 22:08:06 -0400327}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600328EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
Alan Stern36e56a32006-07-01 22:08:06 -0400329
330/**
331 * usb_driver_release_interface - unbind a driver from an interface
332 * @driver: the driver to be unbound
333 * @iface: the interface from which it will be unbound
334 *
335 * This can be used by drivers to release an interface without waiting
336 * for their disconnect() methods to be called. In typical cases this
337 * also causes the driver disconnect() method to be called.
338 *
339 * This call is synchronous, and may not be used in an interrupt context.
Greg Kroah-Hartman341487a2007-04-09 11:52:31 -0400340 * Callers must own the device lock, so driver disconnect() entries don't
341 * need extra locking, but other call contexts may need to explicitly claim
342 * that lock.
Alan Stern36e56a32006-07-01 22:08:06 -0400343 */
344void usb_driver_release_interface(struct usb_driver *driver,
345 struct usb_interface *iface)
346{
347 struct device *dev = &iface->dev;
Alan Stern645daaa2006-08-30 15:47:02 -0400348 struct usb_device *udev = interface_to_usbdev(iface);
Alan Stern36e56a32006-07-01 22:08:06 -0400349
350 /* this should never happen, don't release something that's not ours */
Alan Stern8bb54ab2006-07-01 22:08:49 -0400351 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
Alan Stern36e56a32006-07-01 22:08:06 -0400352 return;
353
354 /* don't release from within disconnect() */
355 if (iface->condition != USB_INTERFACE_BOUND)
356 return;
357
358 /* don't release if the interface hasn't been added yet */
359 if (device_is_registered(dev)) {
360 iface->condition = USB_INTERFACE_UNBINDING;
361 device_release_driver(dev);
362 }
363
364 dev->driver = NULL;
365 usb_set_intfdata(iface, NULL);
Alan Stern645daaa2006-08-30 15:47:02 -0400366
Alan Sterne0318eb2006-09-26 14:50:20 -0400367 usb_pm_lock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400368 iface->condition = USB_INTERFACE_UNBOUND;
369 mark_quiesced(iface);
Alan Stern645daaa2006-08-30 15:47:02 -0400370 iface->needs_remote_wakeup = 0;
Alan Sterne0318eb2006-09-26 14:50:20 -0400371 usb_pm_unlock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400372}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600373EXPORT_SYMBOL_GPL(usb_driver_release_interface);
Alan Stern36e56a32006-07-01 22:08:06 -0400374
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800375/* returns 0 if no match, 1 if match */
Greg Kroah-Hartmanbb417022007-01-26 14:26:21 +0100376int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800377{
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800378 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
379 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
380 return 0;
381
382 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
383 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
384 return 0;
385
386 /* No need to test id->bcdDevice_lo != 0, since 0 is never
387 greater than any unsigned number. */
388 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
389 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
390 return 0;
391
392 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
393 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
394 return 0;
395
396 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
397 (id->bDeviceClass != dev->descriptor.bDeviceClass))
398 return 0;
399
400 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800401 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800402 return 0;
403
404 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
405 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
406 return 0;
407
Greg Kroah-Hartmanbb417022007-01-26 14:26:21 +0100408 return 1;
409}
410
411/* returns 0 if no match, 1 if match */
412int usb_match_one_id(struct usb_interface *interface,
413 const struct usb_device_id *id)
414{
415 struct usb_host_interface *intf;
416 struct usb_device *dev;
417
418 /* proc_connectinfo in devio.c may call us with id == NULL. */
419 if (id == NULL)
420 return 0;
421
422 intf = interface->cur_altsetting;
423 dev = interface_to_usbdev(interface);
424
425 if (!usb_match_device(dev, id))
426 return 0;
427
Alan Stern93c8bf42006-10-18 16:41:51 -0400428 /* The interface class, subclass, and protocol should never be
429 * checked for a match if the device class is Vendor Specific,
430 * unless the match record specifies the Vendor ID. */
431 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
432 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
433 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
434 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
435 USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
436 return 0;
437
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800438 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
439 (id->bInterfaceClass != intf->desc.bInterfaceClass))
440 return 0;
441
442 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
443 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
444 return 0;
445
446 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
447 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
448 return 0;
449
450 return 1;
451}
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100452EXPORT_SYMBOL_GPL(usb_match_one_id);
453
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800454/**
455 * usb_match_id - find first usb_device_id matching device or interface
456 * @interface: the interface of interest
457 * @id: array of usb_device_id structures, terminated by zero entry
458 *
459 * usb_match_id searches an array of usb_device_id's and returns
460 * the first one matching the device or interface, or null.
461 * This is used when binding (or rebinding) a driver to an interface.
462 * Most USB device drivers will use this indirectly, through the usb core,
463 * but some layered driver frameworks use it directly.
464 * These device tables are exported with MODULE_DEVICE_TABLE, through
465 * modutils, to support the driver loading functionality of USB hotplugging.
466 *
467 * What Matches:
468 *
469 * The "match_flags" element in a usb_device_id controls which
470 * members are used. If the corresponding bit is set, the
471 * value in the device_id must match its corresponding member
472 * in the device or interface descriptor, or else the device_id
473 * does not match.
474 *
475 * "driver_info" is normally used only by device drivers,
476 * but you can create a wildcard "matches anything" usb_device_id
477 * as a driver's "modules.usbmap" entry if you provide an id with
478 * only a nonzero "driver_info" field. If you do this, the USB device
479 * driver's probe() routine should use additional intelligence to
480 * decide whether to bind to the specified interface.
481 *
482 * What Makes Good usb_device_id Tables:
483 *
484 * The match algorithm is very simple, so that intelligence in
485 * driver selection must come from smart driver id records.
486 * Unless you have good reasons to use another selection policy,
487 * provide match elements only in related groups, and order match
488 * specifiers from specific to general. Use the macros provided
489 * for that purpose if you can.
490 *
491 * The most specific match specifiers use device descriptor
492 * data. These are commonly used with product-specific matches;
493 * the USB_DEVICE macro lets you provide vendor and product IDs,
494 * and you can also match against ranges of product revisions.
495 * These are widely used for devices with application or vendor
496 * specific bDeviceClass values.
497 *
498 * Matches based on device class/subclass/protocol specifications
499 * are slightly more general; use the USB_DEVICE_INFO macro, or
500 * its siblings. These are used with single-function devices
501 * where bDeviceClass doesn't specify that each interface has
502 * its own class.
503 *
504 * Matches based on interface class/subclass/protocol are the
505 * most general; they let drivers bind to any interface on a
506 * multiple-function device. Use the USB_INTERFACE_INFO
507 * macro, or its siblings, to match class-per-interface style
Alan Stern93c8bf42006-10-18 16:41:51 -0400508 * devices (as recorded in bInterfaceClass).
509 *
510 * Note that an entry created by USB_INTERFACE_INFO won't match
511 * any interface if the device class is set to Vendor-Specific.
512 * This is deliberate; according to the USB spec the meanings of
513 * the interface class/subclass/protocol for these devices are also
514 * vendor-specific, and hence matching against a standard product
515 * class wouldn't work anyway. If you really want to use an
516 * interface-based match for such a device, create a match record
517 * that also specifies the vendor ID. (Unforunately there isn't a
518 * standard macro for creating records like this.)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800519 *
520 * Within those groups, remember that not all combinations are
521 * meaningful. For example, don't give a product version range
522 * without vendor and product IDs; or specify a protocol without
523 * its associated class and subclass.
524 */
525const struct usb_device_id *usb_match_id(struct usb_interface *interface,
526 const struct usb_device_id *id)
527{
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800528 /* proc_connectinfo in devio.c may call us with id == NULL. */
529 if (id == NULL)
530 return NULL;
531
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800532 /* It is important to check that id->driver_info is nonzero,
533 since an entry that is all zeroes except for a nonzero
534 id->driver_info is the way to create an entry that
535 indicates that the driver want to examine every
536 device and interface. */
Greg Kroah-Hartmande6f92b2008-01-28 09:50:12 -0800537 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
538 id->bInterfaceClass || id->driver_info; id++) {
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800539 if (usb_match_one_id(interface, id))
540 return id;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800541 }
542
543 return NULL;
544}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600545EXPORT_SYMBOL_GPL(usb_match_id);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800546
Adrian Bunk8bb22d22006-11-21 22:02:54 +0100547static int usb_device_match(struct device *dev, struct device_driver *drv)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800548{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400549 /* devices and interfaces are handled separately */
550 if (is_usb_device(dev)) {
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800551
Alan Stern8bb54ab2006-07-01 22:08:49 -0400552 /* interface drivers never match devices */
553 if (!is_usb_device_driver(drv))
554 return 0;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800555
Alan Stern8bb54ab2006-07-01 22:08:49 -0400556 /* TODO: Add real matching code */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800557 return 1;
558
Alan Stern8bb54ab2006-07-01 22:08:49 -0400559 } else {
560 struct usb_interface *intf;
561 struct usb_driver *usb_drv;
562 const struct usb_device_id *id;
563
564 /* device drivers never match interfaces */
565 if (is_usb_device_driver(drv))
566 return 0;
567
568 intf = to_usb_interface(dev);
569 usb_drv = to_usb_driver(drv);
570
571 id = usb_match_id(intf, usb_drv->id_table);
572 if (id)
573 return 1;
574
575 id = usb_match_dynamic_id(intf, usb_drv);
576 if (id)
577 return 1;
578 }
579
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800580 return 0;
581}
582
Alan Stern36e56a32006-07-01 22:08:06 -0400583#ifdef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200584static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
Alan Stern36e56a32006-07-01 22:08:06 -0400585{
Alan Stern36e56a32006-07-01 22:08:06 -0400586 struct usb_device *usb_dev;
Alan Stern36e56a32006-07-01 22:08:06 -0400587
Alan Stern36e56a32006-07-01 22:08:06 -0400588 /* driver is often null here; dev_dbg() would oops */
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800589 pr_debug("usb %s: uevent\n", dev->bus_id);
Alan Stern36e56a32006-07-01 22:08:06 -0400590
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100591 if (is_usb_device(dev))
Alan Stern782da722006-07-01 22:09:35 -0400592 usb_dev = to_usb_device(dev);
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100593 else {
594 struct usb_interface *intf = to_usb_interface(dev);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400595 usb_dev = interface_to_usbdev(intf);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400596 }
Alan Stern36e56a32006-07-01 22:08:06 -0400597
598 if (usb_dev->devnum < 0) {
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800599 pr_debug("usb %s: already deleted?\n", dev->bus_id);
Alan Stern36e56a32006-07-01 22:08:06 -0400600 return -ENODEV;
601 }
602 if (!usb_dev->bus) {
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800603 pr_debug("usb %s: bus removed?\n", dev->bus_id);
Alan Stern36e56a32006-07-01 22:08:06 -0400604 return -ENODEV;
605 }
606
607#ifdef CONFIG_USB_DEVICEFS
608 /* If this is available, userspace programs can directly read
609 * all the device descriptors we don't tell them about. Or
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100610 * act as usermode drivers.
Alan Stern36e56a32006-07-01 22:08:06 -0400611 */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200612 if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
Alan Stern36e56a32006-07-01 22:08:06 -0400613 usb_dev->bus->busnum, usb_dev->devnum))
614 return -ENOMEM;
615#endif
616
617 /* per-device configurations are common */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200618 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
Alan Stern36e56a32006-07-01 22:08:06 -0400619 le16_to_cpu(usb_dev->descriptor.idVendor),
620 le16_to_cpu(usb_dev->descriptor.idProduct),
621 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
622 return -ENOMEM;
623
624 /* class-based driver binding models */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200625 if (add_uevent_var(env, "TYPE=%d/%d/%d",
Alan Stern36e56a32006-07-01 22:08:06 -0400626 usb_dev->descriptor.bDeviceClass,
627 usb_dev->descriptor.bDeviceSubClass,
628 usb_dev->descriptor.bDeviceProtocol))
629 return -ENOMEM;
630
Alan Stern36e56a32006-07-01 22:08:06 -0400631 return 0;
632}
633
634#else
635
Kay Sievers7eff2e72007-08-14 15:15:12 +0200636static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
Alan Stern36e56a32006-07-01 22:08:06 -0400637{
638 return -ENODEV;
639}
Alan Stern36e56a32006-07-01 22:08:06 -0400640#endif /* CONFIG_HOTPLUG */
641
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800642/**
Alan Stern8bb54ab2006-07-01 22:08:49 -0400643 * usb_register_device_driver - register a USB device (not interface) driver
644 * @new_udriver: USB operations for the device driver
Greg Kroah-Hartman2143acc2005-11-21 14:53:03 -0800645 * @owner: module owner of this driver.
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800646 *
Alan Stern8bb54ab2006-07-01 22:08:49 -0400647 * Registers a USB device driver with the USB core. The list of
648 * unattached devices will be rescanned whenever a new driver is
649 * added, allowing the new driver to attach to any recognized devices.
650 * Returns a negative error code on failure and 0 on success.
651 */
652int usb_register_device_driver(struct usb_device_driver *new_udriver,
653 struct module *owner)
654{
655 int retval = 0;
656
657 if (usb_disabled())
658 return -ENODEV;
659
660 new_udriver->drvwrap.for_devices = 1;
661 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
662 new_udriver->drvwrap.driver.bus = &usb_bus_type;
663 new_udriver->drvwrap.driver.probe = usb_probe_device;
664 new_udriver->drvwrap.driver.remove = usb_unbind_device;
665 new_udriver->drvwrap.driver.owner = owner;
666
667 retval = driver_register(&new_udriver->drvwrap.driver);
668
669 if (!retval) {
670 pr_info("%s: registered new device driver %s\n",
671 usbcore_name, new_udriver->name);
672 usbfs_update_special();
673 } else {
674 printk(KERN_ERR "%s: error %d registering device "
675 " driver %s\n",
676 usbcore_name, retval, new_udriver->name);
677 }
678
679 return retval;
680}
681EXPORT_SYMBOL_GPL(usb_register_device_driver);
682
683/**
684 * usb_deregister_device_driver - unregister a USB device (not interface) driver
685 * @udriver: USB operations of the device driver to unregister
686 * Context: must be able to sleep
687 *
688 * Unlinks the specified driver from the internal USB driver list.
689 */
690void usb_deregister_device_driver(struct usb_device_driver *udriver)
691{
692 pr_info("%s: deregistering device driver %s\n",
693 usbcore_name, udriver->name);
694
695 driver_unregister(&udriver->drvwrap.driver);
696 usbfs_update_special();
697}
698EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
699
700/**
701 * usb_register_driver - register a USB interface driver
702 * @new_driver: USB operations for the interface driver
703 * @owner: module owner of this driver.
Randy Dunlap892705a2007-02-10 14:41:41 -0800704 * @mod_name: module name string
Alan Stern8bb54ab2006-07-01 22:08:49 -0400705 *
706 * Registers a USB interface driver with the USB core. The list of
707 * unattached interfaces will be rescanned whenever a new driver is
708 * added, allowing the new driver to attach to any recognized interfaces.
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800709 * Returns a negative error code on failure and 0 on success.
710 *
711 * NOTE: if you want your driver to use the USB major number, you must call
712 * usb_register_dev() to enable that functionality. This function no longer
713 * takes care of that.
714 */
Greg Kroah-Hartman80f745f2007-01-15 11:50:02 -0800715int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
716 const char *mod_name)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800717{
718 int retval = 0;
719
720 if (usb_disabled())
721 return -ENODEV;
722
Alan Stern8bb54ab2006-07-01 22:08:49 -0400723 new_driver->drvwrap.for_devices = 0;
724 new_driver->drvwrap.driver.name = (char *) new_driver->name;
725 new_driver->drvwrap.driver.bus = &usb_bus_type;
726 new_driver->drvwrap.driver.probe = usb_probe_interface;
727 new_driver->drvwrap.driver.remove = usb_unbind_interface;
728 new_driver->drvwrap.driver.owner = owner;
Greg Kroah-Hartman80f745f2007-01-15 11:50:02 -0800729 new_driver->drvwrap.driver.mod_name = mod_name;
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800730 spin_lock_init(&new_driver->dynids.lock);
731 INIT_LIST_HEAD(&new_driver->dynids.list);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800732
Alan Stern8bb54ab2006-07-01 22:08:49 -0400733 retval = driver_register(&new_driver->drvwrap.driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800734
735 if (!retval) {
Alan Stern8bb54ab2006-07-01 22:08:49 -0400736 pr_info("%s: registered new interface driver %s\n",
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800737 usbcore_name, new_driver->name);
738 usbfs_update_special();
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800739 usb_create_newid_file(new_driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800740 } else {
Alan Stern8bb54ab2006-07-01 22:08:49 -0400741 printk(KERN_ERR "%s: error %d registering interface "
742 " driver %s\n",
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800743 usbcore_name, retval, new_driver->name);
744 }
745
746 return retval;
747}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600748EXPORT_SYMBOL_GPL(usb_register_driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800749
750/**
Alan Stern8bb54ab2006-07-01 22:08:49 -0400751 * usb_deregister - unregister a USB interface driver
752 * @driver: USB operations of the interface driver to unregister
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800753 * Context: must be able to sleep
754 *
755 * Unlinks the specified driver from the internal USB driver list.
756 *
757 * NOTE: If you called usb_register_dev(), you still need to call
758 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
759 * this * call will no longer do it for you.
760 */
761void usb_deregister(struct usb_driver *driver)
762{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400763 pr_info("%s: deregistering interface driver %s\n",
764 usbcore_name, driver->name);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800765
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800766 usb_remove_newid_file(driver);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800767 usb_free_dynids(driver);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400768 driver_unregister(&driver->drvwrap.driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800769
770 usbfs_update_special();
771}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600772EXPORT_SYMBOL_GPL(usb_deregister);
Alan Stern36e56a32006-07-01 22:08:06 -0400773
774#ifdef CONFIG_PM
775
Alan Sterne0318eb2006-09-26 14:50:20 -0400776/* Caller has locked udev's pm_mutex */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -0800777static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
Alan Stern36e56a32006-07-01 22:08:06 -0400778{
Alan Stern782da722006-07-01 22:09:35 -0400779 struct usb_device_driver *udriver;
Alan Stern2bf40862006-07-01 22:12:19 -0400780 int status = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400781
Alan Stern114b3682006-07-01 22:13:04 -0400782 if (udev->state == USB_STATE_NOTATTACHED ||
783 udev->state == USB_STATE_SUSPENDED)
784 goto done;
785
Alan Sternb6f6436d2007-05-04 11:51:54 -0400786 /* For devices that don't have a driver, we do a generic suspend. */
787 if (udev->dev.driver)
788 udriver = to_usb_device_driver(udev->dev.driver);
789 else {
Alan Stern645daaa2006-08-30 15:47:02 -0400790 udev->do_remote_wakeup = 0;
Alan Sternb6f6436d2007-05-04 11:51:54 -0400791 udriver = &usb_generic_driver;
Alan Stern1c5df7e2006-07-01 22:13:50 -0400792 }
Alan Stern2bf40862006-07-01 22:12:19 -0400793 status = udriver->suspend(udev, msg);
794
Alan Stern20dfdad2007-05-22 11:50:17 -0400795 done:
796 dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Stern2bf40862006-07-01 22:12:19 -0400797 if (status == 0)
798 udev->dev.power.power_state.event = msg.event;
799 return status;
Alan Stern1cc8a252006-07-01 22:10:15 -0400800}
Alan Stern36e56a32006-07-01 22:08:06 -0400801
Alan Sterne0318eb2006-09-26 14:50:20 -0400802/* Caller has locked udev's pm_mutex */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -0800803static int usb_resume_device(struct usb_device *udev)
Alan Stern1cc8a252006-07-01 22:10:15 -0400804{
805 struct usb_device_driver *udriver;
Alan Stern2bf40862006-07-01 22:12:19 -0400806 int status = 0;
Alan Stern1cc8a252006-07-01 22:10:15 -0400807
Alan Stern0458d5b2007-05-04 11:52:20 -0400808 if (udev->state == USB_STATE_NOTATTACHED)
809 goto done;
810 if (udev->state != USB_STATE_SUSPENDED && !udev->reset_resume)
Alan Stern2bf40862006-07-01 22:12:19 -0400811 goto done;
Alan Stern1cc8a252006-07-01 22:10:15 -0400812
Alan Stern1c5df7e2006-07-01 22:13:50 -0400813 /* Can't resume it if it doesn't have a driver. */
814 if (udev->dev.driver == NULL) {
815 status = -ENOTCONN;
Alan Stern2bf40862006-07-01 22:12:19 -0400816 goto done;
Alan Stern1c5df7e2006-07-01 22:13:50 -0400817 }
818
Alan Stern6bc6cff2007-05-04 11:53:03 -0400819 if (udev->quirks & USB_QUIRK_RESET_RESUME)
820 udev->reset_resume = 1;
821
Alan Stern1cc8a252006-07-01 22:10:15 -0400822 udriver = to_usb_device_driver(udev->dev.driver);
Alan Stern2bf40862006-07-01 22:12:19 -0400823 status = udriver->resume(udev);
824
Alan Stern20dfdad2007-05-22 11:50:17 -0400825 done:
826 dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Stern2add5222007-03-20 14:59:39 -0400827 if (status == 0) {
828 udev->autoresume_disabled = 0;
Alan Stern2bf40862006-07-01 22:12:19 -0400829 udev->dev.power.power_state.event = PM_EVENT_ON;
Alan Stern2add5222007-03-20 14:59:39 -0400830 }
Alan Stern2bf40862006-07-01 22:12:19 -0400831 return status;
Alan Stern1cc8a252006-07-01 22:10:15 -0400832}
833
Alan Sterne0318eb2006-09-26 14:50:20 -0400834/* Caller has locked intf's usb_device's pm mutex */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -0800835static int usb_suspend_interface(struct usb_interface *intf, pm_message_t msg)
Alan Stern1cc8a252006-07-01 22:10:15 -0400836{
837 struct usb_driver *driver;
Alan Stern2bf40862006-07-01 22:12:19 -0400838 int status = 0;
Alan Stern1cc8a252006-07-01 22:10:15 -0400839
Alan Stern114b3682006-07-01 22:13:04 -0400840 /* with no hardware, USB interfaces only use FREEZE and ON states */
841 if (interface_to_usbdev(intf)->state == USB_STATE_NOTATTACHED ||
842 !is_active(intf))
843 goto done;
844
Alan Stern645daaa2006-08-30 15:47:02 -0400845 if (intf->condition == USB_INTERFACE_UNBOUND) /* This can't happen */
Alan Stern2bf40862006-07-01 22:12:19 -0400846 goto done;
Alan Stern1cc8a252006-07-01 22:10:15 -0400847 driver = to_usb_driver(intf->dev.driver);
Alan Stern36e56a32006-07-01 22:08:06 -0400848
Alan Stern36e56a32006-07-01 22:08:06 -0400849 if (driver->suspend && driver->resume) {
Alan Stern1cc8a252006-07-01 22:10:15 -0400850 status = driver->suspend(intf, msg);
Alan Stern645daaa2006-08-30 15:47:02 -0400851 if (status == 0)
852 mark_quiesced(intf);
853 else if (!interface_to_usbdev(intf)->auto_pm)
Alan Stern1cc8a252006-07-01 22:10:15 -0400854 dev_err(&intf->dev, "%s error %d\n",
855 "suspend", status);
Alan Stern36e56a32006-07-01 22:08:06 -0400856 } else {
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800857 /*
858 * FIXME else if there's no suspend method, disconnect...
859 * Not possible if auto_pm is set...
860 */
Alan Stern1cc8a252006-07-01 22:10:15 -0400861 dev_warn(&intf->dev, "no suspend for driver %s?\n",
862 driver->name);
Alan Stern36e56a32006-07-01 22:08:06 -0400863 mark_quiesced(intf);
Alan Stern36e56a32006-07-01 22:08:06 -0400864 }
Alan Stern2bf40862006-07-01 22:12:19 -0400865
Alan Stern20dfdad2007-05-22 11:50:17 -0400866 done:
867 dev_vdbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Stern36e56a32006-07-01 22:08:06 -0400868 return status;
869}
870
Alan Stern645daaa2006-08-30 15:47:02 -0400871/* Caller has locked intf's usb_device's pm_mutex */
Alan Stern0458d5b2007-05-04 11:52:20 -0400872static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
Alan Stern36e56a32006-07-01 22:08:06 -0400873{
Alan Stern1cc8a252006-07-01 22:10:15 -0400874 struct usb_driver *driver;
Alan Stern2bf40862006-07-01 22:12:19 -0400875 int status = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400876
Alan Stern114b3682006-07-01 22:13:04 -0400877 if (interface_to_usbdev(intf)->state == USB_STATE_NOTATTACHED ||
878 is_active(intf))
Alan Stern2bf40862006-07-01 22:12:19 -0400879 goto done;
Alan Stern36e56a32006-07-01 22:08:06 -0400880
Alan Stern645daaa2006-08-30 15:47:02 -0400881 /* Don't let autoresume interfere with unbinding */
882 if (intf->condition == USB_INTERFACE_UNBINDING)
883 goto done;
884
Alan Stern1c5df7e2006-07-01 22:13:50 -0400885 /* Can't resume it if it doesn't have a driver. */
Alan Stern645daaa2006-08-30 15:47:02 -0400886 if (intf->condition == USB_INTERFACE_UNBOUND) {
Alan Stern1c5df7e2006-07-01 22:13:50 -0400887 status = -ENOTCONN;
Alan Stern2bf40862006-07-01 22:12:19 -0400888 goto done;
Alan Stern1c5df7e2006-07-01 22:13:50 -0400889 }
Alan Stern1cc8a252006-07-01 22:10:15 -0400890 driver = to_usb_driver(intf->dev.driver);
Alan Stern36e56a32006-07-01 22:08:06 -0400891
Alan Sternf07600c2007-05-30 15:38:16 -0400892 if (reset_resume) {
893 if (driver->reset_resume) {
894 status = driver->reset_resume(intf);
895 if (status)
896 dev_err(&intf->dev, "%s error %d\n",
897 "reset_resume", status);
898 } else {
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800899 /* status = -EOPNOTSUPP; */
Alan Sternf07600c2007-05-30 15:38:16 -0400900 dev_warn(&intf->dev, "no %s for driver %s?\n",
901 "reset_resume", driver->name);
902 }
903 } else {
904 if (driver->resume) {
905 status = driver->resume(intf);
906 if (status)
907 dev_err(&intf->dev, "%s error %d\n",
908 "resume", status);
909 } else {
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800910 /* status = -EOPNOTSUPP; */
Alan Sternf07600c2007-05-30 15:38:16 -0400911 dev_warn(&intf->dev, "no %s for driver %s?\n",
912 "resume", driver->name);
913 }
914 }
Alan Stern2bf40862006-07-01 22:12:19 -0400915
916done:
Alan Stern20dfdad2007-05-22 11:50:17 -0400917 dev_vdbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Stern0458d5b2007-05-04 11:52:20 -0400918 if (status == 0)
919 mark_active(intf);
Alan Sternf07600c2007-05-30 15:38:16 -0400920
921 /* FIXME: Unbind the driver and reprobe if the resume failed
922 * (not possible if auto_pm is set) */
Alan Stern2bf40862006-07-01 22:12:19 -0400923 return status;
Alan Stern36e56a32006-07-01 22:08:06 -0400924}
925
Alan Stern94fcda12006-11-20 11:38:46 -0500926#ifdef CONFIG_USB_SUSPEND
927
Alan Sternaf4f7602006-10-30 17:06:45 -0500928/* Internal routine to check whether we may autosuspend a device. */
Alan Sternd1aa3e62007-10-11 16:47:36 -0400929static int autosuspend_check(struct usb_device *udev, int reschedule)
Alan Sternaf4f7602006-10-30 17:06:45 -0500930{
931 int i;
932 struct usb_interface *intf;
Alan Sternd1aa3e62007-10-11 16:47:36 -0400933 unsigned long suspend_time, j;
Alan Sternaf4f7602006-10-30 17:06:45 -0500934
Alan Sternb5e795f2007-02-20 15:00:53 -0500935 /* For autosuspend, fail fast if anything is in use or autosuspend
936 * is disabled. Also fail if any interfaces require remote wakeup
937 * but it isn't available.
938 */
Alan Sternaf4f7602006-10-30 17:06:45 -0500939 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
940 if (udev->pm_usage_cnt > 0)
941 return -EBUSY;
Alan Stern2add5222007-03-20 14:59:39 -0400942 if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
Alan Sternb5e795f2007-02-20 15:00:53 -0500943 return -EPERM;
944
Alan Stern19410442007-03-27 13:33:59 -0400945 suspend_time = udev->last_busy + udev->autosuspend_delay;
Alan Sternaf4f7602006-10-30 17:06:45 -0500946 if (udev->actconfig) {
947 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
948 intf = udev->actconfig->interface[i];
949 if (!is_active(intf))
950 continue;
951 if (intf->pm_usage_cnt > 0)
952 return -EBUSY;
953 if (intf->needs_remote_wakeup &&
954 !udev->do_remote_wakeup) {
955 dev_dbg(&udev->dev, "remote wakeup needed "
956 "for autosuspend\n");
957 return -EOPNOTSUPP;
958 }
Alan Sternf07600c2007-05-30 15:38:16 -0400959
960 /* Don't allow autosuspend if the device will need
961 * a reset-resume and any of its interface drivers
962 * doesn't include support.
963 */
964 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
965 struct usb_driver *driver;
966
967 driver = to_usb_driver(intf->dev.driver);
968 if (!driver->reset_resume)
969 return -EOPNOTSUPP;
970 }
Alan Sternaf4f7602006-10-30 17:06:45 -0500971 }
972 }
Alan Stern19410442007-03-27 13:33:59 -0400973
974 /* If everything is okay but the device hasn't been idle for long
Alan Sternd1aa3e62007-10-11 16:47:36 -0400975 * enough, queue a delayed autosuspend request. If the device
976 * _has_ been idle for long enough and the reschedule flag is set,
977 * likewise queue a delayed (1 second) autosuspend request.
Alan Stern19410442007-03-27 13:33:59 -0400978 */
Alan Sternd1aa3e62007-10-11 16:47:36 -0400979 j = jiffies;
980 if (time_before(j, suspend_time))
981 reschedule = 1;
982 else
983 suspend_time = j + HZ;
984 if (reschedule) {
Alan Stern8c9862e2007-04-11 12:06:16 -0400985 if (!timer_pending(&udev->autosuspend.timer)) {
Alan Stern19410442007-03-27 13:33:59 -0400986 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
Alan Sternd1aa3e62007-10-11 16:47:36 -0400987 round_jiffies_relative(suspend_time - j));
988 }
Alan Stern19410442007-03-27 13:33:59 -0400989 return -EAGAIN;
990 }
Alan Sternaf4f7602006-10-30 17:06:45 -0500991 return 0;
992}
993
Alan Stern94fcda12006-11-20 11:38:46 -0500994#else
995
Alan Sternd1aa3e62007-10-11 16:47:36 -0400996static inline int autosuspend_check(struct usb_device *udev, int reschedule)
Alan Sternef7f6c72007-04-05 16:03:49 -0400997{
998 return 0;
999}
Alan Stern94fcda12006-11-20 11:38:46 -05001000
Alan Sternb5e795f2007-02-20 15:00:53 -05001001#endif /* CONFIG_USB_SUSPEND */
Alan Stern94fcda12006-11-20 11:38:46 -05001002
Alan Stern645daaa2006-08-30 15:47:02 -04001003/**
1004 * usb_suspend_both - suspend a USB device and its interfaces
1005 * @udev: the usb_device to suspend
1006 * @msg: Power Management message describing this state transition
1007 *
1008 * This is the central routine for suspending USB devices. It calls the
1009 * suspend methods for all the interface drivers in @udev and then calls
1010 * the suspend method for @udev itself. If an error occurs at any stage,
1011 * all the interfaces which were suspended are resumed so that they remain
1012 * in the same state as the device.
1013 *
1014 * If an autosuspend is in progress (@udev->auto_pm is set), the routine
1015 * checks first to make sure that neither the device itself or any of its
1016 * active interfaces is in use (pm_usage_cnt is greater than 0). If they
1017 * are, the autosuspend fails.
1018 *
1019 * If the suspend succeeds, the routine recursively queues an autosuspend
1020 * request for @udev's parent device, thereby propagating the change up
1021 * the device tree. If all of the parent's children are now suspended,
1022 * the parent will autosuspend in turn.
1023 *
1024 * The suspend method calls are subject to mutual exclusion under control
1025 * of @udev's pm_mutex. Many of these calls are also under the protection
1026 * of @udev's device lock (including all requests originating outside the
1027 * USB subsystem), but autosuspend requests generated by a child device or
1028 * interface driver may not be. Usbcore will insure that the method calls
1029 * do not arrive during bind, unbind, or reset operations. However, drivers
1030 * must be prepared to handle suspend calls arriving at unpredictable times.
1031 * The only way to block such calls is to do an autoresume (preventing
1032 * autosuspends) while holding @udev's device lock (preventing outside
1033 * suspends).
1034 *
1035 * The caller must hold @udev->pm_mutex.
1036 *
1037 * This routine can run only in process context.
1038 */
Alan Stern718efa62007-03-09 15:41:13 -05001039static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
Alan Sterna8e7c562006-07-01 22:11:02 -04001040{
1041 int status = 0;
1042 int i = 0;
1043 struct usb_interface *intf;
Alan Stern645daaa2006-08-30 15:47:02 -04001044 struct usb_device *parent = udev->parent;
Alan Sterna8e7c562006-07-01 22:11:02 -04001045
Alan Stern19410442007-03-27 13:33:59 -04001046 if (udev->state == USB_STATE_NOTATTACHED ||
1047 udev->state == USB_STATE_SUSPENDED)
1048 goto done;
Alan Stern645daaa2006-08-30 15:47:02 -04001049
1050 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
1051
Alan Stern645daaa2006-08-30 15:47:02 -04001052 if (udev->auto_pm) {
Alan Sternd1aa3e62007-10-11 16:47:36 -04001053 status = autosuspend_check(udev, 0);
Alan Sternaf4f7602006-10-30 17:06:45 -05001054 if (status < 0)
Alan Stern19410442007-03-27 13:33:59 -04001055 goto done;
Alan Stern645daaa2006-08-30 15:47:02 -04001056 }
1057
1058 /* Suspend all the interfaces and then udev itself */
Alan Sterna8e7c562006-07-01 22:11:02 -04001059 if (udev->actconfig) {
1060 for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
1061 intf = udev->actconfig->interface[i];
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -08001062 status = usb_suspend_interface(intf, msg);
Alan Sterna8e7c562006-07-01 22:11:02 -04001063 if (status != 0)
1064 break;
1065 }
1066 }
Alan Stern5ad4f712007-09-10 11:31:43 -04001067 if (status == 0)
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -08001068 status = usb_suspend_device(udev, msg);
Alan Sterna8e7c562006-07-01 22:11:02 -04001069
1070 /* If the suspend failed, resume interfaces that did get suspended */
1071 if (status != 0) {
1072 while (--i >= 0) {
1073 intf = udev->actconfig->interface[i];
Alan Stern0458d5b2007-05-04 11:52:20 -04001074 usb_resume_interface(intf, 0);
Alan Sterna8e7c562006-07-01 22:11:02 -04001075 }
Alan Stern645daaa2006-08-30 15:47:02 -04001076
Alan Sternef7f6c72007-04-05 16:03:49 -04001077 /* Try another autosuspend when the interfaces aren't busy */
1078 if (udev->auto_pm)
Alan Sternd1aa3e62007-10-11 16:47:36 -04001079 autosuspend_check(udev, status == -EBUSY);
Alan Sternef7f6c72007-04-05 16:03:49 -04001080
Alan Stern6840d252007-09-10 11:34:26 -04001081 /* If the suspend succeeded then prevent any more URB submissions,
1082 * flush any outstanding URBs, and propagate the suspend up the tree.
1083 */
Alan Sternef7f6c72007-04-05 16:03:49 -04001084 } else {
1085 cancel_delayed_work(&udev->autosuspend);
Alan Stern6840d252007-09-10 11:34:26 -04001086 udev->can_submit = 0;
1087 for (i = 0; i < 16; ++i) {
1088 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1089 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1090 }
Alan Stern7108f282007-09-20 12:37:50 -04001091
1092 /* If this is just a FREEZE or a PRETHAW, udev might
1093 * not really be suspended. Only true suspends get
1094 * propagated up the device tree.
1095 */
1096 if (parent && udev->state == USB_STATE_SUSPENDED)
Alan Sternef7f6c72007-04-05 16:03:49 -04001097 usb_autosuspend_device(parent);
1098 }
Alan Stern645daaa2006-08-30 15:47:02 -04001099
Alan Stern19410442007-03-27 13:33:59 -04001100 done:
Alan Stern20dfdad2007-05-22 11:50:17 -04001101 dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Sterna8e7c562006-07-01 22:11:02 -04001102 return status;
1103}
1104
Alan Stern645daaa2006-08-30 15:47:02 -04001105/**
1106 * usb_resume_both - resume a USB device and its interfaces
1107 * @udev: the usb_device to resume
1108 *
1109 * This is the central routine for resuming USB devices. It calls the
1110 * the resume method for @udev and then calls the resume methods for all
1111 * the interface drivers in @udev.
1112 *
1113 * Before starting the resume, the routine calls itself recursively for
1114 * the parent device of @udev, thereby propagating the change up the device
1115 * tree and assuring that @udev will be able to resume. If the parent is
1116 * unable to resume successfully, the routine fails.
1117 *
1118 * The resume method calls are subject to mutual exclusion under control
1119 * of @udev's pm_mutex. Many of these calls are also under the protection
1120 * of @udev's device lock (including all requests originating outside the
1121 * USB subsystem), but autoresume requests generated by a child device or
1122 * interface driver may not be. Usbcore will insure that the method calls
1123 * do not arrive during bind, unbind, or reset operations. However, drivers
1124 * must be prepared to handle resume calls arriving at unpredictable times.
1125 * The only way to block such calls is to do an autoresume (preventing
1126 * other autoresumes) while holding @udev's device lock (preventing outside
1127 * resumes).
1128 *
1129 * The caller must hold @udev->pm_mutex.
1130 *
1131 * This routine can run only in process context.
1132 */
Alan Stern718efa62007-03-09 15:41:13 -05001133static int usb_resume_both(struct usb_device *udev)
Alan Sterna8e7c562006-07-01 22:11:02 -04001134{
Alan Stern645daaa2006-08-30 15:47:02 -04001135 int status = 0;
Alan Sterna8e7c562006-07-01 22:11:02 -04001136 int i;
1137 struct usb_interface *intf;
Alan Stern645daaa2006-08-30 15:47:02 -04001138 struct usb_device *parent = udev->parent;
Alan Sterna8e7c562006-07-01 22:11:02 -04001139
Alan Stern645daaa2006-08-30 15:47:02 -04001140 cancel_delayed_work(&udev->autosuspend);
Alan Stern19410442007-03-27 13:33:59 -04001141 if (udev->state == USB_STATE_NOTATTACHED) {
1142 status = -ENODEV;
1143 goto done;
1144 }
Alan Stern6840d252007-09-10 11:34:26 -04001145 udev->can_submit = 1;
Alan Stern645daaa2006-08-30 15:47:02 -04001146
1147 /* Propagate the resume up the tree, if necessary */
1148 if (udev->state == USB_STATE_SUSPENDED) {
Alan Stern19410442007-03-27 13:33:59 -04001149 if (udev->auto_pm && udev->autoresume_disabled) {
1150 status = -EPERM;
1151 goto done;
1152 }
Alan Stern645daaa2006-08-30 15:47:02 -04001153 if (parent) {
Alan Stern94fcda12006-11-20 11:38:46 -05001154 status = usb_autoresume_device(parent);
Alan Sternee49fb52006-11-22 16:55:54 -05001155 if (status == 0) {
1156 status = usb_resume_device(udev);
Alan Sternf07600c2007-05-30 15:38:16 -04001157 if (status || udev->state ==
1158 USB_STATE_NOTATTACHED) {
Alan Stern94fcda12006-11-20 11:38:46 -05001159 usb_autosuspend_device(parent);
Alan Sternee49fb52006-11-22 16:55:54 -05001160
1161 /* It's possible usb_resume_device()
1162 * failed after the port was
1163 * unsuspended, causing udev to be
1164 * logically disconnected. We don't
1165 * want usb_disconnect() to autosuspend
1166 * the parent again, so tell it that
1167 * udev disconnected while still
1168 * suspended. */
1169 if (udev->state ==
1170 USB_STATE_NOTATTACHED)
1171 udev->discon_suspended = 1;
1172 }
1173 }
Alan Stern645daaa2006-08-30 15:47:02 -04001174 } else {
1175
1176 /* We can't progagate beyond the USB subsystem,
1177 * so if a root hub's controller is suspended
1178 * then we're stuck. */
Alan Sterne7e6da92007-06-21 16:25:17 -04001179 status = usb_resume_device(udev);
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -08001180 }
Alan Stern592fbbe2006-09-19 10:08:43 -04001181 } else {
1182
Alan Stern0458d5b2007-05-04 11:52:20 -04001183 /* Needed for setting udev->dev.power.power_state.event,
1184 * for possible debugging message, and for reset_resume. */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -08001185 status = usb_resume_device(udev);
Alan Stern114b3682006-07-01 22:13:04 -04001186 }
1187
Alan Sterna8e7c562006-07-01 22:11:02 -04001188 if (status == 0 && udev->actconfig) {
1189 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1190 intf = udev->actconfig->interface[i];
Alan Stern0458d5b2007-05-04 11:52:20 -04001191 usb_resume_interface(intf, udev->reset_resume);
Alan Sterna8e7c562006-07-01 22:11:02 -04001192 }
1193 }
Alan Stern645daaa2006-08-30 15:47:02 -04001194
Alan Stern19410442007-03-27 13:33:59 -04001195 done:
Alan Stern20dfdad2007-05-22 11:50:17 -04001196 dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
Alan Stern0458d5b2007-05-04 11:52:20 -04001197 udev->reset_resume = 0;
Alan Sterna8e7c562006-07-01 22:11:02 -04001198 return status;
1199}
1200
Alan Stern645daaa2006-08-30 15:47:02 -04001201#ifdef CONFIG_USB_SUSPEND
1202
Alan Stern94fcda12006-11-20 11:38:46 -05001203/* Internal routine to adjust a device's usage counter and change
1204 * its autosuspend state.
1205 */
1206static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
1207{
1208 int status = 0;
1209
1210 usb_pm_lock(udev);
Alan Stern19410442007-03-27 13:33:59 -04001211 udev->auto_pm = 1;
Alan Stern94fcda12006-11-20 11:38:46 -05001212 udev->pm_usage_cnt += inc_usage_cnt;
1213 WARN_ON(udev->pm_usage_cnt < 0);
Alan Stern013d27f2007-08-20 12:18:39 -04001214 if (inc_usage_cnt)
1215 udev->last_busy = jiffies;
Alan Stern94fcda12006-11-20 11:38:46 -05001216 if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
Alan Stern19410442007-03-27 13:33:59 -04001217 if (udev->state == USB_STATE_SUSPENDED)
1218 status = usb_resume_both(udev);
Alan Stern94fcda12006-11-20 11:38:46 -05001219 if (status != 0)
1220 udev->pm_usage_cnt -= inc_usage_cnt;
Alan Stern19410442007-03-27 13:33:59 -04001221 else if (inc_usage_cnt)
1222 udev->last_busy = jiffies;
1223 } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
Alan Stern19410442007-03-27 13:33:59 -04001224 status = usb_suspend_both(udev, PMSG_SUSPEND);
1225 }
Alan Stern94fcda12006-11-20 11:38:46 -05001226 usb_pm_unlock(udev);
1227 return status;
1228}
1229
Alan Stern19410442007-03-27 13:33:59 -04001230/* usb_autosuspend_work - callback routine to autosuspend a USB device */
1231void usb_autosuspend_work(struct work_struct *work)
1232{
1233 struct usb_device *udev =
1234 container_of(work, struct usb_device, autosuspend.work);
1235
1236 usb_autopm_do_device(udev, 0);
1237}
1238
Alan Stern645daaa2006-08-30 15:47:02 -04001239/**
1240 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001241 * @udev: the usb_device to autosuspend
Alan Stern645daaa2006-08-30 15:47:02 -04001242 *
1243 * This routine should be called when a core subsystem is finished using
1244 * @udev and wants to allow it to autosuspend. Examples would be when
1245 * @udev's device file in usbfs is closed or after a configuration change.
1246 *
Alan Stern94fcda12006-11-20 11:38:46 -05001247 * @udev's usage counter is decremented. If it or any of the usage counters
1248 * for an active interface is greater than 0, no autosuspend request will be
1249 * queued. (If an interface driver does not support autosuspend then its
1250 * usage counter is permanently positive.) Furthermore, if an interface
1251 * driver requires remote-wakeup capability during autosuspend but remote
1252 * wakeup is disabled, the autosuspend will fail.
Alan Stern645daaa2006-08-30 15:47:02 -04001253 *
1254 * Often the caller will hold @udev's device lock, but this is not
1255 * necessary.
1256 *
1257 * This routine can run only in process context.
1258 */
Alan Stern94fcda12006-11-20 11:38:46 -05001259void usb_autosuspend_device(struct usb_device *udev)
Alan Stern645daaa2006-08-30 15:47:02 -04001260{
Alan Stern94fcda12006-11-20 11:38:46 -05001261 int status;
1262
1263 status = usb_autopm_do_device(udev, -1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001264 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1265 __FUNCTION__, udev->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001266}
1267
1268/**
Alan Stern19c26232007-02-20 15:03:32 -05001269 * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
1270 * @udev: the usb_device to autosuspend
1271 *
1272 * This routine should be called when a core subsystem thinks @udev may
1273 * be ready to autosuspend.
1274 *
1275 * @udev's usage counter left unchanged. If it or any of the usage counters
1276 * for an active interface is greater than 0, or autosuspend is not allowed
1277 * for any other reason, no autosuspend request will be queued.
1278 *
1279 * This routine can run only in process context.
1280 */
1281void usb_try_autosuspend_device(struct usb_device *udev)
1282{
1283 usb_autopm_do_device(udev, 0);
Alan Stern20dfdad2007-05-22 11:50:17 -04001284 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1285 __FUNCTION__, udev->pm_usage_cnt);
Alan Stern19c26232007-02-20 15:03:32 -05001286}
1287
1288/**
Alan Stern645daaa2006-08-30 15:47:02 -04001289 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001290 * @udev: the usb_device to autoresume
Alan Stern645daaa2006-08-30 15:47:02 -04001291 *
1292 * This routine should be called when a core subsystem wants to use @udev
Alan Stern94fcda12006-11-20 11:38:46 -05001293 * and needs to guarantee that it is not suspended. No autosuspend will
1294 * occur until usb_autosuspend_device is called. (Note that this will not
1295 * prevent suspend events originating in the PM core.) Examples would be
1296 * when @udev's device file in usbfs is opened or when a remote-wakeup
1297 * request is received.
Alan Stern645daaa2006-08-30 15:47:02 -04001298 *
Alan Stern94fcda12006-11-20 11:38:46 -05001299 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1300 * However if the autoresume fails then the usage counter is re-decremented.
Alan Stern645daaa2006-08-30 15:47:02 -04001301 *
1302 * Often the caller will hold @udev's device lock, but this is not
1303 * necessary (and attempting it might cause deadlock).
1304 *
1305 * This routine can run only in process context.
1306 */
Alan Stern94fcda12006-11-20 11:38:46 -05001307int usb_autoresume_device(struct usb_device *udev)
Alan Stern645daaa2006-08-30 15:47:02 -04001308{
1309 int status;
1310
Alan Stern94fcda12006-11-20 11:38:46 -05001311 status = usb_autopm_do_device(udev, 1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001312 dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
1313 __FUNCTION__, status, udev->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001314 return status;
1315}
1316
Alan Sternaf4f7602006-10-30 17:06:45 -05001317/* Internal routine to adjust an interface's usage counter and change
1318 * its device's autosuspend state.
1319 */
1320static int usb_autopm_do_interface(struct usb_interface *intf,
1321 int inc_usage_cnt)
1322{
1323 struct usb_device *udev = interface_to_usbdev(intf);
1324 int status = 0;
1325
1326 usb_pm_lock(udev);
1327 if (intf->condition == USB_INTERFACE_UNBOUND)
1328 status = -ENODEV;
1329 else {
Alan Stern19410442007-03-27 13:33:59 -04001330 udev->auto_pm = 1;
Alan Sternaf4f7602006-10-30 17:06:45 -05001331 intf->pm_usage_cnt += inc_usage_cnt;
Alan Stern013d27f2007-08-20 12:18:39 -04001332 udev->last_busy = jiffies;
Alan Sternaf4f7602006-10-30 17:06:45 -05001333 if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
Alan Stern19410442007-03-27 13:33:59 -04001334 if (udev->state == USB_STATE_SUSPENDED)
1335 status = usb_resume_both(udev);
Alan Sternaf4f7602006-10-30 17:06:45 -05001336 if (status != 0)
1337 intf->pm_usage_cnt -= inc_usage_cnt;
Alan Stern013d27f2007-08-20 12:18:39 -04001338 else
Alan Stern19410442007-03-27 13:33:59 -04001339 udev->last_busy = jiffies;
1340 } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
Alan Stern19410442007-03-27 13:33:59 -04001341 status = usb_suspend_both(udev, PMSG_SUSPEND);
1342 }
Alan Sternaf4f7602006-10-30 17:06:45 -05001343 }
1344 usb_pm_unlock(udev);
1345 return status;
1346}
1347
Alan Stern645daaa2006-08-30 15:47:02 -04001348/**
1349 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001350 * @intf: the usb_interface whose counter should be decremented
Alan Stern645daaa2006-08-30 15:47:02 -04001351 *
1352 * This routine should be called by an interface driver when it is
1353 * finished using @intf and wants to allow it to autosuspend. A typical
1354 * example would be a character-device driver when its device file is
1355 * closed.
1356 *
1357 * The routine decrements @intf's usage counter. When the counter reaches
1358 * 0, a delayed autosuspend request for @intf's device is queued. When
1359 * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
1360 * the other usage counters for the sibling interfaces and @intf's
1361 * usb_device, the device and all its interfaces will be autosuspended.
1362 *
1363 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1364 * core will not change its value other than the increment and decrement
1365 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1366 * may use this simple counter-oriented discipline or may set the value
1367 * any way it likes.
1368 *
1369 * If the driver has set @intf->needs_remote_wakeup then autosuspend will
1370 * take place only if the device's remote-wakeup facility is enabled.
1371 *
1372 * Suspend method calls queued by this routine can arrive at any time
1373 * while @intf is resumed and its usage counter is equal to 0. They are
1374 * not protected by the usb_device's lock but only by its pm_mutex.
1375 * Drivers must provide their own synchronization.
1376 *
1377 * This routine can run only in process context.
1378 */
1379void usb_autopm_put_interface(struct usb_interface *intf)
1380{
Alan Sternaf4f7602006-10-30 17:06:45 -05001381 int status;
Alan Stern645daaa2006-08-30 15:47:02 -04001382
Alan Sternaf4f7602006-10-30 17:06:45 -05001383 status = usb_autopm_do_interface(intf, -1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001384 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1385 __FUNCTION__, status, intf->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001386}
1387EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1388
1389/**
1390 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001391 * @intf: the usb_interface whose counter should be incremented
Alan Stern645daaa2006-08-30 15:47:02 -04001392 *
1393 * This routine should be called by an interface driver when it wants to
1394 * use @intf and needs to guarantee that it is not suspended. In addition,
1395 * the routine prevents @intf from being autosuspended subsequently. (Note
1396 * that this will not prevent suspend events originating in the PM core.)
1397 * This prevention will persist until usb_autopm_put_interface() is called
1398 * or @intf is unbound. A typical example would be a character-device
1399 * driver when its device file is opened.
1400 *
Alan Stern19410442007-03-27 13:33:59 -04001401 *
1402 * The routine increments @intf's usage counter. (However if the
1403 * autoresume fails then the counter is re-decremented.) So long as the
1404 * counter is greater than 0, autosuspend will not be allowed for @intf
1405 * or its usb_device. When the driver is finished using @intf it should
1406 * call usb_autopm_put_interface() to decrement the usage counter and
1407 * queue a delayed autosuspend request (if the counter is <= 0).
1408 *
Alan Stern645daaa2006-08-30 15:47:02 -04001409 *
1410 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1411 * core will not change its value other than the increment and decrement
1412 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1413 * may use this simple counter-oriented discipline or may set the value
1414 * any way it likes.
1415 *
1416 * Resume method calls generated by this routine can arrive at any time
1417 * while @intf is suspended. They are not protected by the usb_device's
1418 * lock but only by its pm_mutex. Drivers must provide their own
1419 * synchronization.
1420 *
1421 * This routine can run only in process context.
1422 */
1423int usb_autopm_get_interface(struct usb_interface *intf)
1424{
Alan Sternaf4f7602006-10-30 17:06:45 -05001425 int status;
Alan Stern645daaa2006-08-30 15:47:02 -04001426
Alan Sternaf4f7602006-10-30 17:06:45 -05001427 status = usb_autopm_do_interface(intf, 1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001428 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1429 __FUNCTION__, status, intf->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001430 return status;
1431}
1432EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1433
Alan Stern692a1862006-10-30 17:07:51 -05001434/**
1435 * usb_autopm_set_interface - set a USB interface's autosuspend state
1436 * @intf: the usb_interface whose state should be set
1437 *
1438 * This routine sets the autosuspend state of @intf's device according
1439 * to @intf's usage counter, which the caller must have set previously.
1440 * If the counter is <= 0, the device is autosuspended (if it isn't
1441 * already suspended and if nothing else prevents the autosuspend). If
1442 * the counter is > 0, the device is autoresumed (if it isn't already
1443 * awake).
1444 */
1445int usb_autopm_set_interface(struct usb_interface *intf)
1446{
1447 int status;
1448
1449 status = usb_autopm_do_interface(intf, 0);
Alan Stern20dfdad2007-05-22 11:50:17 -04001450 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1451 __FUNCTION__, status, intf->pm_usage_cnt);
Alan Stern692a1862006-10-30 17:07:51 -05001452 return status;
1453}
1454EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
1455
Alan Stern718efa62007-03-09 15:41:13 -05001456#else
1457
1458void usb_autosuspend_work(struct work_struct *work)
1459{}
1460
Alan Stern645daaa2006-08-30 15:47:02 -04001461#endif /* CONFIG_USB_SUSPEND */
1462
Alan Stern6b157c92007-03-13 16:37:30 -04001463/**
1464 * usb_external_suspend_device - external suspend of a USB device and its interfaces
1465 * @udev: the usb_device to suspend
1466 * @msg: Power Management message describing this state transition
1467 *
1468 * This routine handles external suspend requests: ones not generated
1469 * internally by a USB driver (autosuspend) but rather coming from the user
1470 * (via sysfs) or the PM core (system sleep). The suspend will be carried
1471 * out regardless of @udev's usage counter or those of its interfaces,
1472 * and regardless of whether or not remote wakeup is enabled. Of course,
1473 * interface drivers still have the option of failing the suspend (if
1474 * there are unsuspended children, for example).
1475 *
1476 * The caller must hold @udev's device lock.
1477 */
1478int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
Alan Stern1cc8a252006-07-01 22:10:15 -04001479{
1480 int status;
1481
Alan Stern6b157c92007-03-13 16:37:30 -04001482 usb_pm_lock(udev);
1483 udev->auto_pm = 0;
1484 status = usb_suspend_both(udev, msg);
1485 usb_pm_unlock(udev);
Alan Stern1cc8a252006-07-01 22:10:15 -04001486 return status;
1487}
1488
Alan Stern6b157c92007-03-13 16:37:30 -04001489/**
1490 * usb_external_resume_device - external resume of a USB device and its interfaces
1491 * @udev: the usb_device to resume
1492 *
1493 * This routine handles external resume requests: ones not generated
1494 * internally by a USB driver (autoresume) but rather coming from the user
1495 * (via sysfs), the PM core (system resume), or the device itself (remote
1496 * wakeup). @udev's usage counter is unaffected.
1497 *
1498 * The caller must hold @udev's device lock.
1499 */
1500int usb_external_resume_device(struct usb_device *udev)
1501{
1502 int status;
1503
1504 usb_pm_lock(udev);
1505 udev->auto_pm = 0;
1506 status = usb_resume_both(udev);
Alan Sternef7f6c72007-04-05 16:03:49 -04001507 udev->last_busy = jiffies;
Alan Stern6b157c92007-03-13 16:37:30 -04001508 usb_pm_unlock(udev);
1509
1510 /* Now that the device is awake, we can start trying to autosuspend
1511 * it again. */
1512 if (status == 0)
1513 usb_try_autosuspend_device(udev);
1514 return status;
1515}
1516
1517static int usb_suspend(struct device *dev, pm_message_t message)
1518{
Alan Stern271f9e62007-10-10 16:30:12 -04001519 struct usb_device *udev;
1520
Alan Stern6b157c92007-03-13 16:37:30 -04001521 if (!is_usb_device(dev)) /* Ignore PM for interfaces */
1522 return 0;
Alan Stern271f9e62007-10-10 16:30:12 -04001523 udev = to_usb_device(dev);
1524
1525 /* If udev is already suspended, we can skip this suspend and
1526 * we should also skip the upcoming system resume. */
1527 if (udev->state == USB_STATE_SUSPENDED) {
1528 udev->skip_sys_resume = 1;
1529 return 0;
1530 }
1531
1532 udev->skip_sys_resume = 0;
1533 return usb_external_suspend_device(udev, message);
Alan Stern6b157c92007-03-13 16:37:30 -04001534}
1535
Alan Stern1cc8a252006-07-01 22:10:15 -04001536static int usb_resume(struct device *dev)
1537{
Alan Stern2add5222007-03-20 14:59:39 -04001538 struct usb_device *udev;
1539
Alan Stern6b157c92007-03-13 16:37:30 -04001540 if (!is_usb_device(dev)) /* Ignore PM for interfaces */
1541 return 0;
Alan Stern2add5222007-03-20 14:59:39 -04001542 udev = to_usb_device(dev);
Alan Stern0458d5b2007-05-04 11:52:20 -04001543
Alan Stern271f9e62007-10-10 16:30:12 -04001544 /* If udev->skip_sys_resume is set then udev was already suspended
1545 * when the system suspend started, so we don't want to resume
1546 * udev during this system wakeup. However a reset-resume counts
1547 * as a wakeup event, so allow a reset-resume to occur if remote
1548 * wakeup is enabled. */
1549 if (udev->skip_sys_resume) {
Alan Stern0458d5b2007-05-04 11:52:20 -04001550 if (!(udev->reset_resume && udev->do_remote_wakeup))
Alan Stern271f9e62007-10-10 16:30:12 -04001551 return -EHOSTUNREACH;
Alan Stern0458d5b2007-05-04 11:52:20 -04001552 }
Alan Stern2add5222007-03-20 14:59:39 -04001553 return usb_external_resume_device(udev);
Alan Stern1cc8a252006-07-01 22:10:15 -04001554}
1555
Alan Stern6b157c92007-03-13 16:37:30 -04001556#else
1557
1558#define usb_suspend NULL
1559#define usb_resume NULL
1560
Alan Stern36e56a32006-07-01 22:08:06 -04001561#endif /* CONFIG_PM */
1562
1563struct bus_type usb_bus_type = {
1564 .name = "usb",
1565 .match = usb_device_match,
1566 .uevent = usb_uevent,
Alan Stern782da722006-07-01 22:09:35 -04001567 .suspend = usb_suspend,
1568 .resume = usb_resume,
Alan Stern36e56a32006-07-01 22:08:06 -04001569};