blob: 5a7fa6f099584206536c40b21dde9117b79cd5e1 [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
Harvey Harrison441b62c2008-03-03 16:08:34 -0800160 dev_dbg(dev, "%s\n", __func__);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400161
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
Harvey Harrison441b62c2008-03-03 16:08:34 -0800197 dev_dbg(dev, "%s\n", __func__);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800198
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);
Alan Stern78d9a482008-06-23 16:00:40 -0400204 intf->needs_binding = 0;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800205
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800206 if (udev->authorized == 0) {
207 dev_err(&intf->dev, "Device is not authorized for usage\n");
208 return -ENODEV;
209 }
Inaky Perez-Gonzalez72230ab2007-07-31 20:34:03 -0700210
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800211 id = usb_match_id(intf, driver->id_table);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800212 if (!id)
213 id = usb_match_dynamic_id(intf, driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800214 if (id) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800215 dev_dbg(dev, "%s - got id\n", __func__);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800216
Alan Stern94fcda12006-11-20 11:38:46 -0500217 error = usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -0400218 if (error)
219 return error;
220
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800221 /* Interface "power state" doesn't correspond to any hardware
222 * state whatsoever. We use it to record when it's bound to
223 * a driver that may start I/0: it's not frozen/quiesced.
224 */
225 mark_active(intf);
226 intf->condition = USB_INTERFACE_BINDING;
Alan Stern645daaa2006-08-30 15:47:02 -0400227
228 /* The interface should always appear to be in use
229 * unless the driver suports autosuspend.
230 */
231 intf->pm_usage_cnt = !(driver->supports_autosuspend);
232
Alan Stern55151d72008-08-12 14:33:59 -0400233 /* Carry out a deferred switch to altsetting 0 */
234 if (intf->needs_altsetting0) {
235 usb_set_interface(udev, intf->altsetting[0].
236 desc.bInterfaceNumber, 0);
237 intf->needs_altsetting0 = 0;
238 }
239
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800240 error = driver->probe(intf, id);
241 if (error) {
242 mark_quiesced(intf);
Alan Stern645daaa2006-08-30 15:47:02 -0400243 intf->needs_remote_wakeup = 0;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800244 intf->condition = USB_INTERFACE_UNBOUND;
245 } else
246 intf->condition = USB_INTERFACE_BOUND;
Alan Stern645daaa2006-08-30 15:47:02 -0400247
Alan Stern94fcda12006-11-20 11:38:46 -0500248 usb_autosuspend_device(udev);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800249 }
250
251 return error;
252}
253
Alan Stern8bb54ab2006-07-01 22:08:49 -0400254/* called from driver core with dev locked */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800255static int usb_unbind_interface(struct device *dev)
256{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400257 struct usb_driver *driver = to_usb_driver(dev->driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800258 struct usb_interface *intf = to_usb_interface(dev);
Alan Stern645daaa2006-08-30 15:47:02 -0400259 struct usb_device *udev;
260 int error;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800261
262 intf->condition = USB_INTERFACE_UNBINDING;
263
Alan Stern645daaa2006-08-30 15:47:02 -0400264 /* Autoresume for set_interface call below */
265 udev = interface_to_usbdev(intf);
Alan Stern94fcda12006-11-20 11:38:46 -0500266 error = usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -0400267
Alan Stern9da82bd2008-05-08 11:54:37 -0400268 /* Terminate all URBs for this interface unless the driver
269 * supports "soft" unbinding.
270 */
271 if (!driver->soft_unbind)
272 usb_disable_interface(udev, intf);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800273
Alan Stern8bb54ab2006-07-01 22:08:49 -0400274 driver->disconnect(intf);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800275
Alan Stern55151d72008-08-12 14:33:59 -0400276 /* Reset other interface state.
277 * We cannot do a Set-Interface if the device is suspended or
278 * if it is prepared for a system sleep (since installing a new
279 * altsetting means creating new endpoint device entries).
280 * When either of these happens, defer the Set-Interface.
281 */
282 if (!error && intf->dev.power.status == DPM_ON)
283 usb_set_interface(udev, intf->altsetting[0].
284 desc.bInterfaceNumber, 0);
285 else
286 intf->needs_altsetting0 = 1;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800287 usb_set_intfdata(intf, NULL);
Alan Stern645daaa2006-08-30 15:47:02 -0400288
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800289 intf->condition = USB_INTERFACE_UNBOUND;
290 mark_quiesced(intf);
Alan Stern645daaa2006-08-30 15:47:02 -0400291 intf->needs_remote_wakeup = 0;
292
293 if (!error)
Alan Stern94fcda12006-11-20 11:38:46 -0500294 usb_autosuspend_device(udev);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800295
296 return 0;
297}
298
Alan Stern36e56a32006-07-01 22:08:06 -0400299/**
300 * usb_driver_claim_interface - bind a driver to an interface
301 * @driver: the driver to be bound
302 * @iface: the interface to which it will be bound; must be in the
303 * usb device's active configuration
304 * @priv: driver data associated with that interface
305 *
306 * This is used by usb device drivers that need to claim more than one
307 * interface on a device when probing (audio and acm are current examples).
308 * No device driver should directly modify internal usb_interface or
309 * usb_device structure members.
310 *
311 * Few drivers should need to use this routine, since the most natural
312 * way to bind to an interface is to return the private data from
313 * the driver's probe() method.
314 *
Greg Kroah-Hartman341487a2007-04-09 11:52:31 -0400315 * Callers must own the device lock, so driver probe() entries don't need
316 * extra locking, but other call contexts may need to explicitly claim that
317 * lock.
Alan Stern36e56a32006-07-01 22:08:06 -0400318 */
319int usb_driver_claim_interface(struct usb_driver *driver,
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800320 struct usb_interface *iface, void *priv)
Alan Stern36e56a32006-07-01 22:08:06 -0400321{
322 struct device *dev = &iface->dev;
Alan Stern645daaa2006-08-30 15:47:02 -0400323 struct usb_device *udev = interface_to_usbdev(iface);
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700324 int retval = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400325
326 if (dev->driver)
327 return -EBUSY;
328
Alan Stern8bb54ab2006-07-01 22:08:49 -0400329 dev->driver = &driver->drvwrap.driver;
Alan Stern36e56a32006-07-01 22:08:06 -0400330 usb_set_intfdata(iface, priv);
Alan Stern78d9a482008-06-23 16:00:40 -0400331 iface->needs_binding = 0;
Alan Stern645daaa2006-08-30 15:47:02 -0400332
Alan Sterne0318eb2006-09-26 14:50:20 -0400333 usb_pm_lock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400334 iface->condition = USB_INTERFACE_BOUND;
335 mark_active(iface);
Alan Stern645daaa2006-08-30 15:47:02 -0400336 iface->pm_usage_cnt = !(driver->supports_autosuspend);
Alan Sterne0318eb2006-09-26 14:50:20 -0400337 usb_pm_unlock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400338
339 /* if interface was already added, bind now; else let
340 * the future device_add() bind it, bypassing probe()
341 */
342 if (device_is_registered(dev))
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700343 retval = device_bind_driver(dev);
Alan Stern36e56a32006-07-01 22:08:06 -0400344
Greg Kroah-Hartman1b21d5e2006-08-28 11:43:25 -0700345 return retval;
Alan Stern36e56a32006-07-01 22:08:06 -0400346}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600347EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
Alan Stern36e56a32006-07-01 22:08:06 -0400348
349/**
350 * usb_driver_release_interface - unbind a driver from an interface
351 * @driver: the driver to be unbound
352 * @iface: the interface from which it will be unbound
353 *
354 * This can be used by drivers to release an interface without waiting
355 * for their disconnect() methods to be called. In typical cases this
356 * also causes the driver disconnect() method to be called.
357 *
358 * This call is synchronous, and may not be used in an interrupt context.
Greg Kroah-Hartman341487a2007-04-09 11:52:31 -0400359 * Callers must own the device lock, so driver disconnect() entries don't
360 * need extra locking, but other call contexts may need to explicitly claim
361 * that lock.
Alan Stern36e56a32006-07-01 22:08:06 -0400362 */
363void usb_driver_release_interface(struct usb_driver *driver,
364 struct usb_interface *iface)
365{
366 struct device *dev = &iface->dev;
Alan Stern645daaa2006-08-30 15:47:02 -0400367 struct usb_device *udev = interface_to_usbdev(iface);
Alan Stern36e56a32006-07-01 22:08:06 -0400368
369 /* this should never happen, don't release something that's not ours */
Alan Stern8bb54ab2006-07-01 22:08:49 -0400370 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
Alan Stern36e56a32006-07-01 22:08:06 -0400371 return;
372
373 /* don't release from within disconnect() */
374 if (iface->condition != USB_INTERFACE_BOUND)
375 return;
376
377 /* don't release if the interface hasn't been added yet */
378 if (device_is_registered(dev)) {
379 iface->condition = USB_INTERFACE_UNBINDING;
380 device_release_driver(dev);
381 }
382
383 dev->driver = NULL;
384 usb_set_intfdata(iface, NULL);
Alan Stern645daaa2006-08-30 15:47:02 -0400385
Alan Sterne0318eb2006-09-26 14:50:20 -0400386 usb_pm_lock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400387 iface->condition = USB_INTERFACE_UNBOUND;
388 mark_quiesced(iface);
Alan Stern645daaa2006-08-30 15:47:02 -0400389 iface->needs_remote_wakeup = 0;
Alan Sterne0318eb2006-09-26 14:50:20 -0400390 usb_pm_unlock(udev);
Alan Stern36e56a32006-07-01 22:08:06 -0400391}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600392EXPORT_SYMBOL_GPL(usb_driver_release_interface);
Alan Stern36e56a32006-07-01 22:08:06 -0400393
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800394/* returns 0 if no match, 1 if match */
Greg Kroah-Hartmanbb417022007-01-26 14:26:21 +0100395int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800396{
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800397 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
398 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
399 return 0;
400
401 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
402 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
403 return 0;
404
405 /* No need to test id->bcdDevice_lo != 0, since 0 is never
406 greater than any unsigned number. */
407 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
408 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
409 return 0;
410
411 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
412 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
413 return 0;
414
415 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
416 (id->bDeviceClass != dev->descriptor.bDeviceClass))
417 return 0;
418
419 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -0800420 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800421 return 0;
422
423 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
424 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
425 return 0;
426
Greg Kroah-Hartmanbb417022007-01-26 14:26:21 +0100427 return 1;
428}
429
430/* returns 0 if no match, 1 if match */
431int usb_match_one_id(struct usb_interface *interface,
432 const struct usb_device_id *id)
433{
434 struct usb_host_interface *intf;
435 struct usb_device *dev;
436
437 /* proc_connectinfo in devio.c may call us with id == NULL. */
438 if (id == NULL)
439 return 0;
440
441 intf = interface->cur_altsetting;
442 dev = interface_to_usbdev(interface);
443
444 if (!usb_match_device(dev, id))
445 return 0;
446
Alan Stern93c8bf42006-10-18 16:41:51 -0400447 /* The interface class, subclass, and protocol should never be
448 * checked for a match if the device class is Vendor Specific,
449 * unless the match record specifies the Vendor ID. */
450 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
451 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
452 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
453 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
454 USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
455 return 0;
456
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800457 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
458 (id->bInterfaceClass != intf->desc.bInterfaceClass))
459 return 0;
460
461 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
462 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
463 return 0;
464
465 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
466 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
467 return 0;
468
469 return 1;
470}
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100471EXPORT_SYMBOL_GPL(usb_match_one_id);
472
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800473/**
474 * usb_match_id - find first usb_device_id matching device or interface
475 * @interface: the interface of interest
476 * @id: array of usb_device_id structures, terminated by zero entry
477 *
478 * usb_match_id searches an array of usb_device_id's and returns
479 * the first one matching the device or interface, or null.
480 * This is used when binding (or rebinding) a driver to an interface.
481 * Most USB device drivers will use this indirectly, through the usb core,
482 * but some layered driver frameworks use it directly.
483 * These device tables are exported with MODULE_DEVICE_TABLE, through
484 * modutils, to support the driver loading functionality of USB hotplugging.
485 *
486 * What Matches:
487 *
488 * The "match_flags" element in a usb_device_id controls which
489 * members are used. If the corresponding bit is set, the
490 * value in the device_id must match its corresponding member
491 * in the device or interface descriptor, or else the device_id
492 * does not match.
493 *
494 * "driver_info" is normally used only by device drivers,
495 * but you can create a wildcard "matches anything" usb_device_id
496 * as a driver's "modules.usbmap" entry if you provide an id with
497 * only a nonzero "driver_info" field. If you do this, the USB device
498 * driver's probe() routine should use additional intelligence to
499 * decide whether to bind to the specified interface.
500 *
501 * What Makes Good usb_device_id Tables:
502 *
503 * The match algorithm is very simple, so that intelligence in
504 * driver selection must come from smart driver id records.
505 * Unless you have good reasons to use another selection policy,
506 * provide match elements only in related groups, and order match
507 * specifiers from specific to general. Use the macros provided
508 * for that purpose if you can.
509 *
510 * The most specific match specifiers use device descriptor
511 * data. These are commonly used with product-specific matches;
512 * the USB_DEVICE macro lets you provide vendor and product IDs,
513 * and you can also match against ranges of product revisions.
514 * These are widely used for devices with application or vendor
515 * specific bDeviceClass values.
516 *
517 * Matches based on device class/subclass/protocol specifications
518 * are slightly more general; use the USB_DEVICE_INFO macro, or
519 * its siblings. These are used with single-function devices
520 * where bDeviceClass doesn't specify that each interface has
521 * its own class.
522 *
523 * Matches based on interface class/subclass/protocol are the
524 * most general; they let drivers bind to any interface on a
525 * multiple-function device. Use the USB_INTERFACE_INFO
526 * macro, or its siblings, to match class-per-interface style
Alan Stern93c8bf42006-10-18 16:41:51 -0400527 * devices (as recorded in bInterfaceClass).
528 *
529 * Note that an entry created by USB_INTERFACE_INFO won't match
530 * any interface if the device class is set to Vendor-Specific.
531 * This is deliberate; according to the USB spec the meanings of
532 * the interface class/subclass/protocol for these devices are also
533 * vendor-specific, and hence matching against a standard product
534 * class wouldn't work anyway. If you really want to use an
535 * interface-based match for such a device, create a match record
536 * that also specifies the vendor ID. (Unforunately there isn't a
537 * standard macro for creating records like this.)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800538 *
539 * Within those groups, remember that not all combinations are
540 * meaningful. For example, don't give a product version range
541 * without vendor and product IDs; or specify a protocol without
542 * its associated class and subclass.
543 */
544const struct usb_device_id *usb_match_id(struct usb_interface *interface,
545 const struct usb_device_id *id)
546{
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800547 /* proc_connectinfo in devio.c may call us with id == NULL. */
548 if (id == NULL)
549 return NULL;
550
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800551 /* It is important to check that id->driver_info is nonzero,
552 since an entry that is all zeroes except for a nonzero
553 id->driver_info is the way to create an entry that
554 indicates that the driver want to examine every
555 device and interface. */
Greg Kroah-Hartmande6f92b2008-01-28 09:50:12 -0800556 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
557 id->bInterfaceClass || id->driver_info; id++) {
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800558 if (usb_match_one_id(interface, id))
559 return id;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800560 }
561
562 return NULL;
563}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600564EXPORT_SYMBOL_GPL(usb_match_id);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800565
Adrian Bunk8bb22d22006-11-21 22:02:54 +0100566static int usb_device_match(struct device *dev, struct device_driver *drv)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800567{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400568 /* devices and interfaces are handled separately */
569 if (is_usb_device(dev)) {
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800570
Alan Stern8bb54ab2006-07-01 22:08:49 -0400571 /* interface drivers never match devices */
572 if (!is_usb_device_driver(drv))
573 return 0;
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800574
Alan Stern8bb54ab2006-07-01 22:08:49 -0400575 /* TODO: Add real matching code */
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800576 return 1;
577
Alan Stern8bb54ab2006-07-01 22:08:49 -0400578 } else {
579 struct usb_interface *intf;
580 struct usb_driver *usb_drv;
581 const struct usb_device_id *id;
582
583 /* device drivers never match interfaces */
584 if (is_usb_device_driver(drv))
585 return 0;
586
587 intf = to_usb_interface(dev);
588 usb_drv = to_usb_driver(drv);
589
590 id = usb_match_id(intf, usb_drv->id_table);
591 if (id)
592 return 1;
593
594 id = usb_match_dynamic_id(intf, usb_drv);
595 if (id)
596 return 1;
597 }
598
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800599 return 0;
600}
601
Alan Stern36e56a32006-07-01 22:08:06 -0400602#ifdef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200603static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
Alan Stern36e56a32006-07-01 22:08:06 -0400604{
Alan Stern36e56a32006-07-01 22:08:06 -0400605 struct usb_device *usb_dev;
Alan Stern36e56a32006-07-01 22:08:06 -0400606
Alan Stern36e56a32006-07-01 22:08:06 -0400607 /* driver is often null here; dev_dbg() would oops */
Kay Sievers7071a3c2008-05-02 06:02:41 +0200608 pr_debug("usb %s: uevent\n", dev_name(dev));
Alan Stern36e56a32006-07-01 22:08:06 -0400609
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100610 if (is_usb_device(dev))
Alan Stern782da722006-07-01 22:09:35 -0400611 usb_dev = to_usb_device(dev);
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100612 else {
613 struct usb_interface *intf = to_usb_interface(dev);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400614 usb_dev = interface_to_usbdev(intf);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400615 }
Alan Stern36e56a32006-07-01 22:08:06 -0400616
617 if (usb_dev->devnum < 0) {
Kay Sievers7071a3c2008-05-02 06:02:41 +0200618 pr_debug("usb %s: already deleted?\n", dev_name(dev));
Alan Stern36e56a32006-07-01 22:08:06 -0400619 return -ENODEV;
620 }
621 if (!usb_dev->bus) {
Kay Sievers7071a3c2008-05-02 06:02:41 +0200622 pr_debug("usb %s: bus removed?\n", dev_name(dev));
Alan Stern36e56a32006-07-01 22:08:06 -0400623 return -ENODEV;
624 }
625
626#ifdef CONFIG_USB_DEVICEFS
627 /* If this is available, userspace programs can directly read
628 * all the device descriptors we don't tell them about. Or
Kay Sievers9f8b17e2007-03-13 15:59:31 +0100629 * act as usermode drivers.
Alan Stern36e56a32006-07-01 22:08:06 -0400630 */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200631 if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
Alan Stern36e56a32006-07-01 22:08:06 -0400632 usb_dev->bus->busnum, usb_dev->devnum))
633 return -ENOMEM;
634#endif
635
636 /* per-device configurations are common */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200637 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
Alan Stern36e56a32006-07-01 22:08:06 -0400638 le16_to_cpu(usb_dev->descriptor.idVendor),
639 le16_to_cpu(usb_dev->descriptor.idProduct),
640 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
641 return -ENOMEM;
642
643 /* class-based driver binding models */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200644 if (add_uevent_var(env, "TYPE=%d/%d/%d",
Alan Stern36e56a32006-07-01 22:08:06 -0400645 usb_dev->descriptor.bDeviceClass,
646 usb_dev->descriptor.bDeviceSubClass,
647 usb_dev->descriptor.bDeviceProtocol))
648 return -ENOMEM;
649
Alan Stern36e56a32006-07-01 22:08:06 -0400650 return 0;
651}
652
653#else
654
Kay Sievers7eff2e72007-08-14 15:15:12 +0200655static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
Alan Stern36e56a32006-07-01 22:08:06 -0400656{
657 return -ENODEV;
658}
Alan Stern36e56a32006-07-01 22:08:06 -0400659#endif /* CONFIG_HOTPLUG */
660
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800661/**
Alan Stern8bb54ab2006-07-01 22:08:49 -0400662 * usb_register_device_driver - register a USB device (not interface) driver
663 * @new_udriver: USB operations for the device driver
Greg Kroah-Hartman2143acc2005-11-21 14:53:03 -0800664 * @owner: module owner of this driver.
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800665 *
Alan Stern8bb54ab2006-07-01 22:08:49 -0400666 * Registers a USB device driver with the USB core. The list of
667 * unattached devices will be rescanned whenever a new driver is
668 * added, allowing the new driver to attach to any recognized devices.
669 * Returns a negative error code on failure and 0 on success.
670 */
671int usb_register_device_driver(struct usb_device_driver *new_udriver,
672 struct module *owner)
673{
674 int retval = 0;
675
676 if (usb_disabled())
677 return -ENODEV;
678
679 new_udriver->drvwrap.for_devices = 1;
680 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
681 new_udriver->drvwrap.driver.bus = &usb_bus_type;
682 new_udriver->drvwrap.driver.probe = usb_probe_device;
683 new_udriver->drvwrap.driver.remove = usb_unbind_device;
684 new_udriver->drvwrap.driver.owner = owner;
685
686 retval = driver_register(&new_udriver->drvwrap.driver);
687
688 if (!retval) {
689 pr_info("%s: registered new device driver %s\n",
690 usbcore_name, new_udriver->name);
691 usbfs_update_special();
692 } else {
693 printk(KERN_ERR "%s: error %d registering device "
694 " driver %s\n",
695 usbcore_name, retval, new_udriver->name);
696 }
697
698 return retval;
699}
700EXPORT_SYMBOL_GPL(usb_register_device_driver);
701
702/**
703 * usb_deregister_device_driver - unregister a USB device (not interface) driver
704 * @udriver: USB operations of the device driver to unregister
705 * Context: must be able to sleep
706 *
707 * Unlinks the specified driver from the internal USB driver list.
708 */
709void usb_deregister_device_driver(struct usb_device_driver *udriver)
710{
711 pr_info("%s: deregistering device driver %s\n",
712 usbcore_name, udriver->name);
713
714 driver_unregister(&udriver->drvwrap.driver);
715 usbfs_update_special();
716}
717EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
718
719/**
720 * usb_register_driver - register a USB interface driver
721 * @new_driver: USB operations for the interface driver
722 * @owner: module owner of this driver.
Randy Dunlap892705a2007-02-10 14:41:41 -0800723 * @mod_name: module name string
Alan Stern8bb54ab2006-07-01 22:08:49 -0400724 *
725 * Registers a USB interface driver with the USB core. The list of
726 * unattached interfaces will be rescanned whenever a new driver is
727 * added, allowing the new driver to attach to any recognized interfaces.
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800728 * Returns a negative error code on failure and 0 on success.
729 *
730 * NOTE: if you want your driver to use the USB major number, you must call
731 * usb_register_dev() to enable that functionality. This function no longer
732 * takes care of that.
733 */
Greg Kroah-Hartman80f745f2007-01-15 11:50:02 -0800734int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
735 const char *mod_name)
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800736{
737 int retval = 0;
738
739 if (usb_disabled())
740 return -ENODEV;
741
Alan Stern8bb54ab2006-07-01 22:08:49 -0400742 new_driver->drvwrap.for_devices = 0;
743 new_driver->drvwrap.driver.name = (char *) new_driver->name;
744 new_driver->drvwrap.driver.bus = &usb_bus_type;
745 new_driver->drvwrap.driver.probe = usb_probe_interface;
746 new_driver->drvwrap.driver.remove = usb_unbind_interface;
747 new_driver->drvwrap.driver.owner = owner;
Greg Kroah-Hartman80f745f2007-01-15 11:50:02 -0800748 new_driver->drvwrap.driver.mod_name = mod_name;
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800749 spin_lock_init(&new_driver->dynids.lock);
750 INIT_LIST_HEAD(&new_driver->dynids.list);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800751
Alan Stern8bb54ab2006-07-01 22:08:49 -0400752 retval = driver_register(&new_driver->drvwrap.driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800753
754 if (!retval) {
Alan Stern8bb54ab2006-07-01 22:08:49 -0400755 pr_info("%s: registered new interface driver %s\n",
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800756 usbcore_name, new_driver->name);
757 usbfs_update_special();
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800758 usb_create_newid_file(new_driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800759 } else {
Alan Stern8bb54ab2006-07-01 22:08:49 -0400760 printk(KERN_ERR "%s: error %d registering interface "
761 " driver %s\n",
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800762 usbcore_name, retval, new_driver->name);
763 }
764
765 return retval;
766}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600767EXPORT_SYMBOL_GPL(usb_register_driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800768
769/**
Alan Stern8bb54ab2006-07-01 22:08:49 -0400770 * usb_deregister - unregister a USB interface driver
771 * @driver: USB operations of the interface driver to unregister
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800772 * Context: must be able to sleep
773 *
774 * Unlinks the specified driver from the internal USB driver list.
775 *
776 * NOTE: If you called usb_register_dev(), you still need to call
777 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
778 * this * call will no longer do it for you.
779 */
780void usb_deregister(struct usb_driver *driver)
781{
Alan Stern8bb54ab2006-07-01 22:08:49 -0400782 pr_info("%s: deregistering interface driver %s\n",
783 usbcore_name, driver->name);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800784
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800785 usb_remove_newid_file(driver);
Greg Kroah-Hartman733260f2005-11-16 13:41:28 -0800786 usb_free_dynids(driver);
Alan Stern8bb54ab2006-07-01 22:08:49 -0400787 driver_unregister(&driver->drvwrap.driver);
Greg Kroah-Hartmanddae41b2005-11-16 13:41:28 -0800788
789 usbfs_update_special();
790}
Greg Kroah-Hartman782e70c2008-01-25 11:12:21 -0600791EXPORT_SYMBOL_GPL(usb_deregister);
Alan Stern36e56a32006-07-01 22:08:06 -0400792
Alan Stern78d9a482008-06-23 16:00:40 -0400793/* Forced unbinding of a USB interface driver, either because
794 * it doesn't support pre_reset/post_reset/reset_resume or
795 * because it doesn't support suspend/resume.
796 *
797 * The caller must hold @intf's device's lock, but not its pm_mutex
798 * and not @intf->dev.sem.
799 */
800void usb_forced_unbind_intf(struct usb_interface *intf)
801{
802 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
803
804 dev_dbg(&intf->dev, "forced unbind\n");
805 usb_driver_release_interface(driver, intf);
806
807 /* Mark the interface for later rebinding */
808 intf->needs_binding = 1;
809}
810
811/* Delayed forced unbinding of a USB interface driver and scan
812 * for rebinding.
813 *
814 * The caller must hold @intf's device's lock, but not its pm_mutex
815 * and not @intf->dev.sem.
816 *
Alan Stern5096aed2008-08-12 14:34:14 -0400817 * Note: Rebinds will be skipped if a system sleep transition is in
818 * progress and the PM "complete" callback hasn't occurred yet.
Alan Stern78d9a482008-06-23 16:00:40 -0400819 */
820void usb_rebind_intf(struct usb_interface *intf)
821{
822 int rc;
823
824 /* Delayed unbind of an existing driver */
825 if (intf->dev.driver) {
826 struct usb_driver *driver =
827 to_usb_driver(intf->dev.driver);
828
829 dev_dbg(&intf->dev, "forced unbind\n");
830 usb_driver_release_interface(driver, intf);
831 }
832
833 /* Try to rebind the interface */
Alan Stern5096aed2008-08-12 14:34:14 -0400834 if (intf->dev.power.status == DPM_ON) {
835 intf->needs_binding = 0;
836 rc = device_attach(&intf->dev);
837 if (rc < 0)
838 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
839 }
Alan Stern78d9a482008-06-23 16:00:40 -0400840}
841
Alan Stern9ff78432008-08-07 13:04:51 -0400842#ifdef CONFIG_PM
843
Alan Stern78d9a482008-06-23 16:00:40 -0400844#define DO_UNBIND 0
845#define DO_REBIND 1
846
847/* Unbind drivers for @udev's interfaces that don't support suspend/resume,
848 * or rebind interfaces that have been unbound, according to @action.
849 *
850 * The caller must hold @udev's device lock.
Alan Stern78d9a482008-06-23 16:00:40 -0400851 */
852static void do_unbind_rebind(struct usb_device *udev, int action)
853{
854 struct usb_host_config *config;
855 int i;
856 struct usb_interface *intf;
857 struct usb_driver *drv;
858
859 config = udev->actconfig;
860 if (config) {
861 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
862 intf = config->interface[i];
863 switch (action) {
864 case DO_UNBIND:
865 if (intf->dev.driver) {
866 drv = to_usb_driver(intf->dev.driver);
867 if (!drv->suspend || !drv->resume)
868 usb_forced_unbind_intf(intf);
869 }
870 break;
871 case DO_REBIND:
Alan Stern5096aed2008-08-12 14:34:14 -0400872 if (intf->needs_binding)
Alan Stern78d9a482008-06-23 16:00:40 -0400873 usb_rebind_intf(intf);
Alan Stern78d9a482008-06-23 16:00:40 -0400874 break;
875 }
876 }
877 }
878}
879
Alan Sterne0318eb2006-09-26 14:50:20 -0400880/* Caller has locked udev's pm_mutex */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -0800881static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
Alan Stern36e56a32006-07-01 22:08:06 -0400882{
Alan Stern782da722006-07-01 22:09:35 -0400883 struct usb_device_driver *udriver;
Alan Stern2bf40862006-07-01 22:12:19 -0400884 int status = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400885
Alan Stern114b3682006-07-01 22:13:04 -0400886 if (udev->state == USB_STATE_NOTATTACHED ||
887 udev->state == USB_STATE_SUSPENDED)
888 goto done;
889
Alan Sternb6f6436d2007-05-04 11:51:54 -0400890 /* For devices that don't have a driver, we do a generic suspend. */
891 if (udev->dev.driver)
892 udriver = to_usb_device_driver(udev->dev.driver);
893 else {
Alan Stern645daaa2006-08-30 15:47:02 -0400894 udev->do_remote_wakeup = 0;
Alan Sternb6f6436d2007-05-04 11:51:54 -0400895 udriver = &usb_generic_driver;
Alan Stern1c5df7e2006-07-01 22:13:50 -0400896 }
Alan Stern2bf40862006-07-01 22:12:19 -0400897 status = udriver->suspend(udev, msg);
898
Alan Stern20dfdad2007-05-22 11:50:17 -0400899 done:
Harvey Harrison441b62c2008-03-03 16:08:34 -0800900 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
Alan Stern2bf40862006-07-01 22:12:19 -0400901 return status;
Alan Stern1cc8a252006-07-01 22:10:15 -0400902}
Alan Stern36e56a32006-07-01 22:08:06 -0400903
Alan Sterne0318eb2006-09-26 14:50:20 -0400904/* Caller has locked udev's pm_mutex */
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -0800905static int usb_resume_device(struct usb_device *udev)
Alan Stern1cc8a252006-07-01 22:10:15 -0400906{
907 struct usb_device_driver *udriver;
Alan Stern2bf40862006-07-01 22:12:19 -0400908 int status = 0;
Alan Stern1cc8a252006-07-01 22:10:15 -0400909
Alan Stern0458d5b2007-05-04 11:52:20 -0400910 if (udev->state == USB_STATE_NOTATTACHED)
911 goto done;
Alan Stern1cc8a252006-07-01 22:10:15 -0400912
Alan Stern1c5df7e2006-07-01 22:13:50 -0400913 /* Can't resume it if it doesn't have a driver. */
914 if (udev->dev.driver == NULL) {
915 status = -ENOTCONN;
Alan Stern2bf40862006-07-01 22:12:19 -0400916 goto done;
Alan Stern1c5df7e2006-07-01 22:13:50 -0400917 }
918
Alan Stern6bc6cff2007-05-04 11:53:03 -0400919 if (udev->quirks & USB_QUIRK_RESET_RESUME)
920 udev->reset_resume = 1;
921
Alan Stern1cc8a252006-07-01 22:10:15 -0400922 udriver = to_usb_device_driver(udev->dev.driver);
Alan Stern2bf40862006-07-01 22:12:19 -0400923 status = udriver->resume(udev);
924
Alan Stern20dfdad2007-05-22 11:50:17 -0400925 done:
Harvey Harrison441b62c2008-03-03 16:08:34 -0800926 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
Alan Stern70a1c9e2008-03-06 17:00:58 -0500927 if (status == 0)
Alan Stern2add5222007-03-20 14:59:39 -0400928 udev->autoresume_disabled = 0;
Alan Stern2bf40862006-07-01 22:12:19 -0400929 return status;
Alan Stern1cc8a252006-07-01 22:10:15 -0400930}
931
Alan Sterne0318eb2006-09-26 14:50:20 -0400932/* Caller has locked intf's usb_device's pm mutex */
Alan Stern65605ae2008-08-12 14:33:27 -0400933static int usb_suspend_interface(struct usb_device *udev,
934 struct usb_interface *intf, pm_message_t msg)
Alan Stern1cc8a252006-07-01 22:10:15 -0400935{
936 struct usb_driver *driver;
Alan Stern2bf40862006-07-01 22:12:19 -0400937 int status = 0;
Alan Stern1cc8a252006-07-01 22:10:15 -0400938
Alan Stern114b3682006-07-01 22:13:04 -0400939 /* with no hardware, USB interfaces only use FREEZE and ON states */
Alan Stern65605ae2008-08-12 14:33:27 -0400940 if (udev->state == USB_STATE_NOTATTACHED || !is_active(intf))
Alan Stern114b3682006-07-01 22:13:04 -0400941 goto done;
942
Alan Stern645daaa2006-08-30 15:47:02 -0400943 if (intf->condition == USB_INTERFACE_UNBOUND) /* This can't happen */
Alan Stern2bf40862006-07-01 22:12:19 -0400944 goto done;
Alan Stern1cc8a252006-07-01 22:10:15 -0400945 driver = to_usb_driver(intf->dev.driver);
Alan Stern36e56a32006-07-01 22:08:06 -0400946
Alan Stern78d9a482008-06-23 16:00:40 -0400947 if (driver->suspend) {
Alan Stern1cc8a252006-07-01 22:10:15 -0400948 status = driver->suspend(intf, msg);
Alan Stern645daaa2006-08-30 15:47:02 -0400949 if (status == 0)
950 mark_quiesced(intf);
Alan Stern65605ae2008-08-12 14:33:27 -0400951 else if (!udev->auto_pm)
Alan Stern1cc8a252006-07-01 22:10:15 -0400952 dev_err(&intf->dev, "%s error %d\n",
953 "suspend", status);
Alan Stern36e56a32006-07-01 22:08:06 -0400954 } else {
Alan Stern78d9a482008-06-23 16:00:40 -0400955 /* Later we will unbind the driver and reprobe */
956 intf->needs_binding = 1;
957 dev_warn(&intf->dev, "no %s for driver %s?\n",
958 "suspend", driver->name);
Alan Stern36e56a32006-07-01 22:08:06 -0400959 mark_quiesced(intf);
Alan Stern36e56a32006-07-01 22:08:06 -0400960 }
Alan Stern2bf40862006-07-01 22:12:19 -0400961
Alan Stern20dfdad2007-05-22 11:50:17 -0400962 done:
Harvey Harrison441b62c2008-03-03 16:08:34 -0800963 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
Alan Stern36e56a32006-07-01 22:08:06 -0400964 return status;
965}
966
Alan Stern645daaa2006-08-30 15:47:02 -0400967/* Caller has locked intf's usb_device's pm_mutex */
Alan Stern65605ae2008-08-12 14:33:27 -0400968static int usb_resume_interface(struct usb_device *udev,
969 struct usb_interface *intf, int reset_resume)
Alan Stern36e56a32006-07-01 22:08:06 -0400970{
Alan Stern1cc8a252006-07-01 22:10:15 -0400971 struct usb_driver *driver;
Alan Stern2bf40862006-07-01 22:12:19 -0400972 int status = 0;
Alan Stern36e56a32006-07-01 22:08:06 -0400973
Alan Stern65605ae2008-08-12 14:33:27 -0400974 if (udev->state == USB_STATE_NOTATTACHED || is_active(intf))
Alan Stern2bf40862006-07-01 22:12:19 -0400975 goto done;
Alan Stern36e56a32006-07-01 22:08:06 -0400976
Alan Stern645daaa2006-08-30 15:47:02 -0400977 /* Don't let autoresume interfere with unbinding */
978 if (intf->condition == USB_INTERFACE_UNBINDING)
979 goto done;
980
Alan Stern1c5df7e2006-07-01 22:13:50 -0400981 /* Can't resume it if it doesn't have a driver. */
Alan Stern55151d72008-08-12 14:33:59 -0400982 if (intf->condition == USB_INTERFACE_UNBOUND) {
983
984 /* Carry out a deferred switch to altsetting 0 */
985 if (intf->needs_altsetting0 &&
986 intf->dev.power.status == DPM_ON) {
987 usb_set_interface(udev, intf->altsetting[0].
988 desc.bInterfaceNumber, 0);
989 intf->needs_altsetting0 = 0;
990 }
Alan Stern2bf40862006-07-01 22:12:19 -0400991 goto done;
Alan Stern55151d72008-08-12 14:33:59 -0400992 }
Alan Stern78d9a482008-06-23 16:00:40 -0400993
994 /* Don't resume if the interface is marked for rebinding */
995 if (intf->needs_binding)
996 goto done;
Alan Stern1cc8a252006-07-01 22:10:15 -0400997 driver = to_usb_driver(intf->dev.driver);
Alan Stern36e56a32006-07-01 22:08:06 -0400998
Alan Sternf07600c2007-05-30 15:38:16 -0400999 if (reset_resume) {
1000 if (driver->reset_resume) {
1001 status = driver->reset_resume(intf);
1002 if (status)
1003 dev_err(&intf->dev, "%s error %d\n",
1004 "reset_resume", status);
1005 } else {
Alan Stern78d9a482008-06-23 16:00:40 -04001006 intf->needs_binding = 1;
Alan Sternf07600c2007-05-30 15:38:16 -04001007 dev_warn(&intf->dev, "no %s for driver %s?\n",
1008 "reset_resume", driver->name);
1009 }
1010 } else {
1011 if (driver->resume) {
1012 status = driver->resume(intf);
1013 if (status)
1014 dev_err(&intf->dev, "%s error %d\n",
1015 "resume", status);
1016 } else {
Alan Stern78d9a482008-06-23 16:00:40 -04001017 intf->needs_binding = 1;
Alan Sternf07600c2007-05-30 15:38:16 -04001018 dev_warn(&intf->dev, "no %s for driver %s?\n",
1019 "resume", driver->name);
1020 }
1021 }
Alan Stern2bf40862006-07-01 22:12:19 -04001022
1023done:
Harvey Harrison441b62c2008-03-03 16:08:34 -08001024 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
Alan Stern78d9a482008-06-23 16:00:40 -04001025 if (status == 0 && intf->condition == USB_INTERFACE_BOUND)
Alan Stern0458d5b2007-05-04 11:52:20 -04001026 mark_active(intf);
Alan Sternf07600c2007-05-30 15:38:16 -04001027
Alan Stern78d9a482008-06-23 16:00:40 -04001028 /* Later we will unbind the driver and/or reprobe, if necessary */
Alan Stern2bf40862006-07-01 22:12:19 -04001029 return status;
Alan Stern36e56a32006-07-01 22:08:06 -04001030}
1031
Alan Stern94fcda12006-11-20 11:38:46 -05001032#ifdef CONFIG_USB_SUSPEND
1033
Alan Sternaf4f7602006-10-30 17:06:45 -05001034/* Internal routine to check whether we may autosuspend a device. */
Alan Sternd1aa3e62007-10-11 16:47:36 -04001035static int autosuspend_check(struct usb_device *udev, int reschedule)
Alan Sternaf4f7602006-10-30 17:06:45 -05001036{
1037 int i;
1038 struct usb_interface *intf;
Alan Sternd1aa3e62007-10-11 16:47:36 -04001039 unsigned long suspend_time, j;
Alan Sternaf4f7602006-10-30 17:06:45 -05001040
Alan Sternb5e795f2007-02-20 15:00:53 -05001041 /* For autosuspend, fail fast if anything is in use or autosuspend
1042 * is disabled. Also fail if any interfaces require remote wakeup
1043 * but it isn't available.
1044 */
Alan Sternaf4f7602006-10-30 17:06:45 -05001045 if (udev->pm_usage_cnt > 0)
1046 return -EBUSY;
Alan Stern2add5222007-03-20 14:59:39 -04001047 if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
Alan Sternb5e795f2007-02-20 15:00:53 -05001048 return -EPERM;
1049
Alan Stern19410442007-03-27 13:33:59 -04001050 suspend_time = udev->last_busy + udev->autosuspend_delay;
Alan Sternaf4f7602006-10-30 17:06:45 -05001051 if (udev->actconfig) {
1052 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1053 intf = udev->actconfig->interface[i];
1054 if (!is_active(intf))
1055 continue;
1056 if (intf->pm_usage_cnt > 0)
1057 return -EBUSY;
1058 if (intf->needs_remote_wakeup &&
1059 !udev->do_remote_wakeup) {
1060 dev_dbg(&udev->dev, "remote wakeup needed "
1061 "for autosuspend\n");
1062 return -EOPNOTSUPP;
1063 }
Alan Sternf07600c2007-05-30 15:38:16 -04001064
1065 /* Don't allow autosuspend if the device will need
1066 * a reset-resume and any of its interface drivers
1067 * doesn't include support.
1068 */
1069 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1070 struct usb_driver *driver;
1071
1072 driver = to_usb_driver(intf->dev.driver);
1073 if (!driver->reset_resume)
1074 return -EOPNOTSUPP;
1075 }
Alan Sternaf4f7602006-10-30 17:06:45 -05001076 }
1077 }
Alan Stern19410442007-03-27 13:33:59 -04001078
1079 /* If everything is okay but the device hasn't been idle for long
Alan Sternd1aa3e62007-10-11 16:47:36 -04001080 * enough, queue a delayed autosuspend request. If the device
1081 * _has_ been idle for long enough and the reschedule flag is set,
1082 * likewise queue a delayed (1 second) autosuspend request.
Alan Stern19410442007-03-27 13:33:59 -04001083 */
Alan Sternd1aa3e62007-10-11 16:47:36 -04001084 j = jiffies;
1085 if (time_before(j, suspend_time))
1086 reschedule = 1;
1087 else
1088 suspend_time = j + HZ;
1089 if (reschedule) {
Alan Stern8c9862e2007-04-11 12:06:16 -04001090 if (!timer_pending(&udev->autosuspend.timer)) {
Alan Stern19410442007-03-27 13:33:59 -04001091 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
Alan Sternd1aa3e62007-10-11 16:47:36 -04001092 round_jiffies_relative(suspend_time - j));
1093 }
Alan Stern19410442007-03-27 13:33:59 -04001094 return -EAGAIN;
1095 }
Alan Sternaf4f7602006-10-30 17:06:45 -05001096 return 0;
1097}
1098
Alan Stern94fcda12006-11-20 11:38:46 -05001099#else
1100
Alan Sternd1aa3e62007-10-11 16:47:36 -04001101static inline int autosuspend_check(struct usb_device *udev, int reschedule)
Alan Sternef7f6c72007-04-05 16:03:49 -04001102{
1103 return 0;
1104}
Alan Stern94fcda12006-11-20 11:38:46 -05001105
Alan Sternb5e795f2007-02-20 15:00:53 -05001106#endif /* CONFIG_USB_SUSPEND */
Alan Stern94fcda12006-11-20 11:38:46 -05001107
Alan Stern645daaa2006-08-30 15:47:02 -04001108/**
1109 * usb_suspend_both - suspend a USB device and its interfaces
1110 * @udev: the usb_device to suspend
1111 * @msg: Power Management message describing this state transition
1112 *
1113 * This is the central routine for suspending USB devices. It calls the
1114 * suspend methods for all the interface drivers in @udev and then calls
1115 * the suspend method for @udev itself. If an error occurs at any stage,
1116 * all the interfaces which were suspended are resumed so that they remain
1117 * in the same state as the device.
1118 *
1119 * If an autosuspend is in progress (@udev->auto_pm is set), the routine
1120 * checks first to make sure that neither the device itself or any of its
1121 * active interfaces is in use (pm_usage_cnt is greater than 0). If they
1122 * are, the autosuspend fails.
1123 *
1124 * If the suspend succeeds, the routine recursively queues an autosuspend
1125 * request for @udev's parent device, thereby propagating the change up
1126 * the device tree. If all of the parent's children are now suspended,
1127 * the parent will autosuspend in turn.
1128 *
1129 * The suspend method calls are subject to mutual exclusion under control
1130 * of @udev's pm_mutex. Many of these calls are also under the protection
1131 * of @udev's device lock (including all requests originating outside the
1132 * USB subsystem), but autosuspend requests generated by a child device or
1133 * interface driver may not be. Usbcore will insure that the method calls
1134 * do not arrive during bind, unbind, or reset operations. However, drivers
1135 * must be prepared to handle suspend calls arriving at unpredictable times.
1136 * The only way to block such calls is to do an autoresume (preventing
1137 * autosuspends) while holding @udev's device lock (preventing outside
1138 * suspends).
1139 *
1140 * The caller must hold @udev->pm_mutex.
1141 *
1142 * This routine can run only in process context.
1143 */
Alan Stern718efa62007-03-09 15:41:13 -05001144static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
Alan Sterna8e7c562006-07-01 22:11:02 -04001145{
1146 int status = 0;
1147 int i = 0;
1148 struct usb_interface *intf;
Alan Stern645daaa2006-08-30 15:47:02 -04001149 struct usb_device *parent = udev->parent;
Alan Sterna8e7c562006-07-01 22:11:02 -04001150
Alan Stern19410442007-03-27 13:33:59 -04001151 if (udev->state == USB_STATE_NOTATTACHED ||
1152 udev->state == USB_STATE_SUSPENDED)
1153 goto done;
Alan Stern645daaa2006-08-30 15:47:02 -04001154
1155 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
1156
Alan Stern645daaa2006-08-30 15:47:02 -04001157 if (udev->auto_pm) {
Alan Sternd1aa3e62007-10-11 16:47:36 -04001158 status = autosuspend_check(udev, 0);
Alan Sternaf4f7602006-10-30 17:06:45 -05001159 if (status < 0)
Alan Stern19410442007-03-27 13:33:59 -04001160 goto done;
Alan Stern645daaa2006-08-30 15:47:02 -04001161 }
1162
1163 /* Suspend all the interfaces and then udev itself */
Alan Sterna8e7c562006-07-01 22:11:02 -04001164 if (udev->actconfig) {
1165 for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
1166 intf = udev->actconfig->interface[i];
Alan Stern65605ae2008-08-12 14:33:27 -04001167 status = usb_suspend_interface(udev, intf, msg);
Alan Sterna8e7c562006-07-01 22:11:02 -04001168 if (status != 0)
1169 break;
1170 }
1171 }
Alan Stern5ad4f712007-09-10 11:31:43 -04001172 if (status == 0)
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -08001173 status = usb_suspend_device(udev, msg);
Alan Sterna8e7c562006-07-01 22:11:02 -04001174
1175 /* If the suspend failed, resume interfaces that did get suspended */
1176 if (status != 0) {
1177 while (--i >= 0) {
1178 intf = udev->actconfig->interface[i];
Alan Stern65605ae2008-08-12 14:33:27 -04001179 usb_resume_interface(udev, intf, 0);
Alan Sterna8e7c562006-07-01 22:11:02 -04001180 }
Alan Stern645daaa2006-08-30 15:47:02 -04001181
Alan Sternef7f6c72007-04-05 16:03:49 -04001182 /* Try another autosuspend when the interfaces aren't busy */
1183 if (udev->auto_pm)
Alan Sternd1aa3e62007-10-11 16:47:36 -04001184 autosuspend_check(udev, status == -EBUSY);
Alan Sternef7f6c72007-04-05 16:03:49 -04001185
Alan Stern6840d252007-09-10 11:34:26 -04001186 /* If the suspend succeeded then prevent any more URB submissions,
1187 * flush any outstanding URBs, and propagate the suspend up the tree.
1188 */
Alan Sternef7f6c72007-04-05 16:03:49 -04001189 } else {
1190 cancel_delayed_work(&udev->autosuspend);
Alan Stern6840d252007-09-10 11:34:26 -04001191 udev->can_submit = 0;
1192 for (i = 0; i < 16; ++i) {
1193 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1194 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1195 }
Alan Stern7108f282007-09-20 12:37:50 -04001196
1197 /* If this is just a FREEZE or a PRETHAW, udev might
1198 * not really be suspended. Only true suspends get
1199 * propagated up the device tree.
1200 */
1201 if (parent && udev->state == USB_STATE_SUSPENDED)
Alan Sternef7f6c72007-04-05 16:03:49 -04001202 usb_autosuspend_device(parent);
1203 }
Alan Stern645daaa2006-08-30 15:47:02 -04001204
Alan Stern19410442007-03-27 13:33:59 -04001205 done:
Harvey Harrison441b62c2008-03-03 16:08:34 -08001206 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
Alan Sterna8e7c562006-07-01 22:11:02 -04001207 return status;
1208}
1209
Alan Stern645daaa2006-08-30 15:47:02 -04001210/**
1211 * usb_resume_both - resume a USB device and its interfaces
1212 * @udev: the usb_device to resume
1213 *
1214 * This is the central routine for resuming USB devices. It calls the
1215 * the resume method for @udev and then calls the resume methods for all
1216 * the interface drivers in @udev.
1217 *
1218 * Before starting the resume, the routine calls itself recursively for
1219 * the parent device of @udev, thereby propagating the change up the device
1220 * tree and assuring that @udev will be able to resume. If the parent is
1221 * unable to resume successfully, the routine fails.
1222 *
1223 * The resume method calls are subject to mutual exclusion under control
1224 * of @udev's pm_mutex. Many of these calls are also under the protection
1225 * of @udev's device lock (including all requests originating outside the
1226 * USB subsystem), but autoresume requests generated by a child device or
1227 * interface driver may not be. Usbcore will insure that the method calls
1228 * do not arrive during bind, unbind, or reset operations. However, drivers
1229 * must be prepared to handle resume calls arriving at unpredictable times.
1230 * The only way to block such calls is to do an autoresume (preventing
1231 * other autoresumes) while holding @udev's device lock (preventing outside
1232 * resumes).
1233 *
1234 * The caller must hold @udev->pm_mutex.
1235 *
1236 * This routine can run only in process context.
1237 */
Alan Stern718efa62007-03-09 15:41:13 -05001238static int usb_resume_both(struct usb_device *udev)
Alan Sterna8e7c562006-07-01 22:11:02 -04001239{
Alan Stern645daaa2006-08-30 15:47:02 -04001240 int status = 0;
Alan Sterna8e7c562006-07-01 22:11:02 -04001241 int i;
1242 struct usb_interface *intf;
Alan Stern645daaa2006-08-30 15:47:02 -04001243 struct usb_device *parent = udev->parent;
Alan Sterna8e7c562006-07-01 22:11:02 -04001244
Alan Stern645daaa2006-08-30 15:47:02 -04001245 cancel_delayed_work(&udev->autosuspend);
Alan Stern19410442007-03-27 13:33:59 -04001246 if (udev->state == USB_STATE_NOTATTACHED) {
1247 status = -ENODEV;
1248 goto done;
1249 }
Alan Stern6840d252007-09-10 11:34:26 -04001250 udev->can_submit = 1;
Alan Stern645daaa2006-08-30 15:47:02 -04001251
1252 /* Propagate the resume up the tree, if necessary */
1253 if (udev->state == USB_STATE_SUSPENDED) {
Alan Stern19410442007-03-27 13:33:59 -04001254 if (udev->auto_pm && udev->autoresume_disabled) {
1255 status = -EPERM;
1256 goto done;
1257 }
Alan Stern645daaa2006-08-30 15:47:02 -04001258 if (parent) {
Alan Stern94fcda12006-11-20 11:38:46 -05001259 status = usb_autoresume_device(parent);
Alan Sternee49fb52006-11-22 16:55:54 -05001260 if (status == 0) {
1261 status = usb_resume_device(udev);
Alan Sternf07600c2007-05-30 15:38:16 -04001262 if (status || udev->state ==
1263 USB_STATE_NOTATTACHED) {
Alan Stern94fcda12006-11-20 11:38:46 -05001264 usb_autosuspend_device(parent);
Alan Sternee49fb52006-11-22 16:55:54 -05001265
1266 /* It's possible usb_resume_device()
1267 * failed after the port was
1268 * unsuspended, causing udev to be
1269 * logically disconnected. We don't
1270 * want usb_disconnect() to autosuspend
1271 * the parent again, so tell it that
1272 * udev disconnected while still
1273 * suspended. */
1274 if (udev->state ==
1275 USB_STATE_NOTATTACHED)
1276 udev->discon_suspended = 1;
1277 }
1278 }
Alan Stern645daaa2006-08-30 15:47:02 -04001279 } else {
1280
1281 /* We can't progagate beyond the USB subsystem,
1282 * so if a root hub's controller is suspended
1283 * then we're stuck. */
Alan Sterne7e6da92007-06-21 16:25:17 -04001284 status = usb_resume_device(udev);
Greg Kroah-Hartman2c044a42008-01-30 15:21:33 -08001285 }
Alan Stern6ee0b272008-04-28 11:06:42 -04001286 } else if (udev->reset_resume)
Stephen Hemmingerd5ec1682006-11-14 10:06:17 -08001287 status = usb_resume_device(udev);
Alan Stern114b3682006-07-01 22:13:04 -04001288
Alan Sterna8e7c562006-07-01 22:11:02 -04001289 if (status == 0 && udev->actconfig) {
1290 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1291 intf = udev->actconfig->interface[i];
Alan Stern65605ae2008-08-12 14:33:27 -04001292 usb_resume_interface(udev, intf, udev->reset_resume);
Alan Sterna8e7c562006-07-01 22:11:02 -04001293 }
1294 }
Alan Stern645daaa2006-08-30 15:47:02 -04001295
Alan Stern19410442007-03-27 13:33:59 -04001296 done:
Harvey Harrison441b62c2008-03-03 16:08:34 -08001297 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
Alan Stern70a1c9e2008-03-06 17:00:58 -05001298 if (!status)
1299 udev->reset_resume = 0;
Alan Sterna8e7c562006-07-01 22:11:02 -04001300 return status;
1301}
1302
Alan Stern645daaa2006-08-30 15:47:02 -04001303#ifdef CONFIG_USB_SUSPEND
1304
Alan Stern94fcda12006-11-20 11:38:46 -05001305/* Internal routine to adjust a device's usage counter and change
1306 * its autosuspend state.
1307 */
1308static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
1309{
1310 int status = 0;
1311
1312 usb_pm_lock(udev);
Alan Stern19410442007-03-27 13:33:59 -04001313 udev->auto_pm = 1;
Alan Stern94fcda12006-11-20 11:38:46 -05001314 udev->pm_usage_cnt += inc_usage_cnt;
1315 WARN_ON(udev->pm_usage_cnt < 0);
Alan Stern013d27f2007-08-20 12:18:39 -04001316 if (inc_usage_cnt)
1317 udev->last_busy = jiffies;
Alan Stern94fcda12006-11-20 11:38:46 -05001318 if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
Alan Stern19410442007-03-27 13:33:59 -04001319 if (udev->state == USB_STATE_SUSPENDED)
1320 status = usb_resume_both(udev);
Alan Stern94fcda12006-11-20 11:38:46 -05001321 if (status != 0)
1322 udev->pm_usage_cnt -= inc_usage_cnt;
Alan Stern19410442007-03-27 13:33:59 -04001323 else if (inc_usage_cnt)
1324 udev->last_busy = jiffies;
1325 } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
Alan Stern19410442007-03-27 13:33:59 -04001326 status = usb_suspend_both(udev, PMSG_SUSPEND);
1327 }
Alan Stern94fcda12006-11-20 11:38:46 -05001328 usb_pm_unlock(udev);
1329 return status;
1330}
1331
Alan Stern19410442007-03-27 13:33:59 -04001332/* usb_autosuspend_work - callback routine to autosuspend a USB device */
1333void usb_autosuspend_work(struct work_struct *work)
1334{
1335 struct usb_device *udev =
1336 container_of(work, struct usb_device, autosuspend.work);
1337
1338 usb_autopm_do_device(udev, 0);
1339}
1340
Alan Stern645daaa2006-08-30 15:47:02 -04001341/**
1342 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001343 * @udev: the usb_device to autosuspend
Alan Stern645daaa2006-08-30 15:47:02 -04001344 *
1345 * This routine should be called when a core subsystem is finished using
1346 * @udev and wants to allow it to autosuspend. Examples would be when
1347 * @udev's device file in usbfs is closed or after a configuration change.
1348 *
Alan Stern94fcda12006-11-20 11:38:46 -05001349 * @udev's usage counter is decremented. If it or any of the usage counters
1350 * for an active interface is greater than 0, no autosuspend request will be
1351 * queued. (If an interface driver does not support autosuspend then its
1352 * usage counter is permanently positive.) Furthermore, if an interface
1353 * driver requires remote-wakeup capability during autosuspend but remote
1354 * wakeup is disabled, the autosuspend will fail.
Alan Stern645daaa2006-08-30 15:47:02 -04001355 *
1356 * Often the caller will hold @udev's device lock, but this is not
1357 * necessary.
1358 *
1359 * This routine can run only in process context.
1360 */
Alan Stern94fcda12006-11-20 11:38:46 -05001361void usb_autosuspend_device(struct usb_device *udev)
Alan Stern645daaa2006-08-30 15:47:02 -04001362{
Alan Stern94fcda12006-11-20 11:38:46 -05001363 int status;
1364
1365 status = usb_autopm_do_device(udev, -1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001366 dev_vdbg(&udev->dev, "%s: cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001367 __func__, udev->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001368}
1369
1370/**
Alan Stern19c26232007-02-20 15:03:32 -05001371 * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
1372 * @udev: the usb_device to autosuspend
1373 *
1374 * This routine should be called when a core subsystem thinks @udev may
1375 * be ready to autosuspend.
1376 *
1377 * @udev's usage counter left unchanged. If it or any of the usage counters
1378 * for an active interface is greater than 0, or autosuspend is not allowed
1379 * for any other reason, no autosuspend request will be queued.
1380 *
1381 * This routine can run only in process context.
1382 */
1383void usb_try_autosuspend_device(struct usb_device *udev)
1384{
1385 usb_autopm_do_device(udev, 0);
Alan Stern20dfdad2007-05-22 11:50:17 -04001386 dev_vdbg(&udev->dev, "%s: cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001387 __func__, udev->pm_usage_cnt);
Alan Stern19c26232007-02-20 15:03:32 -05001388}
1389
1390/**
Alan Stern645daaa2006-08-30 15:47:02 -04001391 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001392 * @udev: the usb_device to autoresume
Alan Stern645daaa2006-08-30 15:47:02 -04001393 *
1394 * This routine should be called when a core subsystem wants to use @udev
Alan Stern94fcda12006-11-20 11:38:46 -05001395 * and needs to guarantee that it is not suspended. No autosuspend will
1396 * occur until usb_autosuspend_device is called. (Note that this will not
1397 * prevent suspend events originating in the PM core.) Examples would be
1398 * when @udev's device file in usbfs is opened or when a remote-wakeup
1399 * request is received.
Alan Stern645daaa2006-08-30 15:47:02 -04001400 *
Alan Stern94fcda12006-11-20 11:38:46 -05001401 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1402 * However if the autoresume fails then the usage counter is re-decremented.
Alan Stern645daaa2006-08-30 15:47:02 -04001403 *
1404 * Often the caller will hold @udev's device lock, but this is not
1405 * necessary (and attempting it might cause deadlock).
1406 *
1407 * This routine can run only in process context.
1408 */
Alan Stern94fcda12006-11-20 11:38:46 -05001409int usb_autoresume_device(struct usb_device *udev)
Alan Stern645daaa2006-08-30 15:47:02 -04001410{
1411 int status;
1412
Alan Stern94fcda12006-11-20 11:38:46 -05001413 status = usb_autopm_do_device(udev, 1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001414 dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001415 __func__, status, udev->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001416 return status;
1417}
1418
Alan Sternaf4f7602006-10-30 17:06:45 -05001419/* Internal routine to adjust an interface's usage counter and change
1420 * its device's autosuspend state.
1421 */
1422static int usb_autopm_do_interface(struct usb_interface *intf,
1423 int inc_usage_cnt)
1424{
1425 struct usb_device *udev = interface_to_usbdev(intf);
1426 int status = 0;
1427
1428 usb_pm_lock(udev);
1429 if (intf->condition == USB_INTERFACE_UNBOUND)
1430 status = -ENODEV;
1431 else {
Alan Stern19410442007-03-27 13:33:59 -04001432 udev->auto_pm = 1;
Alan Sternaf4f7602006-10-30 17:06:45 -05001433 intf->pm_usage_cnt += inc_usage_cnt;
Alan Stern013d27f2007-08-20 12:18:39 -04001434 udev->last_busy = jiffies;
Alan Sternaf4f7602006-10-30 17:06:45 -05001435 if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
Alan Stern19410442007-03-27 13:33:59 -04001436 if (udev->state == USB_STATE_SUSPENDED)
1437 status = usb_resume_both(udev);
Alan Sternaf4f7602006-10-30 17:06:45 -05001438 if (status != 0)
1439 intf->pm_usage_cnt -= inc_usage_cnt;
Alan Stern013d27f2007-08-20 12:18:39 -04001440 else
Alan Stern19410442007-03-27 13:33:59 -04001441 udev->last_busy = jiffies;
1442 } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
Alan Stern19410442007-03-27 13:33:59 -04001443 status = usb_suspend_both(udev, PMSG_SUSPEND);
1444 }
Alan Sternaf4f7602006-10-30 17:06:45 -05001445 }
1446 usb_pm_unlock(udev);
1447 return status;
1448}
1449
Alan Stern645daaa2006-08-30 15:47:02 -04001450/**
1451 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001452 * @intf: the usb_interface whose counter should be decremented
Alan Stern645daaa2006-08-30 15:47:02 -04001453 *
1454 * This routine should be called by an interface driver when it is
1455 * finished using @intf and wants to allow it to autosuspend. A typical
1456 * example would be a character-device driver when its device file is
1457 * closed.
1458 *
1459 * The routine decrements @intf's usage counter. When the counter reaches
1460 * 0, a delayed autosuspend request for @intf's device is queued. When
1461 * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
1462 * the other usage counters for the sibling interfaces and @intf's
1463 * usb_device, the device and all its interfaces will be autosuspended.
1464 *
1465 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1466 * core will not change its value other than the increment and decrement
1467 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1468 * may use this simple counter-oriented discipline or may set the value
1469 * any way it likes.
1470 *
1471 * If the driver has set @intf->needs_remote_wakeup then autosuspend will
1472 * take place only if the device's remote-wakeup facility is enabled.
1473 *
1474 * Suspend method calls queued by this routine can arrive at any time
1475 * while @intf is resumed and its usage counter is equal to 0. They are
1476 * not protected by the usb_device's lock but only by its pm_mutex.
1477 * Drivers must provide their own synchronization.
1478 *
1479 * This routine can run only in process context.
1480 */
1481void usb_autopm_put_interface(struct usb_interface *intf)
1482{
Alan Sternaf4f7602006-10-30 17:06:45 -05001483 int status;
Alan Stern645daaa2006-08-30 15:47:02 -04001484
Alan Sternaf4f7602006-10-30 17:06:45 -05001485 status = usb_autopm_do_interface(intf, -1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001486 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001487 __func__, status, intf->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001488}
1489EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1490
1491/**
1492 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
Henrik Kretzschmar701f35a2006-09-25 17:00:56 -07001493 * @intf: the usb_interface whose counter should be incremented
Alan Stern645daaa2006-08-30 15:47:02 -04001494 *
1495 * This routine should be called by an interface driver when it wants to
1496 * use @intf and needs to guarantee that it is not suspended. In addition,
1497 * the routine prevents @intf from being autosuspended subsequently. (Note
1498 * that this will not prevent suspend events originating in the PM core.)
1499 * This prevention will persist until usb_autopm_put_interface() is called
1500 * or @intf is unbound. A typical example would be a character-device
1501 * driver when its device file is opened.
1502 *
Alan Stern19410442007-03-27 13:33:59 -04001503 *
1504 * The routine increments @intf's usage counter. (However if the
1505 * autoresume fails then the counter is re-decremented.) So long as the
1506 * counter is greater than 0, autosuspend will not be allowed for @intf
1507 * or its usb_device. When the driver is finished using @intf it should
1508 * call usb_autopm_put_interface() to decrement the usage counter and
1509 * queue a delayed autosuspend request (if the counter is <= 0).
1510 *
Alan Stern645daaa2006-08-30 15:47:02 -04001511 *
1512 * Note that @intf->pm_usage_cnt is owned by the interface driver. The
1513 * core will not change its value other than the increment and decrement
1514 * in usb_autopm_get_interface and usb_autopm_put_interface. The driver
1515 * may use this simple counter-oriented discipline or may set the value
1516 * any way it likes.
1517 *
1518 * Resume method calls generated by this routine can arrive at any time
1519 * while @intf is suspended. They are not protected by the usb_device's
1520 * lock but only by its pm_mutex. Drivers must provide their own
1521 * synchronization.
1522 *
1523 * This routine can run only in process context.
1524 */
1525int usb_autopm_get_interface(struct usb_interface *intf)
1526{
Alan Sternaf4f7602006-10-30 17:06:45 -05001527 int status;
Alan Stern645daaa2006-08-30 15:47:02 -04001528
Alan Sternaf4f7602006-10-30 17:06:45 -05001529 status = usb_autopm_do_interface(intf, 1);
Alan Stern20dfdad2007-05-22 11:50:17 -04001530 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001531 __func__, status, intf->pm_usage_cnt);
Alan Stern645daaa2006-08-30 15:47:02 -04001532 return status;
1533}
1534EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1535
Alan Stern692a1862006-10-30 17:07:51 -05001536/**
1537 * usb_autopm_set_interface - set a USB interface's autosuspend state
1538 * @intf: the usb_interface whose state should be set
1539 *
1540 * This routine sets the autosuspend state of @intf's device according
1541 * to @intf's usage counter, which the caller must have set previously.
1542 * If the counter is <= 0, the device is autosuspended (if it isn't
1543 * already suspended and if nothing else prevents the autosuspend). If
1544 * the counter is > 0, the device is autoresumed (if it isn't already
1545 * awake).
1546 */
1547int usb_autopm_set_interface(struct usb_interface *intf)
1548{
1549 int status;
1550
1551 status = usb_autopm_do_interface(intf, 0);
Alan Stern20dfdad2007-05-22 11:50:17 -04001552 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001553 __func__, status, intf->pm_usage_cnt);
Alan Stern692a1862006-10-30 17:07:51 -05001554 return status;
1555}
1556EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
1557
Alan Stern718efa62007-03-09 15:41:13 -05001558#else
1559
1560void usb_autosuspend_work(struct work_struct *work)
1561{}
1562
Alan Stern645daaa2006-08-30 15:47:02 -04001563#endif /* CONFIG_USB_SUSPEND */
1564
Alan Stern6b157c92007-03-13 16:37:30 -04001565/**
1566 * usb_external_suspend_device - external suspend of a USB device and its interfaces
1567 * @udev: the usb_device to suspend
1568 * @msg: Power Management message describing this state transition
1569 *
1570 * This routine handles external suspend requests: ones not generated
1571 * internally by a USB driver (autosuspend) but rather coming from the user
1572 * (via sysfs) or the PM core (system sleep). The suspend will be carried
1573 * out regardless of @udev's usage counter or those of its interfaces,
1574 * and regardless of whether or not remote wakeup is enabled. Of course,
1575 * interface drivers still have the option of failing the suspend (if
1576 * there are unsuspended children, for example).
1577 *
1578 * The caller must hold @udev's device lock.
1579 */
1580int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
Alan Stern1cc8a252006-07-01 22:10:15 -04001581{
1582 int status;
1583
Alan Stern78d9a482008-06-23 16:00:40 -04001584 do_unbind_rebind(udev, DO_UNBIND);
Alan Stern6b157c92007-03-13 16:37:30 -04001585 usb_pm_lock(udev);
1586 udev->auto_pm = 0;
1587 status = usb_suspend_both(udev, msg);
1588 usb_pm_unlock(udev);
Alan Stern1cc8a252006-07-01 22:10:15 -04001589 return status;
1590}
1591
Alan Stern6b157c92007-03-13 16:37:30 -04001592/**
1593 * usb_external_resume_device - external resume of a USB device and its interfaces
1594 * @udev: the usb_device to resume
1595 *
1596 * This routine handles external resume requests: ones not generated
1597 * internally by a USB driver (autoresume) but rather coming from the user
1598 * (via sysfs), the PM core (system resume), or the device itself (remote
1599 * wakeup). @udev's usage counter is unaffected.
1600 *
1601 * The caller must hold @udev's device lock.
1602 */
1603int usb_external_resume_device(struct usb_device *udev)
1604{
1605 int status;
1606
1607 usb_pm_lock(udev);
1608 udev->auto_pm = 0;
1609 status = usb_resume_both(udev);
Alan Sternef7f6c72007-04-05 16:03:49 -04001610 udev->last_busy = jiffies;
Alan Stern6b157c92007-03-13 16:37:30 -04001611 usb_pm_unlock(udev);
Alan Stern78d9a482008-06-23 16:00:40 -04001612 do_unbind_rebind(udev, DO_REBIND);
Alan Stern6b157c92007-03-13 16:37:30 -04001613
1614 /* Now that the device is awake, we can start trying to autosuspend
1615 * it again. */
1616 if (status == 0)
1617 usb_try_autosuspend_device(udev);
1618 return status;
1619}
1620
Alan Sternf2189c42008-08-12 14:34:10 -04001621int usb_suspend(struct device *dev, pm_message_t message)
Alan Stern6b157c92007-03-13 16:37:30 -04001622{
Alan Stern271f9e62007-10-10 16:30:12 -04001623 struct usb_device *udev;
1624
Alan Stern271f9e62007-10-10 16:30:12 -04001625 udev = to_usb_device(dev);
1626
1627 /* If udev is already suspended, we can skip this suspend and
Alan Stern3bb1af52008-03-03 15:15:36 -05001628 * we should also skip the upcoming system resume. High-speed
1629 * root hubs are an exception; they need to resume whenever the
1630 * system wakes up in order for USB-PERSIST port handover to work
1631 * properly.
1632 */
Alan Stern271f9e62007-10-10 16:30:12 -04001633 if (udev->state == USB_STATE_SUSPENDED) {
Alan Stern3bb1af52008-03-03 15:15:36 -05001634 if (udev->parent || udev->speed != USB_SPEED_HIGH)
1635 udev->skip_sys_resume = 1;
Alan Stern271f9e62007-10-10 16:30:12 -04001636 return 0;
1637 }
1638
1639 udev->skip_sys_resume = 0;
1640 return usb_external_suspend_device(udev, message);
Alan Stern6b157c92007-03-13 16:37:30 -04001641}
1642
Alan Sternf2189c42008-08-12 14:34:10 -04001643int usb_resume(struct device *dev)
Alan Stern1cc8a252006-07-01 22:10:15 -04001644{
Alan Stern2add5222007-03-20 14:59:39 -04001645 struct usb_device *udev;
1646
Alan Stern2add5222007-03-20 14:59:39 -04001647 udev = to_usb_device(dev);
Alan Stern0458d5b2007-05-04 11:52:20 -04001648
Alan Stern271f9e62007-10-10 16:30:12 -04001649 /* If udev->skip_sys_resume is set then udev was already suspended
Alan Stern8808f002008-04-28 11:06:55 -04001650 * when the system sleep started, so we don't want to resume it
1651 * during this system wakeup.
1652 */
1653 if (udev->skip_sys_resume)
1654 return 0;
Alan Stern2add5222007-03-20 14:59:39 -04001655 return usb_external_resume_device(udev);
Alan Stern1cc8a252006-07-01 22:10:15 -04001656}
1657
Alan Stern36e56a32006-07-01 22:08:06 -04001658#endif /* CONFIG_PM */
1659
1660struct bus_type usb_bus_type = {
1661 .name = "usb",
1662 .match = usb_device_match,
1663 .uevent = usb_uevent,
Alan Stern36e56a32006-07-01 22:08:06 -04001664};