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