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