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