Blame view
drivers/base/dd.c
32.9 KB
989d42e85 driver core: add ... |
1 |
// SPDX-License-Identifier: GPL-2.0 |
07e4a3e27 [PATCH] Move devi... |
2 |
/* |
4a3ad20cc Driver core: codi... |
3 |
* drivers/base/dd.c - The core device/driver interactions. |
07e4a3e27 [PATCH] Move devi... |
4 |
* |
4a3ad20cc Driver core: codi... |
5 6 7 |
* This file contains the (sometimes tricky) code that controls the * interactions between devices and drivers, which primarily includes * driver binding and unbinding. |
07e4a3e27 [PATCH] Move devi... |
8 |
* |
4a3ad20cc Driver core: codi... |
9 10 11 |
* 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 [PATCH] Move devi... |
12 |
* |
4a3ad20cc Driver core: codi... |
13 14 |
* Copyright (c) 2002-5 Patrick Mochel * Copyright (c) 2002-3 Open Source Development Labs |
b40284378 Driver core: move... |
15 16 |
* Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2007-2009 Novell Inc. |
07e4a3e27 [PATCH] Move devi... |
17 |
*/ |
28af109a5 driver core: add ... |
18 |
#include <linux/debugfs.h> |
07e4a3e27 [PATCH] Move devi... |
19 |
#include <linux/device.h> |
216773a78 Consolidate drive... |
20 |
#include <linux/delay.h> |
09515ef5d of/acpi: Configur... |
21 |
#include <linux/dma-mapping.h> |
1f5000bd8 initcall_debug: a... |
22 |
#include <linux/init.h> |
07e4a3e27 [PATCH] Move devi... |
23 |
#include <linux/module.h> |
d779249ed Driver Core: add ... |
24 |
#include <linux/kthread.h> |
735a7ffb7 [PATCH] drivers: ... |
25 |
#include <linux/wait.h> |
216773a78 Consolidate drive... |
26 |
#include <linux/async.h> |
5e928f77a PM: Introduce cor... |
27 |
#include <linux/pm_runtime.h> |
ab78029ec drivers/pinctrl: ... |
28 |
#include <linux/pinctrl/devinfo.h> |
07e4a3e27 [PATCH] Move devi... |
29 30 31 |
#include "base.h" #include "power/power.h" |
d1c3414c2 drivercore: Add d... |
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
/* * 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 driver core: move... |
49 |
* of the (struct device*)->p->deferred_probe pointers are manipulated |
d1c3414c2 drivercore: Add d... |
50 51 52 53 |
*/ static DEFINE_MUTEX(deferred_probe_mutex); static LIST_HEAD(deferred_probe_pending_list); static LIST_HEAD(deferred_probe_active_list); |
58b116bce drivercore: defer... |
54 |
static atomic_t deferred_trigger_count = ATOMIC_INIT(0); |
28af109a5 driver core: add ... |
55 |
static struct dentry *deferred_devices; |
25b4e70dc driver core: allo... |
56 |
static bool initcalls_done; |
d1c3414c2 drivercore: Add d... |
57 |
|
1ea61b68d async: Add cmdlin... |
58 59 60 |
/* Save the async probe drivers' name from kernel cmdline */ #define ASYNC_DRV_NAMES_MAX_LEN 256 static char async_probe_drv_names[ASYNC_DRV_NAMES_MAX_LEN]; |
41575335e driver core: Remo... |
61 |
/* |
013c074f8 PM / sleep: prohi... |
62 63 64 65 66 67 68 |
* 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 drivercore: Add d... |
69 70 71 72 73 |
* 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 driver core: move... |
74 |
struct device_private *private; |
d1c3414c2 drivercore: Add d... |
75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
/* * 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 driver core: move... |
89 90 91 92 |
private = list_first_entry(&deferred_probe_active_list, typeof(*dev->p), deferred_probe); dev = private->device; list_del_init(&private->deferred_probe); |
d1c3414c2 drivercore: Add d... |
93 94 |
get_device(dev); |
8b0372a25 driver core: mino... |
95 96 97 98 |
/* * Drop the mutex while probing each device; the probe path may * manipulate the deferred list */ |
d1c3414c2 drivercore: Add d... |
99 |
mutex_unlock(&deferred_probe_mutex); |
8153584e3 driver core: Move... |
100 101 102 103 104 105 106 |
/* * 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. */ |
494fd7b7a PM / core: fix de... |
107 |
device_pm_move_to_tail(dev); |
8153584e3 driver core: Move... |
108 |
|
d1c3414c2 drivercore: Add d... |
109 110 |
dev_dbg(dev, "Retrying from deferred list "); |
0a50f61c4 drivers: base: in... |
111 |
bus_probe_device(dev); |
d1c3414c2 drivercore: Add d... |
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); |
e7dd40105 driver core: Add ... |
119 |
void driver_deferred_probe_add(struct device *dev) |
d1c3414c2 drivercore: Add d... |
120 121 |
{ mutex_lock(&deferred_probe_mutex); |
ef8a3fd6e driver core: move... |
122 |
if (list_empty(&dev->p->deferred_probe)) { |
d1c3414c2 drivercore: Add d... |
123 124 |
dev_dbg(dev, "Added to deferred list "); |
1d29cfa57 driver core: fixu... |
125 |
list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list); |
d1c3414c2 drivercore: Add d... |
126 127 128 129 130 131 132 |
} mutex_unlock(&deferred_probe_mutex); } void driver_deferred_probe_del(struct device *dev) { mutex_lock(&deferred_probe_mutex); |
ef8a3fd6e driver core: move... |
133 |
if (!list_empty(&dev->p->deferred_probe)) { |
d1c3414c2 drivercore: Add d... |
134 135 |
dev_dbg(dev, "Removed from deferred list "); |
ef8a3fd6e driver core: move... |
136 |
list_del_init(&dev->p->deferred_probe); |
d1c3414c2 drivercore: Add d... |
137 138 139 140 141 142 143 144 145 146 147 |
} 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 drivercore: defer... |
148 149 150 151 152 |
* * 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 base:dd - Fix for... |
153 |
* trigger event has already occurred and will be stuck there. |
58b116bce drivercore: defer... |
154 155 156 157 158 |
* * 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 drivercore: Add d... |
159 160 161 162 163 |
*/ static void driver_deferred_probe_trigger(void) { if (!driver_deferred_probe_enable) return; |
8b0372a25 driver core: mino... |
164 165 |
/* * A successful probe means that all the devices in the pending list |
d1c3414c2 drivercore: Add d... |
166 |
* should be triggered to be reprobed. Move all the deferred devices |
8b0372a25 driver core: mino... |
167 168 |
* into the active list so they can be retried by the workqueue */ |
d1c3414c2 drivercore: Add d... |
169 |
mutex_lock(&deferred_probe_mutex); |
58b116bce drivercore: defer... |
170 |
atomic_inc(&deferred_trigger_count); |
d1c3414c2 drivercore: Add d... |
171 172 173 |
list_splice_tail_init(&deferred_probe_pending_list, &deferred_probe_active_list); mutex_unlock(&deferred_probe_mutex); |
8b0372a25 driver core: mino... |
174 175 176 177 |
/* * Kick the re-probe thread. It may already be scheduled, but it is * safe to kick it again. */ |
2c507e464 device core: Remo... |
178 |
schedule_work(&deferred_probe_work); |
d1c3414c2 drivercore: Add d... |
179 180 181 |
} /** |
dbf03d656 driver core: fix ... |
182 |
* device_block_probing() - Block/defer device's probes |
013c074f8 PM / sleep: prohi... |
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
* * 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(); } |
28af109a5 driver core: add ... |
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
/* * deferred_devs_show() - Show the devices in the deferred probe pending list. */ static int deferred_devs_show(struct seq_file *s, void *data) { struct device_private *curr; mutex_lock(&deferred_probe_mutex); list_for_each_entry(curr, &deferred_probe_pending_list, deferred_probe) seq_printf(s, "%s ", dev_name(curr->device)); mutex_unlock(&deferred_probe_mutex); return 0; } DEFINE_SHOW_ATTRIBUTE(deferred_devs); |
25b4e70dc driver core: allo... |
222 223 224 |
static int deferred_probe_timeout = -1; static int __init deferred_probe_timeout_setup(char *str) { |
63c980470 driver core: Repl... |
225 226 227 228 |
int timeout; if (!kstrtoint(str, 10, &timeout)) deferred_probe_timeout = timeout; |
25b4e70dc driver core: allo... |
229 230 231 |
return 1; } __setup("deferred_probe_timeout=", deferred_probe_timeout_setup); |
62a6bc3a1 driver: core: All... |
232 233 234 235 236 237 238 239 240 241 242 243 |
static int __driver_deferred_probe_check_state(struct device *dev) { if (!initcalls_done) return -EPROBE_DEFER; if (!deferred_probe_timeout) { dev_WARN(dev, "deferred probe timeout, ignoring dependency"); return -ETIMEDOUT; } return 0; } |
25b4e70dc driver core: allo... |
244 245 246 247 248 249 250 251 252 253 254 255 256 |
/** * driver_deferred_probe_check_state() - Check deferred probe state * @dev: device to check * * Returns -ENODEV if init is done and all built-in drivers have had a chance * to probe (i.e. initcalls are done), -ETIMEDOUT if deferred probe debug * timeout has expired, or -EPROBE_DEFER if none of those conditions are met. * * Drivers or subsystems can opt-in to calling this function instead of directly * returning -EPROBE_DEFER. */ int driver_deferred_probe_check_state(struct device *dev) { |
62a6bc3a1 driver: core: All... |
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 |
int ret; ret = __driver_deferred_probe_check_state(dev); if (ret < 0) return ret; dev_warn(dev, "ignoring dependency for device, assuming no driver"); return -ENODEV; } /** * driver_deferred_probe_check_state_continue() - check deferred probe state * @dev: device to check * * Returns -ETIMEDOUT if deferred probe debug timeout has expired, or * -EPROBE_DEFER otherwise. * * Drivers or subsystems can opt-in to calling this function instead of * directly returning -EPROBE_DEFER. * * This is similar to driver_deferred_probe_check_state(), but it allows the * subsystem to keep deferring probe after built-in drivers have had a chance * to probe. One scenario where that is useful is if built-in drivers rely on * resources that are provided by modular drivers. */ int driver_deferred_probe_check_state_continue(struct device *dev) { int ret; ret = __driver_deferred_probe_check_state(dev); if (ret < 0) return ret; |
25b4e70dc driver core: allo... |
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 |
return -EPROBE_DEFER; } static void deferred_probe_timeout_work_func(struct work_struct *work) { struct device_private *private, *p; deferred_probe_timeout = 0; driver_deferred_probe_trigger(); flush_work(&deferred_probe_work); list_for_each_entry_safe(private, p, &deferred_probe_pending_list, deferred_probe) dev_info(private->device, "deferred probe pending"); } static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func); |
013c074f8 PM / sleep: prohi... |
305 |
/** |
d1c3414c2 drivercore: Add d... |
306 307 308 309 310 311 312 313 |
* 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) { |
28af109a5 driver core: add ... |
314 315 |
deferred_devices = debugfs_create_file("devices_deferred", 0444, NULL, NULL, &deferred_devs_fops); |
d1c3414c2 drivercore: Add d... |
316 317 |
driver_deferred_probe_enable = true; driver_deferred_probe_trigger(); |
d72cca1ee drivercore: Fix o... |
318 |
/* Sort as many dependencies as possible before exiting initcalls */ |
2c507e464 device core: Remo... |
319 |
flush_work(&deferred_probe_work); |
25b4e70dc driver core: allo... |
320 321 322 323 324 325 326 327 328 329 330 331 332 |
initcalls_done = true; /* * Trigger deferred probe again, this time we won't defer anything * that is optional */ driver_deferred_probe_trigger(); flush_work(&deferred_probe_work); if (deferred_probe_timeout > 0) { schedule_delayed_work(&deferred_probe_timeout_work, deferred_probe_timeout * HZ); } |
d1c3414c2 drivercore: Add d... |
333 334 335 |
return 0; } late_initcall(deferred_probe_initcall); |
07e4a3e27 [PATCH] Move devi... |
336 |
|
28af109a5 driver core: add ... |
337 338 339 340 341 |
static void __exit deferred_probe_exit(void) { debugfs_remove_recursive(deferred_devices); } __exitcall(deferred_probe_exit); |
6b9cb4275 device core: add ... |
342 343 344 345 346 347 348 349 350 351 352 |
/** * 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 driver core: Avoi... |
353 |
return dev->p && klist_node_attached(&dev->p->knode_driver); |
6b9cb4275 device core: add ... |
354 |
} |
1901fb260 Driver core: fix ... |
355 |
static void driver_bound(struct device *dev) |
07e4a3e27 [PATCH] Move devi... |
356 |
{ |
6b9cb4275 device core: add ... |
357 |
if (device_is_bound(dev)) { |
f86db396f drivers/base: che... |
358 359 |
printk(KERN_WARNING "%s: device %s already bound ", |
2b3a302a0 driver core: repl... |
360 |
__func__, kobject_name(&dev->kobj)); |
1901fb260 Driver core: fix ... |
361 |
return; |
f86db396f drivers/base: che... |
362 |
} |
4c898c7f2 [PATCH] Driver Co... |
363 |
|
94f8cc0ee drivers/base/dd.c... |
364 365 366 |
pr_debug("driver: '%s': %s: bound to device '%s' ", dev->driver->name, __func__, dev_name(dev)); |
116af3782 Driver core: add ... |
367 |
|
fbb88fadf driver-core: fix ... |
368 |
klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); |
9ed989537 driver core: Func... |
369 |
device_links_driver_bound(dev); |
fbb88fadf driver-core: fix ... |
370 |
|
aa8e54b55 PM / sleep: Go di... |
371 |
device_pm_check_callbacks(dev); |
8b0372a25 driver core: mino... |
372 373 374 375 |
/* * Make sure the device is no longer in one of the deferred lists and * kick off retrying all pending devices */ |
d1c3414c2 drivercore: Add d... |
376 377 |
driver_deferred_probe_del(dev); driver_deferred_probe_trigger(); |
116af3782 Driver core: add ... |
378 |
if (dev->bus) |
c6f7e72a3 driver core: remo... |
379 |
blocking_notifier_call_chain(&dev->bus->p->bus_notifier, |
116af3782 Driver core: add ... |
380 |
BUS_NOTIFY_BOUND_DRIVER, dev); |
1455cf8db driver core: emit... |
381 382 |
kobject_uevent(&dev->kobj, KOBJ_BIND); |
1901fb260 Driver core: fix ... |
383 |
} |
3c47d19ff drivers: base: ad... |
384 385 386 387 |
static ssize_t coredump_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { device_lock(dev); |
1fe56e0ca drivers: base: re... |
388 |
dev->driver->coredump(dev); |
3c47d19ff drivers: base: ad... |
389 390 391 392 393 |
device_unlock(dev); return count; } static DEVICE_ATTR_WO(coredump); |
1901fb260 Driver core: fix ... |
394 395 396 |
static int driver_sysfs_add(struct device *dev) { int ret; |
45daef0fd Driver core: Add ... |
397 398 399 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_BIND_DRIVER, dev); |
e5dd12784 Driver core: move... |
400 |
ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj, |
3c47d19ff drivers: base: ad... |
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
kobject_name(&dev->kobj)); if (ret) goto fail; ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, "driver"); if (ret) goto rm_dev; if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump || !device_create_file(dev, &dev_attr_coredump)) return 0; sysfs_remove_link(&dev->kobj, "driver"); rm_dev: sysfs_remove_link(&dev->driver->p->kobj, |
07e4a3e27 [PATCH] Move devi... |
418 |
kobject_name(&dev->kobj)); |
3c47d19ff drivers: base: ad... |
419 420 |
fail: |
f86db396f drivers/base: che... |
421 |
return ret; |
07e4a3e27 [PATCH] Move devi... |
422 |
} |
1901fb260 Driver core: fix ... |
423 424 425 426 427 |
static void driver_sysfs_remove(struct device *dev) { struct device_driver *drv = dev->driver; if (drv) { |
3c47d19ff drivers: base: ad... |
428 429 |
if (drv->coredump) device_remove_file(dev, &dev_attr_coredump); |
e5dd12784 Driver core: move... |
430 |
sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj)); |
1901fb260 Driver core: fix ... |
431 432 433 434 435 |
sysfs_remove_link(&dev->kobj, "driver"); } } /** |
4a3ad20cc Driver core: codi... |
436 437 |
* device_bind_driver - bind a driver to one device. * @dev: device. |
1901fb260 Driver core: fix ... |
438 |
* |
4a3ad20cc Driver core: codi... |
439 440 |
* Allow manual attachment of a driver to a device. * Caller must have already set @dev->driver. |
1901fb260 Driver core: fix ... |
441 |
* |
4a3ad20cc Driver core: codi... |
442 443 444 445 |
* 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 Driver core: fix ... |
446 |
* |
8e9394ce2 Driver core: crea... |
447 |
* This function must be called with the device lock held. |
1901fb260 Driver core: fix ... |
448 449 450 |
*/ int device_bind_driver(struct device *dev) { |
cb986b749 driver core: Chan... |
451 452 453 454 455 |
int ret; ret = driver_sysfs_add(dev); if (!ret) driver_bound(dev); |
14b6257a5 device core: add ... |
456 457 458 |
else if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); |
cb986b749 driver core: Chan... |
459 |
return ret; |
1901fb260 Driver core: fix ... |
460 |
} |
4a3ad20cc Driver core: codi... |
461 |
EXPORT_SYMBOL_GPL(device_bind_driver); |
1901fb260 Driver core: fix ... |
462 |
|
d779249ed Driver Core: add ... |
463 |
static atomic_t probe_count = ATOMIC_INIT(0); |
735a7ffb7 [PATCH] drivers: ... |
464 |
static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); |
0ff26c662 driver core: Fix ... |
465 466 467 468 469 470 471 472 |
static void driver_deferred_probe_add_trigger(struct device *dev, int local_trigger_count) { driver_deferred_probe_add(dev); /* 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(); } |
21c7f30b1 driver core: per-... |
473 |
static int really_probe(struct device *dev, struct device_driver *drv) |
07e4a3e27 [PATCH] Move devi... |
474 |
{ |
013c074f8 PM / sleep: prohi... |
475 |
int ret = -EPROBE_DEFER; |
58b116bce drivercore: defer... |
476 |
int local_trigger_count = atomic_read(&deferred_trigger_count); |
c5f062748 driver core: skip... |
477 478 |
bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && !drv->suppress_bind_attrs; |
07e4a3e27 [PATCH] Move devi... |
479 |
|
013c074f8 PM / sleep: prohi... |
480 481 482 |
if (defer_all_probes) { /* * Value of defer_all_probes can be set only by |
dbf03d656 driver core: fix ... |
483 |
* device_block_probing() which, in turn, will call |
013c074f8 PM / sleep: prohi... |
484 485 486 487 488 489 490 |
* 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; } |
9ed989537 driver core: Func... |
491 |
ret = device_links_check_suppliers(dev); |
0ff26c662 driver core: Fix ... |
492 493 |
if (ret == -EPROBE_DEFER) driver_deferred_probe_add_trigger(dev, local_trigger_count); |
9ed989537 driver core: Func... |
494 495 |
if (ret) return ret; |
d779249ed Driver Core: add ... |
496 |
atomic_inc(&probe_count); |
7dc72b284 Driver core: clea... |
497 498 |
pr_debug("bus: '%s': %s: probing driver %s with device %s ", |
1e0b2cf93 driver core: stru... |
499 |
drv->bus->name, __func__, drv->name, dev_name(dev)); |
a8b37e324 driver core: Prin... |
500 501 502 503 504 |
if (!list_empty(&dev->devres_head)) { dev_crit(dev, "Resources present before probing "); return -EBUSY; } |
07e4a3e27 [PATCH] Move devi... |
505 |
|
bea5b158f driver core: add ... |
506 |
re_probe: |
07e4a3e27 [PATCH] Move devi... |
507 |
dev->driver = drv; |
ab78029ec drivers/pinctrl: ... |
508 509 510 511 |
/* If using pinctrl, bind pins now before probing */ ret = pinctrl_bind_pins(dev); if (ret) |
14b6257a5 device core: add ... |
512 |
goto pinctrl_bind_failed; |
ab78029ec drivers/pinctrl: ... |
513 |
|
ccf640f4c dma-mapping: remo... |
514 515 516 |
if (dev->bus->dma_configure) { ret = dev->bus->dma_configure(dev); if (ret) |
0b777eee8 driver core: Post... |
517 |
goto probe_failed; |
ccf640f4c dma-mapping: remo... |
518 |
} |
09515ef5d of/acpi: Configur... |
519 |
|
1901fb260 Driver core: fix ... |
520 521 522 |
if (driver_sysfs_add(dev)) { printk(KERN_ERR "%s: driver_sysfs_add(%s) failed ", |
1e0b2cf93 driver core: stru... |
523 |
__func__, dev_name(dev)); |
1901fb260 Driver core: fix ... |
524 525 |
goto probe_failed; } |
e90d55327 driver core / PM:... |
526 527 528 529 530 |
if (dev->pm_domain && dev->pm_domain->activate) { ret = dev->pm_domain->activate(dev); if (ret) goto probe_failed; } |
594c8281f [PATCH] Add bus_t... |
531 532 |
if (dev->bus->probe) { ret = dev->bus->probe(dev); |
1901fb260 Driver core: fix ... |
533 |
if (ret) |
d779249ed Driver Core: add ... |
534 |
goto probe_failed; |
594c8281f [PATCH] Add bus_t... |
535 |
} else if (drv->probe) { |
0d3e5a2e3 [PATCH] Driver Co... |
536 |
ret = drv->probe(dev); |
1901fb260 Driver core: fix ... |
537 |
if (ret) |
d779249ed Driver Core: add ... |
538 |
goto probe_failed; |
f86db396f drivers/base: che... |
539 |
} |
1901fb260 Driver core: fix ... |
540 |
|
23b690444 driver core: add ... |
541 542 543 544 545 |
if (device_add_groups(dev, drv->dev_groups)) { dev_err(dev, "device_add_groups() failed "); goto dev_groups_failed; } |
bea5b158f driver core: add ... |
546 547 |
if (test_remove) { test_remove = false; |
23b690444 driver core: add ... |
548 |
device_remove_groups(dev, drv->dev_groups); |
bdacd1b42 driver core: fix ... |
549 |
if (dev->bus->remove) |
bea5b158f driver core: add ... |
550 551 552 553 554 555 556 557 558 559 560 561 562 563 |
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 drivers/pinctrl: ... |
564 |
pinctrl_init_done(dev); |
e90d55327 driver core / PM:... |
565 566 |
if (dev->pm_domain && dev->pm_domain->sync) dev->pm_domain->sync(dev); |
1901fb260 Driver core: fix ... |
567 |
driver_bound(dev); |
0d3e5a2e3 [PATCH] Driver Co... |
568 |
ret = 1; |
7dc72b284 Driver core: clea... |
569 570 |
pr_debug("bus: '%s': %s: bound device %s to driver %s ", |
1e0b2cf93 driver core: stru... |
571 |
drv->bus->name, __func__, dev_name(dev), drv->name); |
d779249ed Driver Core: add ... |
572 |
goto done; |
0d3e5a2e3 [PATCH] Driver Co... |
573 |
|
23b690444 driver core: add ... |
574 575 576 577 578 |
dev_groups_failed: if (dev->bus->remove) dev->bus->remove(dev); else if (drv->remove) drv->remove(dev); |
d779249ed Driver Core: add ... |
579 |
probe_failed: |
14b6257a5 device core: add ... |
580 581 582 583 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); pinctrl_bind_failed: |
9ed989537 driver core: Func... |
584 |
device_links_no_driver(dev); |
9ac7849e3 devres: device re... |
585 |
devres_release_all(dev); |
0b777eee8 driver core: Post... |
586 |
arch_teardown_dma_ops(dev); |
1901fb260 Driver core: fix ... |
587 588 |
driver_sysfs_remove(dev); dev->driver = NULL; |
0998d0631 device-core: Ensu... |
589 |
dev_set_drvdata(dev, NULL); |
e90d55327 driver core / PM:... |
590 591 |
if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); |
5de85b9d5 PM / runtime: Re-... |
592 |
pm_runtime_reinit(dev); |
08810a411 PM / core: Add NE... |
593 |
dev_pm_set_driver_flags(dev, 0); |
1901fb260 Driver core: fix ... |
594 |
|
bb2b40754 driver core: use ... |
595 596 |
switch (ret) { case -EPROBE_DEFER: |
d1c3414c2 drivercore: Add d... |
597 |
/* Driver requested deferred probing */ |
13fcffbbd driver core: Make... |
598 599 |
dev_dbg(dev, "Driver %s requests probe deferral ", drv->name); |
0ff26c662 driver core: Fix ... |
600 |
driver_deferred_probe_add_trigger(dev, local_trigger_count); |
bb2b40754 driver core: use ... |
601 602 603 604 605 606 607 608 |
break; case -ENODEV: case -ENXIO: pr_debug("%s: probe of %s rejects match %d ", drv->name, dev_name(dev), ret); break; default: |
0d3e5a2e3 [PATCH] Driver Co... |
609 610 611 612 |
/* driver matched but the probe failed */ printk(KERN_WARNING "%s: probe of %s failed with error %d ", |
1e0b2cf93 driver core: stru... |
613 |
drv->name, dev_name(dev), ret); |
0d3e5a2e3 [PATCH] Driver Co... |
614 |
} |
c578abbc2 driver core: Don'... |
615 616 617 618 619 |
/* * Ignore errors returned by ->probe so that the next driver can try * its luck. */ ret = 0; |
d779249ed Driver Core: add ... |
620 |
done: |
d779249ed Driver Core: add ... |
621 |
atomic_dec(&probe_count); |
735a7ffb7 [PATCH] drivers: ... |
622 |
wake_up(&probe_waitqueue); |
d779249ed Driver Core: add ... |
623 624 |
return ret; } |
0a50f61c4 drivers: base: in... |
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 |
/* * For initcall_debug, show the driver probe time. */ static int really_probe_debug(struct device *dev, struct device_driver *drv) { ktime_t calltime, delta, rettime; int ret; calltime = ktime_get(); ret = really_probe(dev, drv); rettime = ktime_get(); delta = ktime_sub(rettime, calltime); printk(KERN_DEBUG "probe of %s returned %d after %lld usecs ", dev_name(dev), ret, (s64) ktime_to_us(delta)); return ret; } |
d779249ed Driver Core: add ... |
642 643 644 645 646 647 648 649 |
/** * 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 driver core: repl... |
650 651 |
pr_debug("%s: probe_count = %d ", __func__, |
d779249ed Driver Core: add ... |
652 653 654 655 656 657 658 |
atomic_read(&probe_count)); if (atomic_read(&probe_count)) return -EBUSY; return 0; } /** |
216773a78 Consolidate drive... |
659 660 |
* wait_for_device_probe * Wait for device probing to be completed. |
216773a78 Consolidate drive... |
661 |
*/ |
b23530ebc driver core: remo... |
662 |
void wait_for_device_probe(void) |
216773a78 Consolidate drive... |
663 |
{ |
013c074f8 PM / sleep: prohi... |
664 |
/* wait for the deferred probe workqueue to finish */ |
2c507e464 device core: Remo... |
665 |
flush_work(&deferred_probe_work); |
013c074f8 PM / sleep: prohi... |
666 |
|
216773a78 Consolidate drive... |
667 |
/* wait for the known devices to complete their probing */ |
b23530ebc driver core: remo... |
668 |
wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); |
216773a78 Consolidate drive... |
669 |
async_synchronize_full(); |
216773a78 Consolidate drive... |
670 |
} |
d4d5291c8 driver synchroniz... |
671 |
EXPORT_SYMBOL_GPL(wait_for_device_probe); |
216773a78 Consolidate drive... |
672 673 |
/** |
d779249ed Driver Core: add ... |
674 675 676 677 |
* 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 driver core: chec... |
678 |
* This function returns -ENODEV if the device is not registered, |
af901ca18 tree-wide: fix as... |
679 |
* 1 if the device is bound successfully and 0 otherwise. |
d779249ed Driver Core: add ... |
680 |
* |
8e9394ce2 Driver core: crea... |
681 682 |
* This function must be called with @dev lock held. When called for a * USB interface, @dev->parent lock must be held as well. |
ddef08dd0 Driver core: wake... |
683 684 |
* * If the device has a parent, runtime-resume the parent before driver probing. |
d779249ed Driver Core: add ... |
685 |
*/ |
4a3ad20cc Driver core: codi... |
686 |
int driver_probe_device(struct device_driver *drv, struct device *dev) |
d779249ed Driver Core: add ... |
687 |
{ |
d779249ed Driver Core: add ... |
688 |
int ret = 0; |
f2eaae197 Driver core: Fix ... |
689 690 |
if (!device_is_registered(dev)) return -ENODEV; |
d779249ed Driver Core: add ... |
691 |
|
7dc72b284 Driver core: clea... |
692 693 |
pr_debug("bus: '%s': %s: matched device %s with driver %s ", |
1e0b2cf93 driver core: stru... |
694 |
drv->bus->name, __func__, dev_name(dev), drv->name); |
d779249ed Driver Core: add ... |
695 |
|
b06c0b2f0 Revert "PM / runt... |
696 |
pm_runtime_get_suppliers(dev); |
ddef08dd0 Driver core: wake... |
697 698 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
5e928f77a PM: Introduce cor... |
699 |
pm_runtime_barrier(dev); |
0a50f61c4 drivers: base: in... |
700 701 702 703 |
if (initcall_debug) ret = really_probe_debug(dev, drv); else ret = really_probe(dev, drv); |
fa180eb44 PM / Runtime: Idl... |
704 |
pm_request_idle(dev); |
d779249ed Driver Core: add ... |
705 |
|
ddef08dd0 Driver core: wake... |
706 707 |
if (dev->parent) pm_runtime_put(dev->parent); |
b06c0b2f0 Revert "PM / runt... |
708 |
pm_runtime_put_suppliers(dev); |
0d3e5a2e3 [PATCH] Driver Co... |
709 |
return ret; |
07e4a3e27 [PATCH] Move devi... |
710 |
} |
1ea61b68d async: Add cmdlin... |
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 |
static inline bool cmdline_requested_async_probing(const char *drv_name) { return parse_option_str(async_probe_drv_names, drv_name); } /* The option format is "driver_async_probe=drv_name1,drv_name2,..." */ static int __init save_async_options(char *buf) { if (strlen(buf) >= ASYNC_DRV_NAMES_MAX_LEN) printk(KERN_WARNING "Too long list of driver names for 'driver_async_probe'! "); strlcpy(async_probe_drv_names, buf, ASYNC_DRV_NAMES_MAX_LEN); return 0; } __setup("driver_async_probe=", save_async_options); |
765230b5f driver-core: add ... |
728 |
bool driver_allows_async_probing(struct device_driver *drv) |
2287c322b [PATCH] Use bus_f... |
729 |
{ |
d173a137c driver-core: enab... |
730 731 |
switch (drv->probe_type) { case PROBE_PREFER_ASYNCHRONOUS: |
f2411da74 driver-core: add ... |
732 |
return true; |
d173a137c driver-core: enab... |
733 734 735 736 |
case PROBE_FORCE_SYNCHRONOUS: return false; default: |
1ea61b68d async: Add cmdlin... |
737 738 |
if (cmdline_requested_async_probing(drv->name)) return true; |
80c6e1465 driver-core: fix ... |
739 |
if (module_requested_async_probing(drv->owner)) |
d173a137c driver-core: enab... |
740 |
return true; |
f2411da74 driver-core: add ... |
741 |
|
d173a137c driver-core: enab... |
742 743 |
return false; } |
765230b5f driver-core: add ... |
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 |
} 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 ARM: 8524/1: driv... |
784 |
int ret; |
765230b5f driver-core: add ... |
785 |
|
656b8035b ARM: 8524/1: driv... |
786 787 788 |
ret = driver_match_device(drv, dev); if (ret == 0) { /* no match */ |
49b420a13 driver core: chec... |
789 |
return 0; |
656b8035b ARM: 8524/1: driv... |
790 791 792 793 794 795 796 797 |
} 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 driver core: chec... |
798 |
|
765230b5f driver-core: add ... |
799 800 801 802 803 804 805 |
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 [PATCH] Driver Co... |
806 |
return driver_probe_device(drv, dev); |
2287c322b [PATCH] Use bus_f... |
807 |
} |
765230b5f driver-core: add ... |
808 809 810 811 812 813 814 815 816 817 |
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); |
3451a495e driver core: Esta... |
818 819 820 821 822 823 824 825 |
/* * Check if device has already been removed or claimed. This may * happen with driver loading, device discovery/registration, * and deferred probe processing happens all at once with * multiple threads. */ if (dev->p->dead || dev->driver) goto out_unlock; |
ddef08dd0 Driver core: wake... |
826 827 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
765230b5f driver-core: add ... |
828 829 830 831 832 |
bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver); dev_dbg(dev, "async probe completed "); pm_request_idle(dev); |
ddef08dd0 Driver core: wake... |
833 834 |
if (dev->parent) pm_runtime_put(dev->parent); |
3451a495e driver core: Esta... |
835 |
out_unlock: |
765230b5f driver-core: add ... |
836 837 838 839 |
device_unlock(dev); put_device(dev); } |
802a87fd5 driver-core: make... |
840 |
static int __device_attach(struct device *dev, bool allow_async) |
07e4a3e27 [PATCH] Move devi... |
841 |
{ |
0d3e5a2e3 [PATCH] Driver Co... |
842 |
int ret = 0; |
8e9394ce2 Driver core: crea... |
843 |
device_lock(dev); |
07e4a3e27 [PATCH] Move devi... |
844 |
if (dev->driver) { |
6b9cb4275 device core: add ... |
845 |
if (device_is_bound(dev)) { |
8497d6a21 driver-core: fix ... |
846 847 848 |
ret = 1; goto out_unlock; } |
f86db396f drivers/base: che... |
849 850 851 |
ret = device_bind_driver(dev); if (ret == 0) ret = 1; |
c6a46696f driver core: don'... |
852 853 854 855 |
else { dev->driver = NULL; ret = 0; } |
21c7f30b1 driver core: per-... |
856 |
} else { |
765230b5f driver-core: add ... |
857 858 859 860 861 |
struct device_attach_data data = { .dev = dev, .check_async = allow_async, .want_async = false, }; |
ddef08dd0 Driver core: wake... |
862 863 |
if (dev->parent) pm_runtime_get_sync(dev->parent); |
765230b5f driver-core: add ... |
864 865 866 867 868 869 870 871 872 873 874 875 876 |
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); |
c37e20eaf driver core: Atta... |
877 |
async_schedule_dev(__device_attach_async_helper, dev); |
765230b5f driver-core: add ... |
878 879 880 |
} else { pm_request_idle(dev); } |
ddef08dd0 Driver core: wake... |
881 882 883 |
if (dev->parent) pm_runtime_put(dev->parent); |
21c7f30b1 driver core: per-... |
884 |
} |
8497d6a21 driver-core: fix ... |
885 |
out_unlock: |
8e9394ce2 Driver core: crea... |
886 |
device_unlock(dev); |
0d3e5a2e3 [PATCH] Driver Co... |
887 |
return ret; |
2287c322b [PATCH] Use bus_f... |
888 |
} |
765230b5f driver-core: add ... |
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 |
/** * 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 Driver core: codi... |
908 |
EXPORT_SYMBOL_GPL(device_attach); |
2287c322b [PATCH] Use bus_f... |
909 |
|
765230b5f driver-core: add ... |
910 911 912 913 |
void device_initial_probe(struct device *dev) { __device_attach(dev, true); } |
ed88747c6 device core: Cons... |
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 |
/* * __device_driver_lock - acquire locks needed to manipulate dev->drv * @dev: Device we will update driver info for * @parent: Parent device. Needed if the bus requires parent lock * * This function will take the required locks for manipulating dev->drv. * Normally this will just be the @dev lock, but when called for a USB * interface, @parent lock will be held as well. */ static void __device_driver_lock(struct device *dev, struct device *parent) { if (parent && dev->bus->need_parent_lock) device_lock(parent); device_lock(dev); } /* * __device_driver_unlock - release locks needed to manipulate dev->drv * @dev: Device we will update driver info for * @parent: Parent device. Needed if the bus requires parent lock * * This function will release the required locks for manipulating dev->drv. * Normally this will just be the the @dev lock, but when called for a * USB interface, @parent lock will be released as well. */ static void __device_driver_unlock(struct device *dev, struct device *parent) { device_unlock(dev); if (parent && dev->bus->need_parent_lock) device_unlock(parent); } /** * device_driver_attach - attach a specific driver to a specific device * @drv: Driver to attach * @dev: Device to attach it to * * Manually attach driver to a device. Will acquire both @dev lock and * @dev->parent lock if needed. */ int device_driver_attach(struct device_driver *drv, struct device *dev) { int ret = 0; __device_driver_lock(dev, dev->parent); /* * If device has been removed or someone has already successfully * bound a driver before us just skip the driver probe call. */ if (!dev->p->dead && !dev->driver) ret = driver_probe_device(drv, dev); __device_driver_unlock(dev, dev->parent); return ret; } |
ef0ff6835 driver core: Prob... |
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 |
static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie) { struct device *dev = _dev; struct device_driver *drv; int ret = 0; __device_driver_lock(dev, dev->parent); drv = dev->p->async_driver; /* * If device has been removed or someone has already successfully * bound a driver before us just skip the driver probe call. */ if (!dev->p->dead && !dev->driver) ret = driver_probe_device(drv, dev); __device_driver_unlock(dev, dev->parent); dev_dbg(dev, "driver %s async attach completed: %d ", drv->name, ret); put_device(dev); } |
4a3ad20cc Driver core: codi... |
995 |
static int __driver_attach(struct device *dev, void *data) |
2287c322b [PATCH] Use bus_f... |
996 |
{ |
4a3ad20cc Driver core: codi... |
997 |
struct device_driver *drv = data; |
656b8035b ARM: 8524/1: driv... |
998 |
int ret; |
0d3e5a2e3 [PATCH] Driver Co... |
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 |
/* * 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 ARM: 8524/1: driv... |
1009 1010 1011 |
ret = driver_match_device(drv, dev); if (ret == 0) { /* no match */ |
6cd495860 device model: Do ... |
1012 |
return 0; |
656b8035b ARM: 8524/1: driv... |
1013 1014 1015 1016 1017 1018 1019 1020 |
} 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 device model: Do ... |
1021 |
|
ef0ff6835 driver core: Prob... |
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 |
if (driver_allows_async_probing(drv)) { /* * Instead of probing the device synchronously we will * probe it asynchronously to allow for more parallelism. * * We only take the device lock here in order to guarantee * that the dev->driver and async_driver fields are protected */ dev_dbg(dev, "probing driver %s asynchronously ", drv->name); device_lock(dev); if (!dev->driver) { get_device(dev); dev->p->async_driver = drv; |
c37e20eaf driver core: Atta... |
1036 |
async_schedule_dev(__driver_attach_async_helper, dev); |
ef0ff6835 driver core: Prob... |
1037 1038 1039 1040 |
} device_unlock(dev); return 0; } |
ed88747c6 device core: Cons... |
1041 |
device_driver_attach(drv, dev); |
0d3e5a2e3 [PATCH] Driver Co... |
1042 |
|
07e4a3e27 [PATCH] Move devi... |
1043 1044 1045 1046 |
return 0; } /** |
4a3ad20cc Driver core: codi... |
1047 1048 |
* driver_attach - try to bind driver to devices. * @drv: driver. |
07e4a3e27 [PATCH] Move devi... |
1049 |
* |
4a3ad20cc Driver core: codi... |
1050 1051 1052 1053 |
* 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 [PATCH] Move devi... |
1054 |
*/ |
4a3ad20cc Driver core: codi... |
1055 |
int driver_attach(struct device_driver *drv) |
07e4a3e27 [PATCH] Move devi... |
1056 |
{ |
f86db396f drivers/base: che... |
1057 |
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); |
07e4a3e27 [PATCH] Move devi... |
1058 |
} |
4a3ad20cc Driver core: codi... |
1059 |
EXPORT_SYMBOL_GPL(driver_attach); |
07e4a3e27 [PATCH] Move devi... |
1060 |
|
ab71c6f07 driver core: fix ... |
1061 |
/* |
8e9394ce2 Driver core: crea... |
1062 1063 |
* __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 [PATCH] Move devi... |
1064 |
*/ |
9ed989537 driver core: Func... |
1065 |
static void __device_release_driver(struct device *dev, struct device *parent) |
07e4a3e27 [PATCH] Move devi... |
1066 |
{ |
4a3ad20cc Driver core: codi... |
1067 |
struct device_driver *drv; |
07e4a3e27 [PATCH] Move devi... |
1068 |
|
ef2c51746 Driver core: fix ... |
1069 |
drv = dev->driver; |
c95a6b057 [PATCH] driver co... |
1070 |
if (drv) { |
9ed989537 driver core: Func... |
1071 |
while (device_links_busy(dev)) { |
ed88747c6 device core: Cons... |
1072 |
__device_driver_unlock(dev, parent); |
9ed989537 driver core: Func... |
1073 1074 |
device_links_unbind_consumers(dev); |
9ed989537 driver core: Func... |
1075 |
|
ed88747c6 device core: Cons... |
1076 |
__device_driver_lock(dev, parent); |
9ed989537 driver core: Func... |
1077 1078 1079 1080 1081 1082 1083 1084 |
/* * A concurrent invocation of the same function might * have released the driver successfully while this one * was waiting, so check for that. */ if (dev->driver != drv) return; } |
e1866b33b PM / Runtime: Rew... |
1085 |
pm_runtime_get_sync(dev); |
21d5c57b3 PM / runtime: Use... |
1086 |
pm_runtime_clean_up_links(dev); |
5e928f77a PM: Introduce cor... |
1087 |
|
1901fb260 Driver core: fix ... |
1088 |
driver_sysfs_remove(dev); |
0d3e5a2e3 [PATCH] Driver Co... |
1089 |
|
116af3782 Driver core: add ... |
1090 |
if (dev->bus) |
c6f7e72a3 driver core: remo... |
1091 |
blocking_notifier_call_chain(&dev->bus->p->bus_notifier, |
116af3782 Driver core: add ... |
1092 1093 |
BUS_NOTIFY_UNBIND_DRIVER, dev); |
baab52ded PM / runtime: Use... |
1094 |
pm_runtime_put_sync(dev); |
e1866b33b PM / Runtime: Rew... |
1095 |
|
23b690444 driver core: add ... |
1096 |
device_remove_groups(dev, drv->dev_groups); |
0f836ca4c [PATCH] driver co... |
1097 |
if (dev->bus && dev->bus->remove) |
594c8281f [PATCH] Add bus_t... |
1098 1099 |
dev->bus->remove(dev); else if (drv->remove) |
0d3e5a2e3 [PATCH] Driver Co... |
1100 |
drv->remove(dev); |
9ed989537 driver core: Func... |
1101 1102 |
device_links_driver_cleanup(dev); |
09515ef5d of/acpi: Configur... |
1103 |
|
9ac7849e3 devres: device re... |
1104 |
devres_release_all(dev); |
376991db4 driver core: Post... |
1105 |
arch_teardown_dma_ops(dev); |
0d3e5a2e3 [PATCH] Driver Co... |
1106 |
dev->driver = NULL; |
0998d0631 device-core: Ensu... |
1107 |
dev_set_drvdata(dev, NULL); |
e90d55327 driver core / PM:... |
1108 1109 |
if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); |
5de85b9d5 PM / runtime: Re-... |
1110 |
pm_runtime_reinit(dev); |
08810a411 PM / core: Add NE... |
1111 |
dev_pm_set_driver_flags(dev, 0); |
e90d55327 driver core / PM:... |
1112 |
|
8940b4f31 driver core: move... |
1113 |
klist_remove(&dev->p->knode_driver); |
aa8e54b55 PM / sleep: Go di... |
1114 |
device_pm_check_callbacks(dev); |
309b7d60a driver core: add ... |
1115 1116 1117 1118 |
if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_UNBOUND_DRIVER, dev); |
1455cf8db driver core: emit... |
1119 1120 |
kobject_uevent(&dev->kobj, KOBJ_UNBIND); |
0d3e5a2e3 [PATCH] Driver Co... |
1121 |
} |
07e4a3e27 [PATCH] Move devi... |
1122 |
} |
9ed989537 driver core: Func... |
1123 1124 1125 |
void device_release_driver_internal(struct device *dev, struct device_driver *drv, struct device *parent) |
4bdb35506 driver core: Add ... |
1126 |
{ |
ed88747c6 device core: Cons... |
1127 |
__device_driver_lock(dev, parent); |
4bdb35506 driver core: Add ... |
1128 |
|
4bdb35506 driver core: Add ... |
1129 |
if (!drv || drv == dev->driver) |
9ed989537 driver core: Func... |
1130 |
__device_release_driver(dev, parent); |
4bdb35506 driver core: Add ... |
1131 |
|
ed88747c6 device core: Cons... |
1132 |
__device_driver_unlock(dev, parent); |
4bdb35506 driver core: Add ... |
1133 |
} |
ab71c6f07 driver core: fix ... |
1134 |
/** |
4a3ad20cc Driver core: codi... |
1135 1136 |
* device_release_driver - manually detach device from driver. * @dev: device. |
ab71c6f07 driver core: fix ... |
1137 |
* |
4a3ad20cc Driver core: codi... |
1138 |
* Manually detach device from driver. |
8e9394ce2 Driver core: crea... |
1139 |
* When called for a USB interface, @dev->parent lock must be held. |
9ed989537 driver core: Func... |
1140 1141 1142 1143 |
* * If this function is to be called with @dev->parent lock held, ensure that * the device's consumers are unbound in advance or that their locks can be * acquired under the @dev->parent lock. |
ab71c6f07 driver core: fix ... |
1144 |
*/ |
4a3ad20cc Driver core: codi... |
1145 |
void device_release_driver(struct device *dev) |
94e7b1c5f [PATCH] Add a kli... |
1146 |
{ |
c95a6b057 [PATCH] driver co... |
1147 1148 1149 1150 1151 |
/* * If anyone calls device_release_driver() recursively from * within their ->remove callback for the same device, they * will deadlock right here. */ |
4bdb35506 driver core: Add ... |
1152 |
device_release_driver_internal(dev, NULL, NULL); |
94e7b1c5f [PATCH] Add a kli... |
1153 |
} |
4a3ad20cc Driver core: codi... |
1154 |
EXPORT_SYMBOL_GPL(device_release_driver); |
c95a6b057 [PATCH] driver co... |
1155 |
|
07e4a3e27 [PATCH] Move devi... |
1156 |
/** |
ed88747c6 device core: Cons... |
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 |
* device_driver_detach - detach driver from a specific device * @dev: device to detach driver from * * Detach driver from device. Will acquire both @dev lock and @dev->parent * lock if needed. */ void device_driver_detach(struct device *dev) { device_release_driver_internal(dev, NULL, dev->parent); } /** |
07e4a3e27 [PATCH] Move devi... |
1169 1170 1171 |
* driver_detach - detach driver from all devices it controls. * @drv: driver. */ |
4a3ad20cc Driver core: codi... |
1172 |
void driver_detach(struct device_driver *drv) |
07e4a3e27 [PATCH] Move devi... |
1173 |
{ |
8940b4f31 driver core: move... |
1174 |
struct device_private *dev_prv; |
4a3ad20cc Driver core: codi... |
1175 |
struct device *dev; |
c95a6b057 [PATCH] driver co... |
1176 |
|
c37d721c6 driver core: Move... |
1177 1178 |
if (driver_allows_async_probing(drv)) async_synchronize_full(); |
c95a6b057 [PATCH] driver co... |
1179 |
for (;;) { |
e5dd12784 Driver core: move... |
1180 1181 1182 |
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 [PATCH] driver co... |
1183 1184 |
break; } |
8940b4f31 driver core: move... |
1185 1186 1187 1188 |
dev_prv = list_entry(drv->p->klist_devices.k_list.prev, struct device_private, knode_driver.n_node); dev = dev_prv->device; |
c95a6b057 [PATCH] driver co... |
1189 |
get_device(dev); |
e5dd12784 Driver core: move... |
1190 |
spin_unlock(&drv->p->klist_devices.k_lock); |
4bdb35506 driver core: Add ... |
1191 |
device_release_driver_internal(dev, drv, dev->parent); |
c95a6b057 [PATCH] driver co... |
1192 1193 |
put_device(dev); } |
07e4a3e27 [PATCH] Move devi... |
1194 |
} |