Blame view
drivers/base/dd.c
23.1 KB
07e4a3e27
|
1 |
/* |
4a3ad20cc
|
2 |
* drivers/base/dd.c - The core device/driver interactions. |
07e4a3e27
|
3 |
* |
4a3ad20cc
|
4 5 6 |
* This file contains the (sometimes tricky) code that controls the * interactions between devices and drivers, which primarily includes * driver binding and unbinding. |
07e4a3e27
|
7 |
* |
4a3ad20cc
|
8 9 10 |
* All of this code used to exist in drivers/base/bus.c, but was * relocated to here in the name of compartmentalization (since it wasn't * strictly code just for the 'struct bus_type'. |
07e4a3e27
|
11 |
* |
4a3ad20cc
|
12 13 |
* Copyright (c) 2002-5 Patrick Mochel * Copyright (c) 2002-3 Open Source Development Labs |
b40284378
|
14 15 |
* Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2007-2009 Novell Inc. |
07e4a3e27
|
16 |
* |
4a3ad20cc
|
17 |
* This file is released under the GPLv2 |
07e4a3e27
|
18 19 20 |
*/ #include <linux/device.h> |
216773a78
|
21 |
#include <linux/delay.h> |
07e4a3e27
|
22 |
#include <linux/module.h> |
d779249ed
|
23 |
#include <linux/kthread.h> |
735a7ffb7
|
24 |
#include <linux/wait.h> |
216773a78
|
25 |
#include <linux/async.h> |
5e928f77a
|
26 |
#include <linux/pm_runtime.h> |
ab78029ec
|
27 |
#include <linux/pinctrl/devinfo.h> |
07e4a3e27
|
28 29 30 |
#include "base.h" #include "power/power.h" |
d1c3414c2
|
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/* * Deferred Probe infrastructure. * * Sometimes driver probe order matters, but the kernel doesn't always have * dependency information which means some drivers will get probed before a * resource it depends on is available. For example, an SDHCI driver may * first need a GPIO line from an i2c GPIO controller before it can be * initialized. If a required resource is not available yet, a driver can * request probing to be deferred by returning -EPROBE_DEFER from its probe hook * * Deferred probe maintains two lists of devices, a pending list and an active * list. A driver returning -EPROBE_DEFER causes the device to be added to the * pending list. A successful driver probe will trigger moving all devices * from the pending to the active list so that the workqueue will eventually * retry them. * * The deferred_probe_mutex must be held any time the deferred_probe_*_list |
ef8a3fd6e
|
48 |
* of the (struct device*)->p->deferred_probe pointers are manipulated |
d1c3414c2
|
49 50 51 52 |
*/ static DEFINE_MUTEX(deferred_probe_mutex); static LIST_HEAD(deferred_probe_pending_list); static LIST_HEAD(deferred_probe_active_list); |
58b116bce
|
53 |
static atomic_t deferred_trigger_count = ATOMIC_INIT(0); |
d1c3414c2
|
54 |
|
41575335e
|
55 |
/* |
013c074f8
|
56 57 58 59 60 61 62 |
* In some cases, like suspend to RAM or hibernation, It might be reasonable * to prohibit probing of devices as it could be unsafe. * Once defer_all_probes is true all drivers probes will be forcibly deferred. */ static bool defer_all_probes; /* |
d1c3414c2
|
63 64 65 66 67 |
* deferred_probe_work_func() - Retry probing devices in the active list. */ static void deferred_probe_work_func(struct work_struct *work) { struct device *dev; |
ef8a3fd6e
|
68 |
struct device_private *private; |
d1c3414c2
|
69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
/* * This block processes every device in the deferred 'active' list. * Each device is removed from the active list and passed to * bus_probe_device() to re-attempt the probe. The loop continues * until every device in the active list is removed and retried. * * Note: Once the device is removed from the list and the mutex is * released, it is possible for the device get freed by another thread * and cause a illegal pointer dereference. This code uses * get/put_device() to ensure the device structure cannot disappear * from under our feet. */ mutex_lock(&deferred_probe_mutex); while (!list_empty(&deferred_probe_active_list)) { |
ef8a3fd6e
|
83 84 85 86 |
private = list_first_entry(&deferred_probe_active_list, typeof(*dev->p), deferred_probe); dev = private->device; list_del_init(&private->deferred_probe); |
d1c3414c2
|
87 88 |
get_device(dev); |
8b0372a25
|
89 90 91 92 |
/* * Drop the mutex while probing each device; the probe path may * manipulate the deferred list */ |
d1c3414c2
|
93 |
mutex_unlock(&deferred_probe_mutex); |
8153584e3
|
94 95 96 97 98 99 100 101 102 103 |
/* * Force the device to the end of the dpm_list since * the PM code assumes that the order we add things to * the list is a good order for suspend but deferred * probe makes that very unsafe. */ device_pm_lock(); device_pm_move_last(dev); device_pm_unlock(); |
d1c3414c2
|
104 105 106 |
dev_dbg(dev, "Retrying from deferred list "); bus_probe_device(dev); |
8153584e3
|
107 |
|
d1c3414c2
|
108 109 110 111 112 113 114 115 116 117 118 |
mutex_lock(&deferred_probe_mutex); put_device(dev); } mutex_unlock(&deferred_probe_mutex); } static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); static void driver_deferred_probe_add(struct device *dev) { mutex_lock(&deferred_probe_mutex); |
ef8a3fd6e
|
119 |
if (list_empty(&dev->p->deferred_probe)) { |
d1c3414c2
|
120 121 |
dev_dbg(dev, "Added to deferred list "); |
1d29cfa57
|
122 |
list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list); |
d1c3414c2
|
123 124 125 126 127 128 129 |
} mutex_unlock(&deferred_probe_mutex); } void driver_deferred_probe_del(struct device *dev) { mutex_lock(&deferred_probe_mutex); |
ef8a3fd6e
|
130 |
if (!list_empty(&dev->p->deferred_probe)) { |
d1c3414c2
|
131 132 |
dev_dbg(dev, "Removed from deferred list "); |
ef8a3fd6e
|
133 |
list_del_init(&dev->p->deferred_probe); |
d1c3414c2
|
134 135 136 137 138 139 140 141 142 143 144 |
} mutex_unlock(&deferred_probe_mutex); } static bool driver_deferred_probe_enable = false; /** * driver_deferred_probe_trigger() - Kick off re-probing deferred devices * * This functions moves all devices from the pending list to the active * list and schedules the deferred probe workqueue to process them. It * should be called anytime a driver is successfully bound to a device. |
58b116bce
|
145 146 147 148 149 |
* * Note, there is a race condition in multi-threaded probe. In the case where * more than one device is probing at the same time, it is possible for one * probe to complete successfully while another is about to defer. If the second * depends on the first, then it will get put on the pending list after the |
9ba8af664
|
150 |
* trigger event has already occurred and will be stuck there. |
58b116bce
|
151 152 153 154 155 |
* * The atomic 'deferred_trigger_count' is used to determine if a successful * trigger has occurred in the midst of probing a driver. If the trigger count * changes in the midst of a probe, then deferred processing should be triggered * again. |
d1c3414c2
|
156 157 158 159 160 |
*/ static void driver_deferred_probe_trigger(void) { if (!driver_deferred_probe_enable) return; |
8b0372a25
|
161 162 |
/* * A successful probe means that all the devices in the pending list |
d1c3414c2
|
163 |
* should be triggered to be reprobed. Move all the deferred devices |
8b0372a25
|
164 165 |
* into the active list so they can be retried by the workqueue */ |
d1c3414c2
|
166 |
mutex_lock(&deferred_probe_mutex); |
58b116bce
|
167 |
atomic_inc(&deferred_trigger_count); |
d1c3414c2
|
168 169 170 |
list_splice_tail_init(&deferred_probe_pending_list, &deferred_probe_active_list); mutex_unlock(&deferred_probe_mutex); |
8b0372a25
|
171 172 173 174 |
/* * Kick the re-probe thread. It may already be scheduled, but it is * safe to kick it again. */ |
2c507e464
|
175 |
schedule_work(&deferred_probe_work); |
d1c3414c2
|
176 177 178 |
} /** |
013c074f8
|
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 |
* device_block_probing() - Block/defere device's probes * * It will disable probing of devices and defer their probes instead. */ void device_block_probing(void) { defer_all_probes = true; /* sync with probes to avoid races. */ wait_for_device_probe(); } /** * device_unblock_probing() - Unblock/enable device's probes * * It will restore normal behavior and trigger re-probing of deferred * devices. */ void device_unblock_probing(void) { defer_all_probes = false; driver_deferred_probe_trigger(); } /** |
d1c3414c2
|
203 204 205 206 207 208 209 210 |
* deferred_probe_initcall() - Enable probing of deferred devices * * We don't want to get in the way when the bulk of drivers are getting probed. * Instead, this initcall makes sure that deferred probing is delayed until * late_initcall time. */ static int deferred_probe_initcall(void) { |
d1c3414c2
|
211 212 |
driver_deferred_probe_enable = true; driver_deferred_probe_trigger(); |
d72cca1ee
|
213 |
/* Sort as many dependencies as possible before exiting initcalls */ |
2c507e464
|
214 |
flush_work(&deferred_probe_work); |
d1c3414c2
|
215 216 217 |
return 0; } late_initcall(deferred_probe_initcall); |
07e4a3e27
|
218 |
|
6b9cb4275
|
219 220 221 222 223 224 225 226 227 228 229 |
/** * device_is_bound() - Check if device is bound to a driver * @dev: device to check * * Returns true if passed device has already finished probing successfully * against a driver. * * This function must be called with the device lock held. */ bool device_is_bound(struct device *dev) { |
3ded91041
|
230 |
return dev->p && klist_node_attached(&dev->p->knode_driver); |
6b9cb4275
|
231 |
} |
1901fb260
|
232 |
static void driver_bound(struct device *dev) |
07e4a3e27
|
233 |
{ |
6b9cb4275
|
234 |
if (device_is_bound(dev)) { |
f86db396f
|
235 236 |
printk(KERN_WARNING "%s: device %s already bound ", |
2b3a302a0
|
237 |
__func__, kobject_name(&dev->kobj)); |
1901fb260
|
238 |
return; |
f86db396f
|
239 |
} |
4c898c7f2
|
240 |
|
94f8cc0ee
|
241 242 243 |
pr_debug("driver: '%s': %s: bound to device '%s' ", dev->driver->name, __func__, dev_name(dev)); |
116af3782
|
244 |
|
fbb88fadf
|
245 |
klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); |
aa8e54b55
|
246 |
device_pm_check_callbacks(dev); |
8b0372a25
|
247 248 249 250 |
/* * Make sure the device is no longer in one of the deferred lists and * kick off retrying all pending devices */ |
d1c3414c2
|
251 252 |
driver_deferred_probe_del(dev); driver_deferred_probe_trigger(); |
116af3782
|
253 |
if (dev->bus) |
c6f7e72a3
|
254 |
blocking_notifier_call_chain(&dev->bus->p->bus_notifier, |
116af3782
|
255 |
BUS_NOTIFY_BOUND_DRIVER, dev); |
1901fb260
|
256 257 258 259 260 |
} static int driver_sysfs_add(struct device *dev) { int ret; |
45daef0fd
|
261 262 263 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_BIND_DRIVER, dev); |
e5dd12784
|
264 |
ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj, |
07e4a3e27
|
265 |
kobject_name(&dev->kobj)); |
f86db396f
|
266 |
if (ret == 0) { |
e5dd12784
|
267 |
ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, |
f86db396f
|
268 269 |
"driver"); if (ret) |
e5dd12784
|
270 |
sysfs_remove_link(&dev->driver->p->kobj, |
f86db396f
|
271 272 273 |
kobject_name(&dev->kobj)); } return ret; |
07e4a3e27
|
274 |
} |
1901fb260
|
275 276 277 278 279 |
static void driver_sysfs_remove(struct device *dev) { struct device_driver *drv = dev->driver; if (drv) { |
e5dd12784
|
280 |
sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj)); |
1901fb260
|
281 282 283 284 285 |
sysfs_remove_link(&dev->kobj, "driver"); } } /** |
4a3ad20cc
|
286 287 |
* device_bind_driver - bind a driver to one device. * @dev: device. |
1901fb260
|
288 |
* |
4a3ad20cc
|
289 290 |
* Allow manual attachment of a driver to a device. * Caller must have already set @dev->driver. |
1901fb260
|
291 |
* |
4a3ad20cc
|
292 293 294 295 |
* Note that this does not modify the bus reference count * nor take the bus's rwsem. Please verify those are accounted * for before calling this. (It is ok to call with no other effort * from a driver's probe() method.) |
1901fb260
|
296 |
* |
8e9394ce2
|
297 |
* This function must be called with the device lock held. |
1901fb260
|
298 299 300 |
*/ int device_bind_driver(struct device *dev) { |
cb986b749
|
301 302 303 304 305 |
int ret; ret = driver_sysfs_add(dev); if (!ret) driver_bound(dev); |
14b6257a5
|
306 307 308 |
else if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); |
cb986b749
|
309 |
return ret; |
1901fb260
|
310 |
} |
4a3ad20cc
|
311 |
EXPORT_SYMBOL_GPL(device_bind_driver); |
1901fb260
|
312 |
|
d779249ed
|
313 |
static atomic_t probe_count = ATOMIC_INIT(0); |
735a7ffb7
|
314 |
static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); |
21c7f30b1
|
315 |
static int really_probe(struct device *dev, struct device_driver *drv) |
07e4a3e27
|
316 |
{ |
013c074f8
|
317 |
int ret = -EPROBE_DEFER; |
58b116bce
|
318 |
int local_trigger_count = atomic_read(&deferred_trigger_count); |
c5f062748
|
319 320 |
bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && !drv->suppress_bind_attrs; |
07e4a3e27
|
321 |
|
013c074f8
|
322 323 324 325 326 327 328 329 330 331 332 |
if (defer_all_probes) { /* * Value of defer_all_probes can be set only by * device_defer_all_probes_enable() which, in turn, will call * wait_for_device_probe() right after that to avoid any races. */ dev_dbg(dev, "Driver %s force probe deferral ", drv->name); driver_deferred_probe_add(dev); return ret; } |
d779249ed
|
333 |
atomic_inc(&probe_count); |
7dc72b284
|
334 335 |
pr_debug("bus: '%s': %s: probing driver %s with device %s ", |
1e0b2cf93
|
336 |
drv->bus->name, __func__, drv->name, dev_name(dev)); |
9ac7849e3
|
337 |
WARN_ON(!list_empty(&dev->devres_head)); |
07e4a3e27
|
338 |
|
bea5b158f
|
339 |
re_probe: |
07e4a3e27
|
340 |
dev->driver = drv; |
ab78029ec
|
341 342 343 344 |
/* If using pinctrl, bind pins now before probing */ ret = pinctrl_bind_pins(dev); if (ret) |
14b6257a5
|
345 |
goto pinctrl_bind_failed; |
ab78029ec
|
346 |
|
1901fb260
|
347 348 349 |
if (driver_sysfs_add(dev)) { printk(KERN_ERR "%s: driver_sysfs_add(%s) failed ", |
1e0b2cf93
|
350 |
__func__, dev_name(dev)); |
1901fb260
|
351 352 |
goto probe_failed; } |
e90d55327
|
353 354 355 356 357 |
if (dev->pm_domain && dev->pm_domain->activate) { ret = dev->pm_domain->activate(dev); if (ret) goto probe_failed; } |
52cdbdd49
|
358 359 360 361 362 363 364 |
/* * Ensure devices are listed in devices_kset in correct order * It's important to move Dev to the end of devices_kset before * calling .probe, because it could be recursive and parent Dev * should always go first */ devices_kset_move_last(dev); |
594c8281f
|
365 366 |
if (dev->bus->probe) { ret = dev->bus->probe(dev); |
1901fb260
|
367 |
if (ret) |
d779249ed
|
368 |
goto probe_failed; |
594c8281f
|
369 |
} else if (drv->probe) { |
0d3e5a2e3
|
370 |
ret = drv->probe(dev); |
1901fb260
|
371 |
if (ret) |
d779249ed
|
372 |
goto probe_failed; |
f86db396f
|
373 |
} |
1901fb260
|
374 |
|
bea5b158f
|
375 376 |
if (test_remove) { test_remove = false; |
bdacd1b42
|
377 |
if (dev->bus->remove) |
bea5b158f
|
378 379 380 381 382 383 384 385 386 387 388 389 390 391 |
dev->bus->remove(dev); else if (drv->remove) drv->remove(dev); devres_release_all(dev); driver_sysfs_remove(dev); dev->driver = NULL; dev_set_drvdata(dev, NULL); if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); pm_runtime_reinit(dev); goto re_probe; } |
ef0eebc05
|
392 |
pinctrl_init_done(dev); |
e90d55327
|
393 394 |
if (dev->pm_domain && dev->pm_domain->sync) dev->pm_domain->sync(dev); |
1901fb260
|
395 |
driver_bound(dev); |
0d3e5a2e3
|
396 |
ret = 1; |
7dc72b284
|
397 398 |
pr_debug("bus: '%s': %s: bound device %s to driver %s ", |
1e0b2cf93
|
399 |
drv->bus->name, __func__, dev_name(dev), drv->name); |
d779249ed
|
400 |
goto done; |
0d3e5a2e3
|
401 |
|
d779249ed
|
402 |
probe_failed: |
14b6257a5
|
403 404 405 406 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); pinctrl_bind_failed: |
9ac7849e3
|
407 |
devres_release_all(dev); |
1901fb260
|
408 409 |
driver_sysfs_remove(dev); dev->driver = NULL; |
0998d0631
|
410 |
dev_set_drvdata(dev, NULL); |
e90d55327
|
411 412 |
if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); |
5de85b9d5
|
413 |
pm_runtime_reinit(dev); |
1901fb260
|
414 |
|
bb2b40754
|
415 416 |
switch (ret) { case -EPROBE_DEFER: |
d1c3414c2
|
417 |
/* Driver requested deferred probing */ |
13fcffbbd
|
418 419 |
dev_dbg(dev, "Driver %s requests probe deferral ", drv->name); |
d1c3414c2
|
420 |
driver_deferred_probe_add(dev); |
58b116bce
|
421 422 423 |
/* Did a trigger occur while probing? Need to re-trigger if yes */ if (local_trigger_count != atomic_read(&deferred_trigger_count)) driver_deferred_probe_trigger(); |
bb2b40754
|
424 425 426 427 428 429 430 431 |
break; case -ENODEV: case -ENXIO: pr_debug("%s: probe of %s rejects match %d ", drv->name, dev_name(dev), ret); break; default: |
0d3e5a2e3
|
432 433 434 435 |
/* driver matched but the probe failed */ printk(KERN_WARNING "%s: probe of %s failed with error %d ", |
1e0b2cf93
|
436 |
drv->name, dev_name(dev), ret); |
0d3e5a2e3
|
437 |
} |
c578abbc2
|
438 439 440 441 442 |
/* * Ignore errors returned by ->probe so that the next driver can try * its luck. */ ret = 0; |
d779249ed
|
443 |
done: |
d779249ed
|
444 |
atomic_dec(&probe_count); |
735a7ffb7
|
445 |
wake_up(&probe_waitqueue); |
d779249ed
|
446 447 448 449 450 451 452 453 454 455 456 |
return ret; } /** * driver_probe_done * Determine if the probe sequence is finished or not. * * Should somehow figure out how to use a semaphore, not an atomic variable... */ int driver_probe_done(void) { |
2b3a302a0
|
457 458 |
pr_debug("%s: probe_count = %d ", __func__, |
d779249ed
|
459 460 461 462 463 464 465 |
atomic_read(&probe_count)); if (atomic_read(&probe_count)) return -EBUSY; return 0; } /** |
216773a78
|
466 467 |
* wait_for_device_probe * Wait for device probing to be completed. |
216773a78
|
468 |
*/ |
b23530ebc
|
469 |
void wait_for_device_probe(void) |
216773a78
|
470 |
{ |
013c074f8
|
471 |
/* wait for the deferred probe workqueue to finish */ |
2c507e464
|
472 |
flush_work(&deferred_probe_work); |
013c074f8
|
473 |
|
216773a78
|
474 |
/* wait for the known devices to complete their probing */ |
b23530ebc
|
475 |
wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); |
216773a78
|
476 |
async_synchronize_full(); |
216773a78
|
477 |
} |
d4d5291c8
|
478 |
EXPORT_SYMBOL_GPL(wait_for_device_probe); |
216773a78
|
479 480 |
/** |
d779249ed
|
481 482 483 484 |
* driver_probe_device - attempt to bind device & driver together * @drv: driver to bind a device to * @dev: device to try to bind to the driver * |
49b420a13
|
485 |
* This function returns -ENODEV if the device is not registered, |
af901ca18
|
486 |
* 1 if the device is bound successfully and 0 otherwise. |
d779249ed
|
487 |
* |
8e9394ce2
|
488 489 |
* This function must be called with @dev lock held. When called for a * USB interface, @dev->parent lock must be held as well. |
ddef08dd0
|
490 491 |
* * If the device has a parent, runtime-resume the parent before driver probing. |
d779249ed
|
492 |
*/ |
4a3ad20cc
|
493 |
int driver_probe_device(struct device_driver *drv, struct device *dev) |
d779249ed
|
494 |
{ |
d779249ed
|
495 |
int ret = 0; |
f2eaae197
|
496 497 |
if (!device_is_registered(dev)) return -ENODEV; |
d779249ed
|
498 |
|
7dc72b284
|
499 500 |
pr_debug("bus: '%s': %s: matched device %s with driver %s ", |
1e0b2cf93
|
501 |
drv->bus->name, __func__, dev_name(dev), drv->name); |
d779249ed
|
502 |
|
ddef08dd0
|
503 504 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
5e928f77a
|
505 |
pm_runtime_barrier(dev); |
21c7f30b1
|
506 |
ret = really_probe(dev, drv); |
fa180eb44
|
507 |
pm_request_idle(dev); |
d779249ed
|
508 |
|
ddef08dd0
|
509 510 |
if (dev->parent) pm_runtime_put(dev->parent); |
0d3e5a2e3
|
511 |
return ret; |
07e4a3e27
|
512 |
} |
765230b5f
|
513 |
bool driver_allows_async_probing(struct device_driver *drv) |
2287c322b
|
514 |
{ |
d173a137c
|
515 516 |
switch (drv->probe_type) { case PROBE_PREFER_ASYNCHRONOUS: |
f2411da74
|
517 |
return true; |
d173a137c
|
518 519 520 521 |
case PROBE_FORCE_SYNCHRONOUS: return false; default: |
80c6e1465
|
522 |
if (module_requested_async_probing(drv->owner)) |
d173a137c
|
523 |
return true; |
f2411da74
|
524 |
|
d173a137c
|
525 526 |
return false; } |
765230b5f
|
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 |
} struct device_attach_data { struct device *dev; /* * Indicates whether we are are considering asynchronous probing or * not. Only initial binding after device or driver registration * (including deferral processing) may be done asynchronously, the * rest is always synchronous, as we expect it is being done by * request from userspace. */ bool check_async; /* * Indicates if we are binding synchronous or asynchronous drivers. * When asynchronous probing is enabled we'll execute 2 passes * over drivers: first pass doing synchronous probing and second * doing asynchronous probing (if synchronous did not succeed - * most likely because there was no driver requiring synchronous * probing - and we found asynchronous driver during first pass). * The 2 passes are done because we can't shoot asynchronous * probe for given device and driver from bus_for_each_drv() since * driver pointer is not guaranteed to stay valid once * bus_for_each_drv() iterates to the next driver on the bus. */ bool want_async; /* * We'll set have_async to 'true' if, while scanning for matching * driver, we'll encounter one that requests asynchronous probing. */ bool have_async; }; static int __device_attach_driver(struct device_driver *drv, void *_data) { struct device_attach_data *data = _data; struct device *dev = data->dev; bool async_allowed; |
656b8035b
|
567 |
int ret; |
765230b5f
|
568 569 570 571 572 573 574 575 576 |
/* * Check if device has already been claimed. This may * happen with driver loading, device discovery/registration, * and deferred probe processing happens all at once with * multiple threads. */ if (dev->driver) return -EBUSY; |
49b420a13
|
577 |
|
656b8035b
|
578 579 580 |
ret = driver_match_device(drv, dev); if (ret == 0) { /* no match */ |
49b420a13
|
581 |
return 0; |
656b8035b
|
582 583 584 585 586 587 588 589 |
} else if (ret == -EPROBE_DEFER) { dev_dbg(dev, "Device match requests probe deferral "); driver_deferred_probe_add(dev); } else if (ret < 0) { dev_dbg(dev, "Bus failed to match device: %d", ret); return ret; } /* ret > 0 means positive match */ |
49b420a13
|
590 |
|
765230b5f
|
591 592 593 594 595 596 597 |
async_allowed = driver_allows_async_probing(drv); if (async_allowed) data->have_async = true; if (data->check_async && async_allowed != data->want_async) return 0; |
0d3e5a2e3
|
598 |
return driver_probe_device(drv, dev); |
2287c322b
|
599 |
} |
765230b5f
|
600 601 602 603 604 605 606 607 608 609 |
static void __device_attach_async_helper(void *_dev, async_cookie_t cookie) { struct device *dev = _dev; struct device_attach_data data = { .dev = dev, .check_async = true, .want_async = true, }; device_lock(dev); |
ddef08dd0
|
610 611 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
765230b5f
|
612 613 614 615 616 |
bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver); dev_dbg(dev, "async probe completed "); pm_request_idle(dev); |
ddef08dd0
|
617 618 |
if (dev->parent) pm_runtime_put(dev->parent); |
765230b5f
|
619 620 621 622 |
device_unlock(dev); put_device(dev); } |
802a87fd5
|
623 |
static int __device_attach(struct device *dev, bool allow_async) |
07e4a3e27
|
624 |
{ |
0d3e5a2e3
|
625 |
int ret = 0; |
8e9394ce2
|
626 |
device_lock(dev); |
07e4a3e27
|
627 |
if (dev->driver) { |
6b9cb4275
|
628 |
if (device_is_bound(dev)) { |
8497d6a21
|
629 630 631 |
ret = 1; goto out_unlock; } |
f86db396f
|
632 633 634 |
ret = device_bind_driver(dev); if (ret == 0) ret = 1; |
c6a46696f
|
635 636 637 638 |
else { dev->driver = NULL; ret = 0; } |
21c7f30b1
|
639 |
} else { |
765230b5f
|
640 641 642 643 644 |
struct device_attach_data data = { .dev = dev, .check_async = allow_async, .want_async = false, }; |
ddef08dd0
|
645 646 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
765230b5f
|
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 |
ret = bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver); if (!ret && allow_async && data.have_async) { /* * If we could not find appropriate driver * synchronously and we are allowed to do * async probes and there are drivers that * want to probe asynchronously, we'll * try them. */ dev_dbg(dev, "scheduling asynchronous probe "); get_device(dev); async_schedule(__device_attach_async_helper, dev); } else { pm_request_idle(dev); } |
ddef08dd0
|
664 665 666 |
if (dev->parent) pm_runtime_put(dev->parent); |
21c7f30b1
|
667 |
} |
8497d6a21
|
668 |
out_unlock: |
8e9394ce2
|
669 |
device_unlock(dev); |
0d3e5a2e3
|
670 |
return ret; |
2287c322b
|
671 |
} |
765230b5f
|
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 |
/** * device_attach - try to attach device to a driver. * @dev: device. * * Walk the list of drivers that the bus has and call * driver_probe_device() for each pair. If a compatible * pair is found, break out and return. * * Returns 1 if the device was bound to a driver; * 0 if no matching driver was found; * -ENODEV if the device is not registered. * * When called for a USB interface, @dev->parent lock must be held. */ int device_attach(struct device *dev) { return __device_attach(dev, false); } |
4a3ad20cc
|
691 |
EXPORT_SYMBOL_GPL(device_attach); |
2287c322b
|
692 |
|
765230b5f
|
693 694 695 696 |
void device_initial_probe(struct device *dev) { __device_attach(dev, true); } |
4a3ad20cc
|
697 |
static int __driver_attach(struct device *dev, void *data) |
2287c322b
|
698 |
{ |
4a3ad20cc
|
699 |
struct device_driver *drv = data; |
656b8035b
|
700 |
int ret; |
0d3e5a2e3
|
701 702 703 704 705 706 707 708 709 710 |
/* * Lock device and try to bind to it. We drop the error * here and always return 0, because we need to keep trying * to bind to devices and some drivers will return an error * simply if it didn't support the device. * * driver_probe_device() will spit a warning if there * is an error. */ |
656b8035b
|
711 712 713 |
ret = driver_match_device(drv, dev); if (ret == 0) { /* no match */ |
6cd495860
|
714 |
return 0; |
656b8035b
|
715 716 717 718 719 720 721 722 |
} else if (ret == -EPROBE_DEFER) { dev_dbg(dev, "Device match requests probe deferral "); driver_deferred_probe_add(dev); } else if (ret < 0) { dev_dbg(dev, "Bus failed to match device: %d", ret); return ret; } /* ret > 0 means positive match */ |
6cd495860
|
723 |
|
bf74ad5bc
|
724 |
if (dev->parent) /* Needed for USB */ |
8e9394ce2
|
725 726 |
device_lock(dev->parent); device_lock(dev); |
0d3e5a2e3
|
727 728 |
if (!dev->driver) driver_probe_device(drv, dev); |
8e9394ce2
|
729 |
device_unlock(dev); |
bf74ad5bc
|
730 |
if (dev->parent) |
8e9394ce2
|
731 |
device_unlock(dev->parent); |
0d3e5a2e3
|
732 |
|
07e4a3e27
|
733 734 735 736 |
return 0; } /** |
4a3ad20cc
|
737 738 |
* driver_attach - try to bind driver to devices. * @drv: driver. |
07e4a3e27
|
739 |
* |
4a3ad20cc
|
740 741 742 743 |
* Walk the list of devices that the bus has on it and try to * match the driver with each one. If driver_probe_device() * returns 0 and the @dev->driver is set, we've found a * compatible pair. |
07e4a3e27
|
744 |
*/ |
4a3ad20cc
|
745 |
int driver_attach(struct device_driver *drv) |
07e4a3e27
|
746 |
{ |
f86db396f
|
747 |
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); |
07e4a3e27
|
748 |
} |
4a3ad20cc
|
749 |
EXPORT_SYMBOL_GPL(driver_attach); |
07e4a3e27
|
750 |
|
ab71c6f07
|
751 |
/* |
8e9394ce2
|
752 753 |
* __device_release_driver() must be called with @dev lock held. * When called for a USB interface, @dev->parent lock must be held as well. |
07e4a3e27
|
754 |
*/ |
4a3ad20cc
|
755 |
static void __device_release_driver(struct device *dev) |
07e4a3e27
|
756 |
{ |
4a3ad20cc
|
757 |
struct device_driver *drv; |
07e4a3e27
|
758 |
|
ef2c51746
|
759 |
drv = dev->driver; |
c95a6b057
|
760 |
if (drv) { |
765230b5f
|
761 762 |
if (driver_allows_async_probing(drv)) async_synchronize_full(); |
e1866b33b
|
763 |
pm_runtime_get_sync(dev); |
5e928f77a
|
764 |
|
1901fb260
|
765 |
driver_sysfs_remove(dev); |
0d3e5a2e3
|
766 |
|
116af3782
|
767 |
if (dev->bus) |
c6f7e72a3
|
768 |
blocking_notifier_call_chain(&dev->bus->p->bus_notifier, |
116af3782
|
769 770 |
BUS_NOTIFY_UNBIND_DRIVER, dev); |
baab52ded
|
771 |
pm_runtime_put_sync(dev); |
e1866b33b
|
772 |
|
0f836ca4c
|
773 |
if (dev->bus && dev->bus->remove) |
594c8281f
|
774 775 |
dev->bus->remove(dev); else if (drv->remove) |
0d3e5a2e3
|
776 |
drv->remove(dev); |
9ac7849e3
|
777 |
devres_release_all(dev); |
0d3e5a2e3
|
778 |
dev->driver = NULL; |
0998d0631
|
779 |
dev_set_drvdata(dev, NULL); |
e90d55327
|
780 781 |
if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); |
5de85b9d5
|
782 |
pm_runtime_reinit(dev); |
e90d55327
|
783 |
|
8940b4f31
|
784 |
klist_remove(&dev->p->knode_driver); |
aa8e54b55
|
785 |
device_pm_check_callbacks(dev); |
309b7d60a
|
786 787 788 789 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_UNBOUND_DRIVER, dev); |
0d3e5a2e3
|
790 |
} |
07e4a3e27
|
791 |
} |
ab71c6f07
|
792 |
/** |
4a3ad20cc
|
793 794 |
* device_release_driver - manually detach device from driver. * @dev: device. |
ab71c6f07
|
795 |
* |
4a3ad20cc
|
796 |
* Manually detach device from driver. |
8e9394ce2
|
797 |
* When called for a USB interface, @dev->parent lock must be held. |
ab71c6f07
|
798 |
*/ |
4a3ad20cc
|
799 |
void device_release_driver(struct device *dev) |
94e7b1c5f
|
800 |
{ |
c95a6b057
|
801 802 803 804 805 |
/* * If anyone calls device_release_driver() recursively from * within their ->remove callback for the same device, they * will deadlock right here. */ |
8e9394ce2
|
806 |
device_lock(dev); |
c95a6b057
|
807 |
__device_release_driver(dev); |
8e9394ce2
|
808 |
device_unlock(dev); |
94e7b1c5f
|
809 |
} |
4a3ad20cc
|
810 |
EXPORT_SYMBOL_GPL(device_release_driver); |
c95a6b057
|
811 |
|
07e4a3e27
|
812 813 814 815 |
/** * driver_detach - detach driver from all devices it controls. * @drv: driver. */ |
4a3ad20cc
|
816 |
void driver_detach(struct device_driver *drv) |
07e4a3e27
|
817 |
{ |
8940b4f31
|
818 |
struct device_private *dev_prv; |
4a3ad20cc
|
819 |
struct device *dev; |
c95a6b057
|
820 821 |
for (;;) { |
e5dd12784
|
822 823 824 |
spin_lock(&drv->p->klist_devices.k_lock); if (list_empty(&drv->p->klist_devices.k_list)) { spin_unlock(&drv->p->klist_devices.k_lock); |
c95a6b057
|
825 826 |
break; } |
8940b4f31
|
827 828 829 830 |
dev_prv = list_entry(drv->p->klist_devices.k_list.prev, struct device_private, knode_driver.n_node); dev = dev_prv->device; |
c95a6b057
|
831 |
get_device(dev); |
e5dd12784
|
832 |
spin_unlock(&drv->p->klist_devices.k_lock); |
c95a6b057
|
833 |
|
bf74ad5bc
|
834 |
if (dev->parent) /* Needed for USB */ |
8e9394ce2
|
835 836 |
device_lock(dev->parent); device_lock(dev); |
c95a6b057
|
837 838 |
if (dev->driver == drv) __device_release_driver(dev); |
8e9394ce2
|
839 |
device_unlock(dev); |
bf74ad5bc
|
840 |
if (dev->parent) |
8e9394ce2
|
841 |
device_unlock(dev->parent); |
c95a6b057
|
842 843 |
put_device(dev); } |
07e4a3e27
|
844 |
} |