1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * drivers/base/dd.c - The core device/driver interactions. |
4 | * |
5 | * This file contains the (sometimes tricky) code that controls the |
6 | * interactions between devices and drivers, which primarily includes |
7 | * driver binding and unbinding. |
8 | * |
9 | * All of this code used to exist in drivers/base/bus.c, but was |
10 | * relocated to here in the name of compartmentalization (since it wasn't |
11 | * strictly code just for the 'struct bus_type'. |
12 | * |
13 | * Copyright (c) 2002-5 Patrick Mochel |
14 | * Copyright (c) 2002-3 Open Source Development Labs |
15 | * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de> |
16 | * Copyright (c) 2007-2009 Novell Inc. |
17 | */ |
18 | |
19 | #include <linux/debugfs.h> |
20 | #include <linux/device.h> |
21 | #include <linux/delay.h> |
22 | #include <linux/dma-map-ops.h> |
23 | #include <linux/init.h> |
24 | #include <linux/module.h> |
25 | #include <linux/kthread.h> |
26 | #include <linux/wait.h> |
27 | #include <linux/async.h> |
28 | #include <linux/pm_runtime.h> |
29 | #include <linux/pinctrl/devinfo.h> |
30 | #include <linux/slab.h> |
31 | |
32 | #include "base.h" |
33 | #include "power/power.h" |
34 | |
35 | /* |
36 | * Deferred Probe infrastructure. |
37 | * |
38 | * Sometimes driver probe order matters, but the kernel doesn't always have |
39 | * dependency information which means some drivers will get probed before a |
40 | * resource it depends on is available. For example, an SDHCI driver may |
41 | * first need a GPIO line from an i2c GPIO controller before it can be |
42 | * initialized. If a required resource is not available yet, a driver can |
43 | * request probing to be deferred by returning -EPROBE_DEFER from its probe hook |
44 | * |
45 | * Deferred probe maintains two lists of devices, a pending list and an active |
46 | * list. A driver returning -EPROBE_DEFER causes the device to be added to the |
47 | * pending list. A successful driver probe will trigger moving all devices |
48 | * from the pending to the active list so that the workqueue will eventually |
49 | * retry them. |
50 | * |
51 | * The deferred_probe_mutex must be held any time the deferred_probe_*_list |
52 | * of the (struct device*)->p->deferred_probe pointers are manipulated |
53 | */ |
54 | static DEFINE_MUTEX(deferred_probe_mutex); |
55 | static LIST_HEAD(deferred_probe_pending_list); |
56 | static LIST_HEAD(deferred_probe_active_list); |
57 | static atomic_t deferred_trigger_count = ATOMIC_INIT(0); |
58 | static bool initcalls_done; |
59 | |
60 | /* Save the async probe drivers' name from kernel cmdline */ |
61 | #define ASYNC_DRV_NAMES_MAX_LEN 256 |
62 | static char async_probe_drv_names[ASYNC_DRV_NAMES_MAX_LEN]; |
63 | static bool async_probe_default; |
64 | |
65 | /* |
66 | * In some cases, like suspend to RAM or hibernation, It might be reasonable |
67 | * to prohibit probing of devices as it could be unsafe. |
68 | * Once defer_all_probes is true all drivers probes will be forcibly deferred. |
69 | */ |
70 | static bool defer_all_probes; |
71 | |
72 | static void __device_set_deferred_probe_reason(const struct device *dev, char *reason) |
73 | { |
74 | kfree(objp: dev->p->deferred_probe_reason); |
75 | dev->p->deferred_probe_reason = reason; |
76 | } |
77 | |
78 | /* |
79 | * deferred_probe_work_func() - Retry probing devices in the active list. |
80 | */ |
81 | static void deferred_probe_work_func(struct work_struct *work) |
82 | { |
83 | struct device *dev; |
84 | struct device_private *private; |
85 | /* |
86 | * This block processes every device in the deferred 'active' list. |
87 | * Each device is removed from the active list and passed to |
88 | * bus_probe_device() to re-attempt the probe. The loop continues |
89 | * until every device in the active list is removed and retried. |
90 | * |
91 | * Note: Once the device is removed from the list and the mutex is |
92 | * released, it is possible for the device get freed by another thread |
93 | * and cause a illegal pointer dereference. This code uses |
94 | * get/put_device() to ensure the device structure cannot disappear |
95 | * from under our feet. |
96 | */ |
97 | mutex_lock(&deferred_probe_mutex); |
98 | while (!list_empty(head: &deferred_probe_active_list)) { |
99 | private = list_first_entry(&deferred_probe_active_list, |
100 | typeof(*dev->p), deferred_probe); |
101 | dev = private->device; |
102 | list_del_init(entry: &private->deferred_probe); |
103 | |
104 | get_device(dev); |
105 | |
106 | __device_set_deferred_probe_reason(dev, NULL); |
107 | |
108 | /* |
109 | * Drop the mutex while probing each device; the probe path may |
110 | * manipulate the deferred list |
111 | */ |
112 | mutex_unlock(lock: &deferred_probe_mutex); |
113 | |
114 | /* |
115 | * Force the device to the end of the dpm_list since |
116 | * the PM code assumes that the order we add things to |
117 | * the list is a good order for suspend but deferred |
118 | * probe makes that very unsafe. |
119 | */ |
120 | device_pm_move_to_tail(dev); |
121 | |
122 | dev_dbg(dev, "Retrying from deferred list\n" ); |
123 | bus_probe_device(dev); |
124 | mutex_lock(&deferred_probe_mutex); |
125 | |
126 | put_device(dev); |
127 | } |
128 | mutex_unlock(lock: &deferred_probe_mutex); |
129 | } |
130 | static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); |
131 | |
132 | void driver_deferred_probe_add(struct device *dev) |
133 | { |
134 | if (!dev->can_match) |
135 | return; |
136 | |
137 | mutex_lock(&deferred_probe_mutex); |
138 | if (list_empty(head: &dev->p->deferred_probe)) { |
139 | dev_dbg(dev, "Added to deferred list\n" ); |
140 | list_add_tail(new: &dev->p->deferred_probe, head: &deferred_probe_pending_list); |
141 | } |
142 | mutex_unlock(lock: &deferred_probe_mutex); |
143 | } |
144 | |
145 | void driver_deferred_probe_del(struct device *dev) |
146 | { |
147 | mutex_lock(&deferred_probe_mutex); |
148 | if (!list_empty(head: &dev->p->deferred_probe)) { |
149 | dev_dbg(dev, "Removed from deferred list\n" ); |
150 | list_del_init(entry: &dev->p->deferred_probe); |
151 | __device_set_deferred_probe_reason(dev, NULL); |
152 | } |
153 | mutex_unlock(lock: &deferred_probe_mutex); |
154 | } |
155 | |
156 | static bool driver_deferred_probe_enable; |
157 | /** |
158 | * driver_deferred_probe_trigger() - Kick off re-probing deferred devices |
159 | * |
160 | * This functions moves all devices from the pending list to the active |
161 | * list and schedules the deferred probe workqueue to process them. It |
162 | * should be called anytime a driver is successfully bound to a device. |
163 | * |
164 | * Note, there is a race condition in multi-threaded probe. In the case where |
165 | * more than one device is probing at the same time, it is possible for one |
166 | * probe to complete successfully while another is about to defer. If the second |
167 | * depends on the first, then it will get put on the pending list after the |
168 | * trigger event has already occurred and will be stuck there. |
169 | * |
170 | * The atomic 'deferred_trigger_count' is used to determine if a successful |
171 | * trigger has occurred in the midst of probing a driver. If the trigger count |
172 | * changes in the midst of a probe, then deferred processing should be triggered |
173 | * again. |
174 | */ |
175 | void driver_deferred_probe_trigger(void) |
176 | { |
177 | if (!driver_deferred_probe_enable) |
178 | return; |
179 | |
180 | /* |
181 | * A successful probe means that all the devices in the pending list |
182 | * should be triggered to be reprobed. Move all the deferred devices |
183 | * into the active list so they can be retried by the workqueue |
184 | */ |
185 | mutex_lock(&deferred_probe_mutex); |
186 | atomic_inc(v: &deferred_trigger_count); |
187 | list_splice_tail_init(list: &deferred_probe_pending_list, |
188 | head: &deferred_probe_active_list); |
189 | mutex_unlock(lock: &deferred_probe_mutex); |
190 | |
191 | /* |
192 | * Kick the re-probe thread. It may already be scheduled, but it is |
193 | * safe to kick it again. |
194 | */ |
195 | queue_work(wq: system_unbound_wq, work: &deferred_probe_work); |
196 | } |
197 | |
198 | /** |
199 | * device_block_probing() - Block/defer device's probes |
200 | * |
201 | * It will disable probing of devices and defer their probes instead. |
202 | */ |
203 | void device_block_probing(void) |
204 | { |
205 | defer_all_probes = true; |
206 | /* sync with probes to avoid races. */ |
207 | wait_for_device_probe(); |
208 | } |
209 | |
210 | /** |
211 | * device_unblock_probing() - Unblock/enable device's probes |
212 | * |
213 | * It will restore normal behavior and trigger re-probing of deferred |
214 | * devices. |
215 | */ |
216 | void device_unblock_probing(void) |
217 | { |
218 | defer_all_probes = false; |
219 | driver_deferred_probe_trigger(); |
220 | } |
221 | |
222 | /** |
223 | * device_set_deferred_probe_reason() - Set defer probe reason message for device |
224 | * @dev: the pointer to the struct device |
225 | * @vaf: the pointer to va_format structure with message |
226 | */ |
227 | void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf) |
228 | { |
229 | const char *drv = dev_driver_string(dev); |
230 | char *reason; |
231 | |
232 | mutex_lock(&deferred_probe_mutex); |
233 | |
234 | reason = kasprintf(GFP_KERNEL, fmt: "%s: %pV" , drv, vaf); |
235 | __device_set_deferred_probe_reason(dev, reason); |
236 | |
237 | mutex_unlock(lock: &deferred_probe_mutex); |
238 | } |
239 | |
240 | /* |
241 | * deferred_devs_show() - Show the devices in the deferred probe pending list. |
242 | */ |
243 | static int deferred_devs_show(struct seq_file *s, void *data) |
244 | { |
245 | struct device_private *curr; |
246 | |
247 | mutex_lock(&deferred_probe_mutex); |
248 | |
249 | list_for_each_entry(curr, &deferred_probe_pending_list, deferred_probe) |
250 | seq_printf(m: s, fmt: "%s\t%s" , dev_name(dev: curr->device), |
251 | curr->device->p->deferred_probe_reason ?: "\n" ); |
252 | |
253 | mutex_unlock(lock: &deferred_probe_mutex); |
254 | |
255 | return 0; |
256 | } |
257 | DEFINE_SHOW_ATTRIBUTE(deferred_devs); |
258 | |
259 | #ifdef CONFIG_MODULES |
260 | static int driver_deferred_probe_timeout = 10; |
261 | #else |
262 | static int driver_deferred_probe_timeout; |
263 | #endif |
264 | |
265 | static int __init deferred_probe_timeout_setup(char *str) |
266 | { |
267 | int timeout; |
268 | |
269 | if (!kstrtoint(s: str, base: 10, res: &timeout)) |
270 | driver_deferred_probe_timeout = timeout; |
271 | return 1; |
272 | } |
273 | __setup("deferred_probe_timeout=" , deferred_probe_timeout_setup); |
274 | |
275 | /** |
276 | * driver_deferred_probe_check_state() - Check deferred probe state |
277 | * @dev: device to check |
278 | * |
279 | * Return: |
280 | * * -ENODEV if initcalls have completed and modules are disabled. |
281 | * * -ETIMEDOUT if the deferred probe timeout was set and has expired |
282 | * and modules are enabled. |
283 | * * -EPROBE_DEFER in other cases. |
284 | * |
285 | * Drivers or subsystems can opt-in to calling this function instead of directly |
286 | * returning -EPROBE_DEFER. |
287 | */ |
288 | int driver_deferred_probe_check_state(struct device *dev) |
289 | { |
290 | if (!IS_ENABLED(CONFIG_MODULES) && initcalls_done) { |
291 | dev_warn(dev, "ignoring dependency for device, assuming no driver\n" ); |
292 | return -ENODEV; |
293 | } |
294 | |
295 | if (!driver_deferred_probe_timeout && initcalls_done) { |
296 | dev_warn(dev, "deferred probe timeout, ignoring dependency\n" ); |
297 | return -ETIMEDOUT; |
298 | } |
299 | |
300 | return -EPROBE_DEFER; |
301 | } |
302 | EXPORT_SYMBOL_GPL(driver_deferred_probe_check_state); |
303 | |
304 | static void deferred_probe_timeout_work_func(struct work_struct *work) |
305 | { |
306 | struct device_private *p; |
307 | |
308 | fw_devlink_drivers_done(); |
309 | |
310 | driver_deferred_probe_timeout = 0; |
311 | driver_deferred_probe_trigger(); |
312 | flush_work(work: &deferred_probe_work); |
313 | |
314 | mutex_lock(&deferred_probe_mutex); |
315 | list_for_each_entry(p, &deferred_probe_pending_list, deferred_probe) |
316 | dev_info(p->device, "deferred probe pending\n" ); |
317 | mutex_unlock(lock: &deferred_probe_mutex); |
318 | |
319 | fw_devlink_probing_done(); |
320 | } |
321 | static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func); |
322 | |
323 | void deferred_probe_extend_timeout(void) |
324 | { |
325 | /* |
326 | * If the work hasn't been queued yet or if the work expired, don't |
327 | * start a new one. |
328 | */ |
329 | if (cancel_delayed_work(dwork: &deferred_probe_timeout_work)) { |
330 | schedule_delayed_work(dwork: &deferred_probe_timeout_work, |
331 | delay: driver_deferred_probe_timeout * HZ); |
332 | pr_debug("Extended deferred probe timeout by %d secs\n" , |
333 | driver_deferred_probe_timeout); |
334 | } |
335 | } |
336 | |
337 | /** |
338 | * deferred_probe_initcall() - Enable probing of deferred devices |
339 | * |
340 | * We don't want to get in the way when the bulk of drivers are getting probed. |
341 | * Instead, this initcall makes sure that deferred probing is delayed until |
342 | * late_initcall time. |
343 | */ |
344 | static int deferred_probe_initcall(void) |
345 | { |
346 | debugfs_create_file(name: "devices_deferred" , mode: 0444, NULL, NULL, |
347 | fops: &deferred_devs_fops); |
348 | |
349 | driver_deferred_probe_enable = true; |
350 | driver_deferred_probe_trigger(); |
351 | /* Sort as many dependencies as possible before exiting initcalls */ |
352 | flush_work(work: &deferred_probe_work); |
353 | initcalls_done = true; |
354 | |
355 | if (!IS_ENABLED(CONFIG_MODULES)) |
356 | fw_devlink_drivers_done(); |
357 | |
358 | /* |
359 | * Trigger deferred probe again, this time we won't defer anything |
360 | * that is optional |
361 | */ |
362 | driver_deferred_probe_trigger(); |
363 | flush_work(work: &deferred_probe_work); |
364 | |
365 | if (driver_deferred_probe_timeout > 0) { |
366 | schedule_delayed_work(dwork: &deferred_probe_timeout_work, |
367 | delay: driver_deferred_probe_timeout * HZ); |
368 | } |
369 | |
370 | if (!IS_ENABLED(CONFIG_MODULES)) |
371 | fw_devlink_probing_done(); |
372 | |
373 | return 0; |
374 | } |
375 | late_initcall(deferred_probe_initcall); |
376 | |
377 | static void __exit deferred_probe_exit(void) |
378 | { |
379 | debugfs_lookup_and_remove(name: "devices_deferred" , NULL); |
380 | } |
381 | __exitcall(deferred_probe_exit); |
382 | |
383 | /** |
384 | * device_is_bound() - Check if device is bound to a driver |
385 | * @dev: device to check |
386 | * |
387 | * Returns true if passed device has already finished probing successfully |
388 | * against a driver. |
389 | * |
390 | * This function must be called with the device lock held. |
391 | */ |
392 | bool device_is_bound(struct device *dev) |
393 | { |
394 | return dev->p && klist_node_attached(n: &dev->p->knode_driver); |
395 | } |
396 | |
397 | static void driver_bound(struct device *dev) |
398 | { |
399 | if (device_is_bound(dev)) { |
400 | pr_warn("%s: device %s already bound\n" , |
401 | __func__, kobject_name(&dev->kobj)); |
402 | return; |
403 | } |
404 | |
405 | pr_debug("driver: '%s': %s: bound to device '%s'\n" , dev->driver->name, |
406 | __func__, dev_name(dev)); |
407 | |
408 | klist_add_tail(n: &dev->p->knode_driver, k: &dev->driver->p->klist_devices); |
409 | device_links_driver_bound(dev); |
410 | |
411 | device_pm_check_callbacks(dev); |
412 | |
413 | /* |
414 | * Make sure the device is no longer in one of the deferred lists and |
415 | * kick off retrying all pending devices |
416 | */ |
417 | driver_deferred_probe_del(dev); |
418 | driver_deferred_probe_trigger(); |
419 | |
420 | bus_notify(dev, value: BUS_NOTIFY_BOUND_DRIVER); |
421 | kobject_uevent(kobj: &dev->kobj, action: KOBJ_BIND); |
422 | } |
423 | |
424 | static ssize_t coredump_store(struct device *dev, struct device_attribute *attr, |
425 | const char *buf, size_t count) |
426 | { |
427 | device_lock(dev); |
428 | dev->driver->coredump(dev); |
429 | device_unlock(dev); |
430 | |
431 | return count; |
432 | } |
433 | static DEVICE_ATTR_WO(coredump); |
434 | |
435 | static int driver_sysfs_add(struct device *dev) |
436 | { |
437 | int ret; |
438 | |
439 | bus_notify(dev, value: BUS_NOTIFY_BIND_DRIVER); |
440 | |
441 | ret = sysfs_create_link(kobj: &dev->driver->p->kobj, target: &dev->kobj, |
442 | name: kobject_name(kobj: &dev->kobj)); |
443 | if (ret) |
444 | goto fail; |
445 | |
446 | ret = sysfs_create_link(kobj: &dev->kobj, target: &dev->driver->p->kobj, |
447 | name: "driver" ); |
448 | if (ret) |
449 | goto rm_dev; |
450 | |
451 | if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump) |
452 | return 0; |
453 | |
454 | ret = device_create_file(device: dev, entry: &dev_attr_coredump); |
455 | if (!ret) |
456 | return 0; |
457 | |
458 | sysfs_remove_link(kobj: &dev->kobj, name: "driver" ); |
459 | |
460 | rm_dev: |
461 | sysfs_remove_link(kobj: &dev->driver->p->kobj, |
462 | name: kobject_name(kobj: &dev->kobj)); |
463 | |
464 | fail: |
465 | return ret; |
466 | } |
467 | |
468 | static void driver_sysfs_remove(struct device *dev) |
469 | { |
470 | struct device_driver *drv = dev->driver; |
471 | |
472 | if (drv) { |
473 | if (drv->coredump) |
474 | device_remove_file(dev, attr: &dev_attr_coredump); |
475 | sysfs_remove_link(kobj: &drv->p->kobj, name: kobject_name(kobj: &dev->kobj)); |
476 | sysfs_remove_link(kobj: &dev->kobj, name: "driver" ); |
477 | } |
478 | } |
479 | |
480 | /** |
481 | * device_bind_driver - bind a driver to one device. |
482 | * @dev: device. |
483 | * |
484 | * Allow manual attachment of a driver to a device. |
485 | * Caller must have already set @dev->driver. |
486 | * |
487 | * Note that this does not modify the bus reference count. |
488 | * Please verify that is accounted for before calling this. |
489 | * (It is ok to call with no other effort from a driver's probe() method.) |
490 | * |
491 | * This function must be called with the device lock held. |
492 | * |
493 | * Callers should prefer to use device_driver_attach() instead. |
494 | */ |
495 | int device_bind_driver(struct device *dev) |
496 | { |
497 | int ret; |
498 | |
499 | ret = driver_sysfs_add(dev); |
500 | if (!ret) { |
501 | device_links_force_bind(dev); |
502 | driver_bound(dev); |
503 | } |
504 | else |
505 | bus_notify(dev, value: BUS_NOTIFY_DRIVER_NOT_BOUND); |
506 | return ret; |
507 | } |
508 | EXPORT_SYMBOL_GPL(device_bind_driver); |
509 | |
510 | static atomic_t probe_count = ATOMIC_INIT(0); |
511 | static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); |
512 | |
513 | static ssize_t state_synced_store(struct device *dev, |
514 | struct device_attribute *attr, |
515 | const char *buf, size_t count) |
516 | { |
517 | int ret = 0; |
518 | |
519 | if (strcmp("1" , buf)) |
520 | return -EINVAL; |
521 | |
522 | device_lock(dev); |
523 | if (!dev->state_synced) { |
524 | dev->state_synced = true; |
525 | dev_sync_state(dev); |
526 | } else { |
527 | ret = -EINVAL; |
528 | } |
529 | device_unlock(dev); |
530 | |
531 | return ret ? ret : count; |
532 | } |
533 | |
534 | static ssize_t state_synced_show(struct device *dev, |
535 | struct device_attribute *attr, char *buf) |
536 | { |
537 | bool val; |
538 | |
539 | device_lock(dev); |
540 | val = dev->state_synced; |
541 | device_unlock(dev); |
542 | |
543 | return sysfs_emit(buf, fmt: "%u\n" , val); |
544 | } |
545 | static DEVICE_ATTR_RW(state_synced); |
546 | |
547 | static void device_unbind_cleanup(struct device *dev) |
548 | { |
549 | devres_release_all(dev); |
550 | arch_teardown_dma_ops(dev); |
551 | kfree(objp: dev->dma_range_map); |
552 | dev->dma_range_map = NULL; |
553 | dev->driver = NULL; |
554 | dev_set_drvdata(dev, NULL); |
555 | if (dev->pm_domain && dev->pm_domain->dismiss) |
556 | dev->pm_domain->dismiss(dev); |
557 | pm_runtime_reinit(dev); |
558 | dev_pm_set_driver_flags(dev, flags: 0); |
559 | } |
560 | |
561 | static void device_remove(struct device *dev) |
562 | { |
563 | device_remove_file(dev, attr: &dev_attr_state_synced); |
564 | device_remove_groups(dev, groups: dev->driver->dev_groups); |
565 | |
566 | if (dev->bus && dev->bus->remove) |
567 | dev->bus->remove(dev); |
568 | else if (dev->driver->remove) |
569 | dev->driver->remove(dev); |
570 | } |
571 | |
572 | static int call_driver_probe(struct device *dev, struct device_driver *drv) |
573 | { |
574 | int ret = 0; |
575 | |
576 | if (dev->bus->probe) |
577 | ret = dev->bus->probe(dev); |
578 | else if (drv->probe) |
579 | ret = drv->probe(dev); |
580 | |
581 | switch (ret) { |
582 | case 0: |
583 | break; |
584 | case -EPROBE_DEFER: |
585 | /* Driver requested deferred probing */ |
586 | dev_dbg(dev, "Driver %s requests probe deferral\n" , drv->name); |
587 | break; |
588 | case -ENODEV: |
589 | case -ENXIO: |
590 | pr_debug("%s: probe of %s rejects match %d\n" , |
591 | drv->name, dev_name(dev), ret); |
592 | break; |
593 | default: |
594 | /* driver matched but the probe failed */ |
595 | pr_warn("%s: probe of %s failed with error %d\n" , |
596 | drv->name, dev_name(dev), ret); |
597 | break; |
598 | } |
599 | |
600 | return ret; |
601 | } |
602 | |
603 | static int really_probe(struct device *dev, struct device_driver *drv) |
604 | { |
605 | bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && |
606 | !drv->suppress_bind_attrs; |
607 | int ret, link_ret; |
608 | |
609 | if (defer_all_probes) { |
610 | /* |
611 | * Value of defer_all_probes can be set only by |
612 | * device_block_probing() which, in turn, will call |
613 | * wait_for_device_probe() right after that to avoid any races. |
614 | */ |
615 | dev_dbg(dev, "Driver %s force probe deferral\n" , drv->name); |
616 | return -EPROBE_DEFER; |
617 | } |
618 | |
619 | link_ret = device_links_check_suppliers(dev); |
620 | if (link_ret == -EPROBE_DEFER) |
621 | return link_ret; |
622 | |
623 | pr_debug("bus: '%s': %s: probing driver %s with device %s\n" , |
624 | drv->bus->name, __func__, drv->name, dev_name(dev)); |
625 | if (!list_empty(head: &dev->devres_head)) { |
626 | dev_crit(dev, "Resources present before probing\n" ); |
627 | ret = -EBUSY; |
628 | goto done; |
629 | } |
630 | |
631 | re_probe: |
632 | dev->driver = drv; |
633 | |
634 | /* If using pinctrl, bind pins now before probing */ |
635 | ret = pinctrl_bind_pins(dev); |
636 | if (ret) |
637 | goto pinctrl_bind_failed; |
638 | |
639 | if (dev->bus->dma_configure) { |
640 | ret = dev->bus->dma_configure(dev); |
641 | if (ret) |
642 | goto pinctrl_bind_failed; |
643 | } |
644 | |
645 | ret = driver_sysfs_add(dev); |
646 | if (ret) { |
647 | pr_err("%s: driver_sysfs_add(%s) failed\n" , |
648 | __func__, dev_name(dev)); |
649 | goto sysfs_failed; |
650 | } |
651 | |
652 | if (dev->pm_domain && dev->pm_domain->activate) { |
653 | ret = dev->pm_domain->activate(dev); |
654 | if (ret) |
655 | goto probe_failed; |
656 | } |
657 | |
658 | ret = call_driver_probe(dev, drv); |
659 | if (ret) { |
660 | /* |
661 | * If fw_devlink_best_effort is active (denoted by -EAGAIN), the |
662 | * device might actually probe properly once some of its missing |
663 | * suppliers have probed. So, treat this as if the driver |
664 | * returned -EPROBE_DEFER. |
665 | */ |
666 | if (link_ret == -EAGAIN) |
667 | ret = -EPROBE_DEFER; |
668 | |
669 | /* |
670 | * Return probe errors as positive values so that the callers |
671 | * can distinguish them from other errors. |
672 | */ |
673 | ret = -ret; |
674 | goto probe_failed; |
675 | } |
676 | |
677 | ret = device_add_groups(dev, groups: drv->dev_groups); |
678 | if (ret) { |
679 | dev_err(dev, "device_add_groups() failed\n" ); |
680 | goto dev_groups_failed; |
681 | } |
682 | |
683 | if (dev_has_sync_state(dev)) { |
684 | ret = device_create_file(device: dev, entry: &dev_attr_state_synced); |
685 | if (ret) { |
686 | dev_err(dev, "state_synced sysfs add failed\n" ); |
687 | goto dev_sysfs_state_synced_failed; |
688 | } |
689 | } |
690 | |
691 | if (test_remove) { |
692 | test_remove = false; |
693 | |
694 | device_remove(dev); |
695 | driver_sysfs_remove(dev); |
696 | if (dev->bus && dev->bus->dma_cleanup) |
697 | dev->bus->dma_cleanup(dev); |
698 | device_unbind_cleanup(dev); |
699 | |
700 | goto re_probe; |
701 | } |
702 | |
703 | pinctrl_init_done(dev); |
704 | |
705 | if (dev->pm_domain && dev->pm_domain->sync) |
706 | dev->pm_domain->sync(dev); |
707 | |
708 | driver_bound(dev); |
709 | pr_debug("bus: '%s': %s: bound device %s to driver %s\n" , |
710 | drv->bus->name, __func__, dev_name(dev), drv->name); |
711 | goto done; |
712 | |
713 | dev_sysfs_state_synced_failed: |
714 | dev_groups_failed: |
715 | device_remove(dev); |
716 | probe_failed: |
717 | driver_sysfs_remove(dev); |
718 | sysfs_failed: |
719 | bus_notify(dev, value: BUS_NOTIFY_DRIVER_NOT_BOUND); |
720 | if (dev->bus && dev->bus->dma_cleanup) |
721 | dev->bus->dma_cleanup(dev); |
722 | pinctrl_bind_failed: |
723 | device_links_no_driver(dev); |
724 | device_unbind_cleanup(dev); |
725 | done: |
726 | return ret; |
727 | } |
728 | |
729 | /* |
730 | * For initcall_debug, show the driver probe time. |
731 | */ |
732 | static int really_probe_debug(struct device *dev, struct device_driver *drv) |
733 | { |
734 | ktime_t calltime, rettime; |
735 | int ret; |
736 | |
737 | calltime = ktime_get(); |
738 | ret = really_probe(dev, drv); |
739 | rettime = ktime_get(); |
740 | /* |
741 | * Don't change this to pr_debug() because that requires |
742 | * CONFIG_DYNAMIC_DEBUG and we want a simple 'initcall_debug' on the |
743 | * kernel commandline to print this all the time at the debug level. |
744 | */ |
745 | printk(KERN_DEBUG "probe of %s returned %d after %lld usecs\n" , |
746 | dev_name(dev), ret, ktime_us_delta(rettime, calltime)); |
747 | return ret; |
748 | } |
749 | |
750 | /** |
751 | * driver_probe_done |
752 | * Determine if the probe sequence is finished or not. |
753 | * |
754 | * Should somehow figure out how to use a semaphore, not an atomic variable... |
755 | */ |
756 | bool __init driver_probe_done(void) |
757 | { |
758 | int local_probe_count = atomic_read(v: &probe_count); |
759 | |
760 | pr_debug("%s: probe_count = %d\n" , __func__, local_probe_count); |
761 | return !local_probe_count; |
762 | } |
763 | |
764 | /** |
765 | * wait_for_device_probe |
766 | * Wait for device probing to be completed. |
767 | */ |
768 | void wait_for_device_probe(void) |
769 | { |
770 | /* wait for the deferred probe workqueue to finish */ |
771 | flush_work(work: &deferred_probe_work); |
772 | |
773 | /* wait for the known devices to complete their probing */ |
774 | wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); |
775 | async_synchronize_full(); |
776 | } |
777 | EXPORT_SYMBOL_GPL(wait_for_device_probe); |
778 | |
779 | static int __driver_probe_device(struct device_driver *drv, struct device *dev) |
780 | { |
781 | int ret = 0; |
782 | |
783 | if (dev->p->dead || !device_is_registered(dev)) |
784 | return -ENODEV; |
785 | if (dev->driver) |
786 | return -EBUSY; |
787 | |
788 | dev->can_match = true; |
789 | pr_debug("bus: '%s': %s: matched device %s with driver %s\n" , |
790 | drv->bus->name, __func__, dev_name(dev), drv->name); |
791 | |
792 | pm_runtime_get_suppliers(dev); |
793 | if (dev->parent) |
794 | pm_runtime_get_sync(dev: dev->parent); |
795 | |
796 | pm_runtime_barrier(dev); |
797 | if (initcall_debug) |
798 | ret = really_probe_debug(dev, drv); |
799 | else |
800 | ret = really_probe(dev, drv); |
801 | pm_request_idle(dev); |
802 | |
803 | if (dev->parent) |
804 | pm_runtime_put(dev: dev->parent); |
805 | |
806 | pm_runtime_put_suppliers(dev); |
807 | return ret; |
808 | } |
809 | |
810 | /** |
811 | * driver_probe_device - attempt to bind device & driver together |
812 | * @drv: driver to bind a device to |
813 | * @dev: device to try to bind to the driver |
814 | * |
815 | * This function returns -ENODEV if the device is not registered, -EBUSY if it |
816 | * already has a driver, 0 if the device is bound successfully and a positive |
817 | * (inverted) error code for failures from the ->probe method. |
818 | * |
819 | * This function must be called with @dev lock held. When called for a |
820 | * USB interface, @dev->parent lock must be held as well. |
821 | * |
822 | * If the device has a parent, runtime-resume the parent before driver probing. |
823 | */ |
824 | static int driver_probe_device(struct device_driver *drv, struct device *dev) |
825 | { |
826 | int trigger_count = atomic_read(v: &deferred_trigger_count); |
827 | int ret; |
828 | |
829 | atomic_inc(v: &probe_count); |
830 | ret = __driver_probe_device(drv, dev); |
831 | if (ret == -EPROBE_DEFER || ret == EPROBE_DEFER) { |
832 | driver_deferred_probe_add(dev); |
833 | |
834 | /* |
835 | * Did a trigger occur while probing? Need to re-trigger if yes |
836 | */ |
837 | if (trigger_count != atomic_read(v: &deferred_trigger_count) && |
838 | !defer_all_probes) |
839 | driver_deferred_probe_trigger(); |
840 | } |
841 | atomic_dec(v: &probe_count); |
842 | wake_up_all(&probe_waitqueue); |
843 | return ret; |
844 | } |
845 | |
846 | static inline bool cmdline_requested_async_probing(const char *drv_name) |
847 | { |
848 | bool async_drv; |
849 | |
850 | async_drv = parse_option_str(str: async_probe_drv_names, option: drv_name); |
851 | |
852 | return (async_probe_default != async_drv); |
853 | } |
854 | |
855 | /* The option format is "driver_async_probe=drv_name1,drv_name2,..." */ |
856 | static int __init save_async_options(char *buf) |
857 | { |
858 | if (strlen(buf) >= ASYNC_DRV_NAMES_MAX_LEN) |
859 | pr_warn("Too long list of driver names for 'driver_async_probe'!\n" ); |
860 | |
861 | strscpy(p: async_probe_drv_names, q: buf, ASYNC_DRV_NAMES_MAX_LEN); |
862 | async_probe_default = parse_option_str(str: async_probe_drv_names, option: "*" ); |
863 | |
864 | return 1; |
865 | } |
866 | __setup("driver_async_probe=" , save_async_options); |
867 | |
868 | static bool driver_allows_async_probing(struct device_driver *drv) |
869 | { |
870 | switch (drv->probe_type) { |
871 | case PROBE_PREFER_ASYNCHRONOUS: |
872 | return true; |
873 | |
874 | case PROBE_FORCE_SYNCHRONOUS: |
875 | return false; |
876 | |
877 | default: |
878 | if (cmdline_requested_async_probing(drv_name: drv->name)) |
879 | return true; |
880 | |
881 | if (module_requested_async_probing(module: drv->owner)) |
882 | return true; |
883 | |
884 | return false; |
885 | } |
886 | } |
887 | |
888 | struct device_attach_data { |
889 | struct device *dev; |
890 | |
891 | /* |
892 | * Indicates whether we are considering asynchronous probing or |
893 | * not. Only initial binding after device or driver registration |
894 | * (including deferral processing) may be done asynchronously, the |
895 | * rest is always synchronous, as we expect it is being done by |
896 | * request from userspace. |
897 | */ |
898 | bool check_async; |
899 | |
900 | /* |
901 | * Indicates if we are binding synchronous or asynchronous drivers. |
902 | * When asynchronous probing is enabled we'll execute 2 passes |
903 | * over drivers: first pass doing synchronous probing and second |
904 | * doing asynchronous probing (if synchronous did not succeed - |
905 | * most likely because there was no driver requiring synchronous |
906 | * probing - and we found asynchronous driver during first pass). |
907 | * The 2 passes are done because we can't shoot asynchronous |
908 | * probe for given device and driver from bus_for_each_drv() since |
909 | * driver pointer is not guaranteed to stay valid once |
910 | * bus_for_each_drv() iterates to the next driver on the bus. |
911 | */ |
912 | bool want_async; |
913 | |
914 | /* |
915 | * We'll set have_async to 'true' if, while scanning for matching |
916 | * driver, we'll encounter one that requests asynchronous probing. |
917 | */ |
918 | bool have_async; |
919 | }; |
920 | |
921 | static int __device_attach_driver(struct device_driver *drv, void *_data) |
922 | { |
923 | struct device_attach_data *data = _data; |
924 | struct device *dev = data->dev; |
925 | bool async_allowed; |
926 | int ret; |
927 | |
928 | ret = driver_match_device(drv, dev); |
929 | if (ret == 0) { |
930 | /* no match */ |
931 | return 0; |
932 | } else if (ret == -EPROBE_DEFER) { |
933 | dev_dbg(dev, "Device match requests probe deferral\n" ); |
934 | dev->can_match = true; |
935 | driver_deferred_probe_add(dev); |
936 | /* |
937 | * Device can't match with a driver right now, so don't attempt |
938 | * to match or bind with other drivers on the bus. |
939 | */ |
940 | return ret; |
941 | } else if (ret < 0) { |
942 | dev_dbg(dev, "Bus failed to match device: %d\n" , ret); |
943 | return ret; |
944 | } /* ret > 0 means positive match */ |
945 | |
946 | async_allowed = driver_allows_async_probing(drv); |
947 | |
948 | if (async_allowed) |
949 | data->have_async = true; |
950 | |
951 | if (data->check_async && async_allowed != data->want_async) |
952 | return 0; |
953 | |
954 | /* |
955 | * Ignore errors returned by ->probe so that the next driver can try |
956 | * its luck. |
957 | */ |
958 | ret = driver_probe_device(drv, dev); |
959 | if (ret < 0) |
960 | return ret; |
961 | return ret == 0; |
962 | } |
963 | |
964 | static void __device_attach_async_helper(void *_dev, async_cookie_t cookie) |
965 | { |
966 | struct device *dev = _dev; |
967 | struct device_attach_data data = { |
968 | .dev = dev, |
969 | .check_async = true, |
970 | .want_async = true, |
971 | }; |
972 | |
973 | device_lock(dev); |
974 | |
975 | /* |
976 | * Check if device has already been removed or claimed. This may |
977 | * happen with driver loading, device discovery/registration, |
978 | * and deferred probe processing happens all at once with |
979 | * multiple threads. |
980 | */ |
981 | if (dev->p->dead || dev->driver) |
982 | goto out_unlock; |
983 | |
984 | if (dev->parent) |
985 | pm_runtime_get_sync(dev: dev->parent); |
986 | |
987 | bus_for_each_drv(bus: dev->bus, NULL, data: &data, fn: __device_attach_driver); |
988 | dev_dbg(dev, "async probe completed\n" ); |
989 | |
990 | pm_request_idle(dev); |
991 | |
992 | if (dev->parent) |
993 | pm_runtime_put(dev: dev->parent); |
994 | out_unlock: |
995 | device_unlock(dev); |
996 | |
997 | put_device(dev); |
998 | } |
999 | |
1000 | static int __device_attach(struct device *dev, bool allow_async) |
1001 | { |
1002 | int ret = 0; |
1003 | bool async = false; |
1004 | |
1005 | device_lock(dev); |
1006 | if (dev->p->dead) { |
1007 | goto out_unlock; |
1008 | } else if (dev->driver) { |
1009 | if (device_is_bound(dev)) { |
1010 | ret = 1; |
1011 | goto out_unlock; |
1012 | } |
1013 | ret = device_bind_driver(dev); |
1014 | if (ret == 0) |
1015 | ret = 1; |
1016 | else { |
1017 | dev->driver = NULL; |
1018 | ret = 0; |
1019 | } |
1020 | } else { |
1021 | struct device_attach_data data = { |
1022 | .dev = dev, |
1023 | .check_async = allow_async, |
1024 | .want_async = false, |
1025 | }; |
1026 | |
1027 | if (dev->parent) |
1028 | pm_runtime_get_sync(dev: dev->parent); |
1029 | |
1030 | ret = bus_for_each_drv(bus: dev->bus, NULL, data: &data, |
1031 | fn: __device_attach_driver); |
1032 | if (!ret && allow_async && data.have_async) { |
1033 | /* |
1034 | * If we could not find appropriate driver |
1035 | * synchronously and we are allowed to do |
1036 | * async probes and there are drivers that |
1037 | * want to probe asynchronously, we'll |
1038 | * try them. |
1039 | */ |
1040 | dev_dbg(dev, "scheduling asynchronous probe\n" ); |
1041 | get_device(dev); |
1042 | async = true; |
1043 | } else { |
1044 | pm_request_idle(dev); |
1045 | } |
1046 | |
1047 | if (dev->parent) |
1048 | pm_runtime_put(dev: dev->parent); |
1049 | } |
1050 | out_unlock: |
1051 | device_unlock(dev); |
1052 | if (async) |
1053 | async_schedule_dev(func: __device_attach_async_helper, dev); |
1054 | return ret; |
1055 | } |
1056 | |
1057 | /** |
1058 | * device_attach - try to attach device to a driver. |
1059 | * @dev: device. |
1060 | * |
1061 | * Walk the list of drivers that the bus has and call |
1062 | * driver_probe_device() for each pair. If a compatible |
1063 | * pair is found, break out and return. |
1064 | * |
1065 | * Returns 1 if the device was bound to a driver; |
1066 | * 0 if no matching driver was found; |
1067 | * -ENODEV if the device is not registered. |
1068 | * |
1069 | * When called for a USB interface, @dev->parent lock must be held. |
1070 | */ |
1071 | int device_attach(struct device *dev) |
1072 | { |
1073 | return __device_attach(dev, allow_async: false); |
1074 | } |
1075 | EXPORT_SYMBOL_GPL(device_attach); |
1076 | |
1077 | void device_initial_probe(struct device *dev) |
1078 | { |
1079 | __device_attach(dev, allow_async: true); |
1080 | } |
1081 | |
1082 | /* |
1083 | * __device_driver_lock - acquire locks needed to manipulate dev->drv |
1084 | * @dev: Device we will update driver info for |
1085 | * @parent: Parent device. Needed if the bus requires parent lock |
1086 | * |
1087 | * This function will take the required locks for manipulating dev->drv. |
1088 | * Normally this will just be the @dev lock, but when called for a USB |
1089 | * interface, @parent lock will be held as well. |
1090 | */ |
1091 | static void __device_driver_lock(struct device *dev, struct device *parent) |
1092 | { |
1093 | if (parent && dev->bus->need_parent_lock) |
1094 | device_lock(dev: parent); |
1095 | device_lock(dev); |
1096 | } |
1097 | |
1098 | /* |
1099 | * __device_driver_unlock - release locks needed to manipulate dev->drv |
1100 | * @dev: Device we will update driver info for |
1101 | * @parent: Parent device. Needed if the bus requires parent lock |
1102 | * |
1103 | * This function will release the required locks for manipulating dev->drv. |
1104 | * Normally this will just be the @dev lock, but when called for a |
1105 | * USB interface, @parent lock will be released as well. |
1106 | */ |
1107 | static void __device_driver_unlock(struct device *dev, struct device *parent) |
1108 | { |
1109 | device_unlock(dev); |
1110 | if (parent && dev->bus->need_parent_lock) |
1111 | device_unlock(dev: parent); |
1112 | } |
1113 | |
1114 | /** |
1115 | * device_driver_attach - attach a specific driver to a specific device |
1116 | * @drv: Driver to attach |
1117 | * @dev: Device to attach it to |
1118 | * |
1119 | * Manually attach driver to a device. Will acquire both @dev lock and |
1120 | * @dev->parent lock if needed. Returns 0 on success, -ERR on failure. |
1121 | */ |
1122 | int device_driver_attach(struct device_driver *drv, struct device *dev) |
1123 | { |
1124 | int ret; |
1125 | |
1126 | __device_driver_lock(dev, parent: dev->parent); |
1127 | ret = __driver_probe_device(drv, dev); |
1128 | __device_driver_unlock(dev, parent: dev->parent); |
1129 | |
1130 | /* also return probe errors as normal negative errnos */ |
1131 | if (ret > 0) |
1132 | ret = -ret; |
1133 | if (ret == -EPROBE_DEFER) |
1134 | return -EAGAIN; |
1135 | return ret; |
1136 | } |
1137 | EXPORT_SYMBOL_GPL(device_driver_attach); |
1138 | |
1139 | static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie) |
1140 | { |
1141 | struct device *dev = _dev; |
1142 | struct device_driver *drv; |
1143 | int ret; |
1144 | |
1145 | __device_driver_lock(dev, parent: dev->parent); |
1146 | drv = dev->p->async_driver; |
1147 | dev->p->async_driver = NULL; |
1148 | ret = driver_probe_device(drv, dev); |
1149 | __device_driver_unlock(dev, parent: dev->parent); |
1150 | |
1151 | dev_dbg(dev, "driver %s async attach completed: %d\n" , drv->name, ret); |
1152 | |
1153 | put_device(dev); |
1154 | } |
1155 | |
1156 | static int __driver_attach(struct device *dev, void *data) |
1157 | { |
1158 | struct device_driver *drv = data; |
1159 | bool async = false; |
1160 | int ret; |
1161 | |
1162 | /* |
1163 | * Lock device and try to bind to it. We drop the error |
1164 | * here and always return 0, because we need to keep trying |
1165 | * to bind to devices and some drivers will return an error |
1166 | * simply if it didn't support the device. |
1167 | * |
1168 | * driver_probe_device() will spit a warning if there |
1169 | * is an error. |
1170 | */ |
1171 | |
1172 | ret = driver_match_device(drv, dev); |
1173 | if (ret == 0) { |
1174 | /* no match */ |
1175 | return 0; |
1176 | } else if (ret == -EPROBE_DEFER) { |
1177 | dev_dbg(dev, "Device match requests probe deferral\n" ); |
1178 | dev->can_match = true; |
1179 | driver_deferred_probe_add(dev); |
1180 | /* |
1181 | * Driver could not match with device, but may match with |
1182 | * another device on the bus. |
1183 | */ |
1184 | return 0; |
1185 | } else if (ret < 0) { |
1186 | dev_dbg(dev, "Bus failed to match device: %d\n" , ret); |
1187 | /* |
1188 | * Driver could not match with device, but may match with |
1189 | * another device on the bus. |
1190 | */ |
1191 | return 0; |
1192 | } /* ret > 0 means positive match */ |
1193 | |
1194 | if (driver_allows_async_probing(drv)) { |
1195 | /* |
1196 | * Instead of probing the device synchronously we will |
1197 | * probe it asynchronously to allow for more parallelism. |
1198 | * |
1199 | * We only take the device lock here in order to guarantee |
1200 | * that the dev->driver and async_driver fields are protected |
1201 | */ |
1202 | dev_dbg(dev, "probing driver %s asynchronously\n" , drv->name); |
1203 | device_lock(dev); |
1204 | if (!dev->driver && !dev->p->async_driver) { |
1205 | get_device(dev); |
1206 | dev->p->async_driver = drv; |
1207 | async = true; |
1208 | } |
1209 | device_unlock(dev); |
1210 | if (async) |
1211 | async_schedule_dev(func: __driver_attach_async_helper, dev); |
1212 | return 0; |
1213 | } |
1214 | |
1215 | __device_driver_lock(dev, parent: dev->parent); |
1216 | driver_probe_device(drv, dev); |
1217 | __device_driver_unlock(dev, parent: dev->parent); |
1218 | |
1219 | return 0; |
1220 | } |
1221 | |
1222 | /** |
1223 | * driver_attach - try to bind driver to devices. |
1224 | * @drv: driver. |
1225 | * |
1226 | * Walk the list of devices that the bus has on it and try to |
1227 | * match the driver with each one. If driver_probe_device() |
1228 | * returns 0 and the @dev->driver is set, we've found a |
1229 | * compatible pair. |
1230 | */ |
1231 | int driver_attach(struct device_driver *drv) |
1232 | { |
1233 | return bus_for_each_dev(bus: drv->bus, NULL, data: drv, fn: __driver_attach); |
1234 | } |
1235 | EXPORT_SYMBOL_GPL(driver_attach); |
1236 | |
1237 | /* |
1238 | * __device_release_driver() must be called with @dev lock held. |
1239 | * When called for a USB interface, @dev->parent lock must be held as well. |
1240 | */ |
1241 | static void __device_release_driver(struct device *dev, struct device *parent) |
1242 | { |
1243 | struct device_driver *drv; |
1244 | |
1245 | drv = dev->driver; |
1246 | if (drv) { |
1247 | pm_runtime_get_sync(dev); |
1248 | |
1249 | while (device_links_busy(dev)) { |
1250 | __device_driver_unlock(dev, parent); |
1251 | |
1252 | device_links_unbind_consumers(dev); |
1253 | |
1254 | __device_driver_lock(dev, parent); |
1255 | /* |
1256 | * A concurrent invocation of the same function might |
1257 | * have released the driver successfully while this one |
1258 | * was waiting, so check for that. |
1259 | */ |
1260 | if (dev->driver != drv) { |
1261 | pm_runtime_put(dev); |
1262 | return; |
1263 | } |
1264 | } |
1265 | |
1266 | driver_sysfs_remove(dev); |
1267 | |
1268 | bus_notify(dev, value: BUS_NOTIFY_UNBIND_DRIVER); |
1269 | |
1270 | pm_runtime_put_sync(dev); |
1271 | |
1272 | device_remove(dev); |
1273 | |
1274 | if (dev->bus && dev->bus->dma_cleanup) |
1275 | dev->bus->dma_cleanup(dev); |
1276 | |
1277 | device_unbind_cleanup(dev); |
1278 | device_links_driver_cleanup(dev); |
1279 | |
1280 | klist_remove(n: &dev->p->knode_driver); |
1281 | device_pm_check_callbacks(dev); |
1282 | |
1283 | bus_notify(dev, value: BUS_NOTIFY_UNBOUND_DRIVER); |
1284 | kobject_uevent(kobj: &dev->kobj, action: KOBJ_UNBIND); |
1285 | } |
1286 | } |
1287 | |
1288 | void device_release_driver_internal(struct device *dev, |
1289 | struct device_driver *drv, |
1290 | struct device *parent) |
1291 | { |
1292 | __device_driver_lock(dev, parent); |
1293 | |
1294 | if (!drv || drv == dev->driver) |
1295 | __device_release_driver(dev, parent); |
1296 | |
1297 | __device_driver_unlock(dev, parent); |
1298 | } |
1299 | |
1300 | /** |
1301 | * device_release_driver - manually detach device from driver. |
1302 | * @dev: device. |
1303 | * |
1304 | * Manually detach device from driver. |
1305 | * When called for a USB interface, @dev->parent lock must be held. |
1306 | * |
1307 | * If this function is to be called with @dev->parent lock held, ensure that |
1308 | * the device's consumers are unbound in advance or that their locks can be |
1309 | * acquired under the @dev->parent lock. |
1310 | */ |
1311 | void device_release_driver(struct device *dev) |
1312 | { |
1313 | /* |
1314 | * If anyone calls device_release_driver() recursively from |
1315 | * within their ->remove callback for the same device, they |
1316 | * will deadlock right here. |
1317 | */ |
1318 | device_release_driver_internal(dev, NULL, NULL); |
1319 | } |
1320 | EXPORT_SYMBOL_GPL(device_release_driver); |
1321 | |
1322 | /** |
1323 | * device_driver_detach - detach driver from a specific device |
1324 | * @dev: device to detach driver from |
1325 | * |
1326 | * Detach driver from device. Will acquire both @dev lock and @dev->parent |
1327 | * lock if needed. |
1328 | */ |
1329 | void device_driver_detach(struct device *dev) |
1330 | { |
1331 | device_release_driver_internal(dev, NULL, parent: dev->parent); |
1332 | } |
1333 | |
1334 | /** |
1335 | * driver_detach - detach driver from all devices it controls. |
1336 | * @drv: driver. |
1337 | */ |
1338 | void driver_detach(struct device_driver *drv) |
1339 | { |
1340 | struct device_private *dev_prv; |
1341 | struct device *dev; |
1342 | |
1343 | if (driver_allows_async_probing(drv)) |
1344 | async_synchronize_full(); |
1345 | |
1346 | for (;;) { |
1347 | spin_lock(lock: &drv->p->klist_devices.k_lock); |
1348 | if (list_empty(head: &drv->p->klist_devices.k_list)) { |
1349 | spin_unlock(lock: &drv->p->klist_devices.k_lock); |
1350 | break; |
1351 | } |
1352 | dev_prv = list_last_entry(&drv->p->klist_devices.k_list, |
1353 | struct device_private, |
1354 | knode_driver.n_node); |
1355 | dev = dev_prv->device; |
1356 | get_device(dev); |
1357 | spin_unlock(lock: &drv->p->klist_devices.k_lock); |
1358 | device_release_driver_internal(dev, drv, parent: dev->parent); |
1359 | put_device(dev); |
1360 | } |
1361 | } |
1362 | |