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 : 3 : static void deferred_probe_work_func(struct work_struct *work)
75 : : {
76 : : struct device *dev;
77 : : 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 : 3 : mutex_lock(&deferred_probe_mutex);
91 : 3 : while (!list_empty(&deferred_probe_active_list)) {
92 : 3 : private = list_first_entry(&deferred_probe_active_list,
93 : : typeof(*dev->p), deferred_probe);
94 : 3 : dev = private->device;
95 : 3 : list_del_init(&private->deferred_probe);
96 : :
97 : 3 : get_device(dev);
98 : :
99 : : /*
100 : : * Drop the mutex while probing each device; the probe path may
101 : : * manipulate the deferred list
102 : : */
103 : 3 : 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 : 3 : device_pm_move_to_tail(dev);
112 : :
113 : : dev_dbg(dev, "Retrying from deferred list\n");
114 : 3 : bus_probe_device(dev);
115 : 3 : mutex_lock(&deferred_probe_mutex);
116 : :
117 : 3 : put_device(dev);
118 : : }
119 : 3 : mutex_unlock(&deferred_probe_mutex);
120 : 3 : }
121 : : static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
122 : :
123 : 3 : void driver_deferred_probe_add(struct device *dev)
124 : : {
125 : 3 : mutex_lock(&deferred_probe_mutex);
126 : 3 : if (list_empty(&dev->p->deferred_probe)) {
127 : : dev_dbg(dev, "Added to deferred list\n");
128 : : list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);
129 : : }
130 : 3 : mutex_unlock(&deferred_probe_mutex);
131 : 3 : }
132 : :
133 : 3 : void driver_deferred_probe_del(struct device *dev)
134 : : {
135 : 3 : mutex_lock(&deferred_probe_mutex);
136 : 3 : if (!list_empty(&dev->p->deferred_probe)) {
137 : : dev_dbg(dev, "Removed from deferred list\n");
138 : : list_del_init(&dev->p->deferred_probe);
139 : : }
140 : 3 : mutex_unlock(&deferred_probe_mutex);
141 : 3 : }
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 : 3 : static void driver_deferred_probe_trigger(void)
163 : : {
164 : 3 : if (!driver_deferred_probe_enable)
165 : 3 : 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 : 3 : mutex_lock(&deferred_probe_mutex);
173 : : atomic_inc(&deferred_trigger_count);
174 : : list_splice_tail_init(&deferred_probe_pending_list,
175 : : &deferred_probe_active_list);
176 : 3 : 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 : : 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 : : 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 : : 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 : : 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 : : 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 : : 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 : 3 : static int deferred_probe_initcall(void)
322 : : {
323 : 3 : deferred_devices = debugfs_create_file("devices_deferred", 0444, NULL,
324 : : NULL, &deferred_devs_fops);
325 : :
326 : 3 : driver_deferred_probe_enable = true;
327 : 3 : driver_deferred_probe_trigger();
328 : : /* Sort as many dependencies as possible before exiting initcalls */
329 : 3 : flush_work(&deferred_probe_work);
330 : 3 : initcalls_done = true;
331 : :
332 : : /*
333 : : * Trigger deferred probe again, this time we won't defer anything
334 : : * that is optional
335 : : */
336 : 3 : driver_deferred_probe_trigger();
337 : 3 : flush_work(&deferred_probe_work);
338 : :
339 : 3 : if (deferred_probe_timeout > 0) {
340 : 0 : schedule_delayed_work(&deferred_probe_timeout_work,
341 : 0 : deferred_probe_timeout * HZ);
342 : : }
343 : 3 : 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 : 3 : bool device_is_bound(struct device *dev)
363 : : {
364 : 3 : return dev->p && klist_node_attached(&dev->p->knode_driver);
365 : : }
366 : :
367 : 3 : static void driver_bound(struct device *dev)
368 : : {
369 : 3 : if (device_is_bound(dev)) {
370 : 0 : printk(KERN_WARNING "%s: device %s already bound\n",
371 : : __func__, kobject_name(&dev->kobj));
372 : 3 : return;
373 : : }
374 : :
375 : : pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name,
376 : : __func__, dev_name(dev));
377 : :
378 : 3 : klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
379 : 3 : device_links_driver_bound(dev);
380 : :
381 : : 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 : 3 : driver_deferred_probe_del(dev);
388 : 3 : driver_deferred_probe_trigger();
389 : :
390 : 3 : if (dev->bus)
391 : 3 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
392 : : BUS_NOTIFY_BOUND_DRIVER, dev);
393 : :
394 : 3 : 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 : : device_lock(dev);
401 : 0 : dev->driver->coredump(dev);
402 : : device_unlock(dev);
403 : :
404 : 0 : return count;
405 : : }
406 : : static DEVICE_ATTR_WO(coredump);
407 : :
408 : 3 : static int driver_sysfs_add(struct device *dev)
409 : : {
410 : : int ret;
411 : :
412 : 3 : if (dev->bus)
413 : 3 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
414 : : BUS_NOTIFY_BIND_DRIVER, dev);
415 : :
416 : 3 : ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
417 : 3 : kobject_name(&dev->kobj));
418 : 3 : if (ret)
419 : : goto fail;
420 : :
421 : 3 : ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
422 : : "driver");
423 : 3 : if (ret)
424 : : goto rm_dev;
425 : :
426 : 3 : if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump ||
427 : 0 : !device_create_file(dev, &dev_attr_coredump))
428 : : return 0;
429 : :
430 : 0 : sysfs_remove_link(&dev->kobj, "driver");
431 : :
432 : : rm_dev:
433 : 0 : sysfs_remove_link(&dev->driver->p->kobj,
434 : : kobject_name(&dev->kobj));
435 : :
436 : : fail:
437 : 0 : return ret;
438 : : }
439 : :
440 : 3 : static void driver_sysfs_remove(struct device *dev)
441 : : {
442 : 3 : struct device_driver *drv = dev->driver;
443 : :
444 : 3 : if (drv) {
445 : 3 : if (drv->coredump)
446 : 0 : device_remove_file(dev, &dev_attr_coredump);
447 : 3 : sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
448 : 3 : sysfs_remove_link(&dev->kobj, "driver");
449 : : }
450 : 3 : }
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 : 1 : int device_bind_driver(struct device *dev)
467 : : {
468 : : int ret;
469 : :
470 : 1 : ret = driver_sysfs_add(dev);
471 : 1 : if (!ret)
472 : 1 : 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 : 1 : 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 : : static void driver_deferred_probe_add_trigger(struct device *dev,
484 : : int local_trigger_count)
485 : : {
486 : 3 : driver_deferred_probe_add(dev);
487 : : /* Did a trigger occur while probing? Need to re-trigger if yes */
488 : 3 : if (local_trigger_count != atomic_read(&deferred_trigger_count))
489 : 0 : driver_deferred_probe_trigger();
490 : : }
491 : :
492 : 3 : static int really_probe(struct device *dev, struct device_driver *drv)
493 : : {
494 : : int ret = -EPROBE_DEFER;
495 : 3 : int local_trigger_count = atomic_read(&deferred_trigger_count);
496 : : bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
497 : : !drv->suppress_bind_attrs;
498 : :
499 : 3 : 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 : : 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 : 3 : ret = device_links_check_suppliers(dev);
511 : 3 : if (ret == -EPROBE_DEFER)
512 : : driver_deferred_probe_add_trigger(dev, local_trigger_count);
513 : 3 : if (ret)
514 : : return ret;
515 : :
516 : : atomic_inc(&probe_count);
517 : : pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
518 : : drv->bus->name, __func__, drv->name, dev_name(dev));
519 : 3 : if (!list_empty(&dev->devres_head)) {
520 : 0 : dev_crit(dev, "Resources present before probing\n");
521 : 0 : return -EBUSY;
522 : : }
523 : :
524 : : re_probe:
525 : 3 : dev->driver = drv;
526 : :
527 : : /* If using pinctrl, bind pins now before probing */
528 : 3 : ret = pinctrl_bind_pins(dev);
529 : 3 : if (ret)
530 : : goto pinctrl_bind_failed;
531 : :
532 : 3 : if (dev->bus->dma_configure) {
533 : 3 : ret = dev->bus->dma_configure(dev);
534 : 3 : if (ret)
535 : : goto probe_failed;
536 : : }
537 : :
538 : 3 : 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 : 3 : if (dev->pm_domain && dev->pm_domain->activate) {
545 : 0 : ret = dev->pm_domain->activate(dev);
546 : 0 : if (ret)
547 : : goto probe_failed;
548 : : }
549 : :
550 : 3 : if (dev->bus->probe) {
551 : 3 : ret = dev->bus->probe(dev);
552 : 3 : if (ret)
553 : : goto probe_failed;
554 : 3 : } else if (drv->probe) {
555 : 3 : ret = drv->probe(dev);
556 : 3 : if (ret)
557 : : goto probe_failed;
558 : : }
559 : :
560 : 3 : if (device_add_groups(dev, drv->dev_groups)) {
561 : 0 : dev_err(dev, "device_add_groups() failed\n");
562 : : goto dev_groups_failed;
563 : : }
564 : :
565 : : 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 : 3 : pinctrl_init_done(dev);
587 : :
588 : 3 : if (dev->pm_domain && dev->pm_domain->sync)
589 : 3 : dev->pm_domain->sync(dev);
590 : :
591 : 3 : driver_bound(dev);
592 : : ret = 1;
593 : : pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
594 : : drv->bus->name, __func__, dev_name(dev), drv->name);
595 : 3 : 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 : : probe_failed:
603 : 3 : if (dev->bus)
604 : 3 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
605 : : BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
606 : : pinctrl_bind_failed:
607 : 3 : device_links_no_driver(dev);
608 : 3 : devres_release_all(dev);
609 : 3 : arch_teardown_dma_ops(dev);
610 : 3 : driver_sysfs_remove(dev);
611 : 3 : dev->driver = NULL;
612 : : dev_set_drvdata(dev, NULL);
613 : 3 : if (dev->pm_domain && dev->pm_domain->dismiss)
614 : 0 : dev->pm_domain->dismiss(dev);
615 : 3 : pm_runtime_reinit(dev);
616 : : dev_pm_set_driver_flags(dev, 0);
617 : :
618 : 3 : switch (ret) {
619 : : case -EPROBE_DEFER:
620 : : /* Driver requested deferred probing */
621 : : dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name);
622 : : driver_deferred_probe_add_trigger(dev, local_trigger_count);
623 : : 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 : 1 : 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 : : done:
641 : : atomic_dec(&probe_count);
642 : 3 : wake_up(&probe_waitqueue);
643 : 3 : 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 : : ktime_t calltime, delta, rettime;
652 : : 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 : 3 : int driver_probe_done(void)
670 : : {
671 : : pr_debug("%s: probe_count = %d\n", __func__,
672 : : atomic_read(&probe_count));
673 : 3 : if (atomic_read(&probe_count))
674 : : return -EBUSY;
675 : 3 : return 0;
676 : : }
677 : :
678 : : /**
679 : : * wait_for_device_probe
680 : : * Wait for device probing to be completed.
681 : : */
682 : 3 : void wait_for_device_probe(void)
683 : : {
684 : : /* wait for the deferred probe workqueue to finish */
685 : 3 : flush_work(&deferred_probe_work);
686 : :
687 : : /* wait for the known devices to complete their probing */
688 : 3 : wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
689 : 3 : async_synchronize_full();
690 : 3 : }
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 : 3 : int driver_probe_device(struct device_driver *drv, struct device *dev)
707 : : {
708 : : int ret = 0;
709 : :
710 : 3 : if (!device_is_registered(dev))
711 : : return -ENODEV;
712 : :
713 : : pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
714 : : drv->bus->name, __func__, dev_name(dev), drv->name);
715 : :
716 : 3 : pm_runtime_get_suppliers(dev);
717 : 3 : if (dev->parent)
718 : : pm_runtime_get_sync(dev->parent);
719 : :
720 : 3 : pm_runtime_barrier(dev);
721 : 3 : if (initcall_debug)
722 : 0 : ret = really_probe_debug(dev, drv);
723 : : else
724 : 3 : ret = really_probe(dev, drv);
725 : : pm_request_idle(dev);
726 : :
727 : 3 : if (dev->parent)
728 : : pm_runtime_put(dev->parent);
729 : :
730 : 3 : pm_runtime_put_suppliers(dev);
731 : 3 : return ret;
732 : : }
733 : :
734 : : static inline bool cmdline_requested_async_probing(const char *drv_name)
735 : : {
736 : 3 : 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 : 3 : bool driver_allows_async_probing(struct device_driver *drv)
752 : : {
753 : 3 : switch (drv->probe_type) {
754 : : case PROBE_PREFER_ASYNCHRONOUS:
755 : : return true;
756 : :
757 : : case PROBE_FORCE_SYNCHRONOUS:
758 : 0 : return false;
759 : :
760 : : default:
761 : 3 : if (cmdline_requested_async_probing(drv->name))
762 : : return true;
763 : :
764 : 3 : if (module_requested_async_probing(drv->owner))
765 : : return true;
766 : :
767 : 3 : 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 : 3 : static int __device_attach_driver(struct device_driver *drv, void *_data)
805 : : {
806 : : struct device_attach_data *data = _data;
807 : 3 : struct device *dev = data->dev;
808 : : bool async_allowed;
809 : : int ret;
810 : :
811 : : ret = driver_match_device(drv, dev);
812 : 3 : if (ret == 0) {
813 : : /* no match */
814 : : return 0;
815 : 3 : } else if (ret == -EPROBE_DEFER) {
816 : : dev_dbg(dev, "Device match requests probe deferral\n");
817 : 0 : driver_deferred_probe_add(dev);
818 : 3 : } 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 : 3 : async_allowed = driver_allows_async_probing(drv);
824 : :
825 : 3 : if (async_allowed)
826 : 0 : data->have_async = true;
827 : :
828 : 3 : if (data->check_async && async_allowed != data->want_async)
829 : : return 0;
830 : :
831 : 3 : return driver_probe_device(drv, dev);
832 : : }
833 : :
834 : 0 : static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)
835 : : {
836 : : struct device *dev = _dev;
837 : 0 : struct device_attach_data data = {
838 : : .dev = dev,
839 : : .check_async = true,
840 : : .want_async = true,
841 : : };
842 : :
843 : : 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 : 0 : if (dev->p->dead || dev->driver)
852 : : goto out_unlock;
853 : :
854 : 0 : if (dev->parent)
855 : : pm_runtime_get_sync(dev->parent);
856 : :
857 : 0 : bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);
858 : : dev_dbg(dev, "async probe completed\n");
859 : :
860 : : pm_request_idle(dev);
861 : :
862 : 0 : if (dev->parent)
863 : : pm_runtime_put(dev->parent);
864 : : out_unlock:
865 : : device_unlock(dev);
866 : :
867 : 0 : put_device(dev);
868 : 0 : }
869 : :
870 : 3 : static int __device_attach(struct device *dev, bool allow_async)
871 : : {
872 : : int ret = 0;
873 : :
874 : : device_lock(dev);
875 : 3 : if (dev->p->dead) {
876 : : goto out_unlock;
877 : 3 : } else if (dev->driver) {
878 : 0 : if (device_is_bound(dev)) {
879 : : ret = 1;
880 : : goto out_unlock;
881 : : }
882 : 0 : ret = device_bind_driver(dev);
883 : 0 : if (ret == 0)
884 : : ret = 1;
885 : : else {
886 : 0 : dev->driver = NULL;
887 : : ret = 0;
888 : : }
889 : : } else {
890 : 3 : struct device_attach_data data = {
891 : : .dev = dev,
892 : : .check_async = allow_async,
893 : : .want_async = false,
894 : : };
895 : :
896 : 3 : if (dev->parent)
897 : : pm_runtime_get_sync(dev->parent);
898 : :
899 : 3 : ret = bus_for_each_drv(dev->bus, NULL, &data,
900 : : __device_attach_driver);
901 : 3 : if (!ret && allow_async && data.have_async) {
902 : : /*
903 : : * If we could not find appropriate driver
904 : : * synchronously and we are allowed to do
905 : : * async probes and there are drivers that
906 : : * want to probe asynchronously, we'll
907 : : * try them.
908 : : */
909 : : dev_dbg(dev, "scheduling asynchronous probe\n");
910 : 0 : get_device(dev);
911 : : async_schedule_dev(__device_attach_async_helper, dev);
912 : : } else {
913 : : pm_request_idle(dev);
914 : : }
915 : :
916 : 3 : if (dev->parent)
917 : : pm_runtime_put(dev->parent);
918 : : }
919 : : out_unlock:
920 : : device_unlock(dev);
921 : 3 : return ret;
922 : : }
923 : :
924 : : /**
925 : : * device_attach - try to attach device to a driver.
926 : : * @dev: device.
927 : : *
928 : : * Walk the list of drivers that the bus has and call
929 : : * driver_probe_device() for each pair. If a compatible
930 : : * pair is found, break out and return.
931 : : *
932 : : * Returns 1 if the device was bound to a driver;
933 : : * 0 if no matching driver was found;
934 : : * -ENODEV if the device is not registered.
935 : : *
936 : : * When called for a USB interface, @dev->parent lock must be held.
937 : : */
938 : 0 : int device_attach(struct device *dev)
939 : : {
940 : 0 : return __device_attach(dev, false);
941 : : }
942 : : EXPORT_SYMBOL_GPL(device_attach);
943 : :
944 : 3 : void device_initial_probe(struct device *dev)
945 : : {
946 : 3 : __device_attach(dev, true);
947 : 3 : }
948 : :
949 : : /*
950 : : * __device_driver_lock - acquire locks needed to manipulate dev->drv
951 : : * @dev: Device we will update driver info for
952 : : * @parent: Parent device. Needed if the bus requires parent lock
953 : : *
954 : : * This function will take the required locks for manipulating dev->drv.
955 : : * Normally this will just be the @dev lock, but when called for a USB
956 : : * interface, @parent lock will be held as well.
957 : : */
958 : 3 : static void __device_driver_lock(struct device *dev, struct device *parent)
959 : : {
960 : 3 : if (parent && dev->bus->need_parent_lock)
961 : : device_lock(parent);
962 : : device_lock(dev);
963 : 3 : }
964 : :
965 : : /*
966 : : * __device_driver_unlock - release locks needed to manipulate dev->drv
967 : : * @dev: Device we will update driver info for
968 : : * @parent: Parent device. Needed if the bus requires parent lock
969 : : *
970 : : * This function will release the required locks for manipulating dev->drv.
971 : : * Normally this will just be the the @dev lock, but when called for a
972 : : * USB interface, @parent lock will be released as well.
973 : : */
974 : 3 : static void __device_driver_unlock(struct device *dev, struct device *parent)
975 : : {
976 : : device_unlock(dev);
977 : 3 : if (parent && dev->bus->need_parent_lock)
978 : : device_unlock(parent);
979 : 3 : }
980 : :
981 : : /**
982 : : * device_driver_attach - attach a specific driver to a specific device
983 : : * @drv: Driver to attach
984 : : * @dev: Device to attach it to
985 : : *
986 : : * Manually attach driver to a device. Will acquire both @dev lock and
987 : : * @dev->parent lock if needed.
988 : : */
989 : 3 : int device_driver_attach(struct device_driver *drv, struct device *dev)
990 : : {
991 : : int ret = 0;
992 : :
993 : 3 : __device_driver_lock(dev, dev->parent);
994 : :
995 : : /*
996 : : * If device has been removed or someone has already successfully
997 : : * bound a driver before us just skip the driver probe call.
998 : : */
999 : 3 : if (!dev->p->dead && !dev->driver)
1000 : 3 : ret = driver_probe_device(drv, dev);
1001 : :
1002 : 3 : __device_driver_unlock(dev, dev->parent);
1003 : :
1004 : 3 : return ret;
1005 : : }
1006 : :
1007 : 0 : static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie)
1008 : : {
1009 : : struct device *dev = _dev;
1010 : : struct device_driver *drv;
1011 : : int ret = 0;
1012 : :
1013 : 0 : __device_driver_lock(dev, dev->parent);
1014 : :
1015 : 0 : drv = dev->p->async_driver;
1016 : :
1017 : : /*
1018 : : * If device has been removed or someone has already successfully
1019 : : * bound a driver before us just skip the driver probe call.
1020 : : */
1021 : 0 : if (!dev->p->dead && !dev->driver)
1022 : 0 : ret = driver_probe_device(drv, dev);
1023 : :
1024 : 0 : __device_driver_unlock(dev, dev->parent);
1025 : :
1026 : : dev_dbg(dev, "driver %s async attach completed: %d\n", drv->name, ret);
1027 : :
1028 : 0 : put_device(dev);
1029 : 0 : }
1030 : :
1031 : 3 : static int __driver_attach(struct device *dev, void *data)
1032 : : {
1033 : : struct device_driver *drv = data;
1034 : : int ret;
1035 : :
1036 : : /*
1037 : : * Lock device and try to bind to it. We drop the error
1038 : : * here and always return 0, because we need to keep trying
1039 : : * to bind to devices and some drivers will return an error
1040 : : * simply if it didn't support the device.
1041 : : *
1042 : : * driver_probe_device() will spit a warning if there
1043 : : * is an error.
1044 : : */
1045 : :
1046 : : ret = driver_match_device(drv, dev);
1047 : 3 : if (ret == 0) {
1048 : : /* no match */
1049 : : return 0;
1050 : 3 : } else if (ret == -EPROBE_DEFER) {
1051 : : dev_dbg(dev, "Device match requests probe deferral\n");
1052 : 0 : driver_deferred_probe_add(dev);
1053 : 3 : } else if (ret < 0) {
1054 : : dev_dbg(dev, "Bus failed to match device: %d", ret);
1055 : : return ret;
1056 : : } /* ret > 0 means positive match */
1057 : :
1058 : 3 : if (driver_allows_async_probing(drv)) {
1059 : : /*
1060 : : * Instead of probing the device synchronously we will
1061 : : * probe it asynchronously to allow for more parallelism.
1062 : : *
1063 : : * We only take the device lock here in order to guarantee
1064 : : * that the dev->driver and async_driver fields are protected
1065 : : */
1066 : : dev_dbg(dev, "probing driver %s asynchronously\n", drv->name);
1067 : : device_lock(dev);
1068 : 0 : if (!dev->driver) {
1069 : 0 : get_device(dev);
1070 : 0 : dev->p->async_driver = drv;
1071 : : async_schedule_dev(__driver_attach_async_helper, dev);
1072 : : }
1073 : : device_unlock(dev);
1074 : 0 : return 0;
1075 : : }
1076 : :
1077 : 3 : device_driver_attach(drv, dev);
1078 : :
1079 : 3 : return 0;
1080 : : }
1081 : :
1082 : : /**
1083 : : * driver_attach - try to bind driver to devices.
1084 : : * @drv: driver.
1085 : : *
1086 : : * Walk the list of devices that the bus has on it and try to
1087 : : * match the driver with each one. If driver_probe_device()
1088 : : * returns 0 and the @dev->driver is set, we've found a
1089 : : * compatible pair.
1090 : : */
1091 : 3 : int driver_attach(struct device_driver *drv)
1092 : : {
1093 : 3 : return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
1094 : : }
1095 : : EXPORT_SYMBOL_GPL(driver_attach);
1096 : :
1097 : : /*
1098 : : * __device_release_driver() must be called with @dev lock held.
1099 : : * When called for a USB interface, @dev->parent lock must be held as well.
1100 : : */
1101 : 3 : static void __device_release_driver(struct device *dev, struct device *parent)
1102 : : {
1103 : : struct device_driver *drv;
1104 : :
1105 : 3 : drv = dev->driver;
1106 : 3 : if (drv) {
1107 : 0 : while (device_links_busy(dev)) {
1108 : 0 : __device_driver_unlock(dev, parent);
1109 : :
1110 : 0 : device_links_unbind_consumers(dev);
1111 : :
1112 : 0 : __device_driver_lock(dev, parent);
1113 : : /*
1114 : : * A concurrent invocation of the same function might
1115 : : * have released the driver successfully while this one
1116 : : * was waiting, so check for that.
1117 : : */
1118 : 0 : if (dev->driver != drv)
1119 : 3 : return;
1120 : : }
1121 : :
1122 : : pm_runtime_get_sync(dev);
1123 : 0 : pm_runtime_clean_up_links(dev);
1124 : :
1125 : 0 : driver_sysfs_remove(dev);
1126 : :
1127 : 0 : if (dev->bus)
1128 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1129 : : BUS_NOTIFY_UNBIND_DRIVER,
1130 : : dev);
1131 : :
1132 : : pm_runtime_put_sync(dev);
1133 : :
1134 : 0 : device_remove_groups(dev, drv->dev_groups);
1135 : :
1136 : 0 : if (dev->bus && dev->bus->remove)
1137 : 0 : dev->bus->remove(dev);
1138 : 0 : else if (drv->remove)
1139 : 0 : drv->remove(dev);
1140 : :
1141 : 0 : device_links_driver_cleanup(dev);
1142 : :
1143 : 0 : devres_release_all(dev);
1144 : 0 : arch_teardown_dma_ops(dev);
1145 : 0 : dev->driver = NULL;
1146 : : dev_set_drvdata(dev, NULL);
1147 : 0 : if (dev->pm_domain && dev->pm_domain->dismiss)
1148 : 0 : dev->pm_domain->dismiss(dev);
1149 : 0 : pm_runtime_reinit(dev);
1150 : : dev_pm_set_driver_flags(dev, 0);
1151 : :
1152 : 0 : klist_remove(&dev->p->knode_driver);
1153 : : device_pm_check_callbacks(dev);
1154 : 0 : if (dev->bus)
1155 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1156 : : BUS_NOTIFY_UNBOUND_DRIVER,
1157 : : dev);
1158 : :
1159 : 0 : kobject_uevent(&dev->kobj, KOBJ_UNBIND);
1160 : : }
1161 : : }
1162 : :
1163 : 3 : void device_release_driver_internal(struct device *dev,
1164 : : struct device_driver *drv,
1165 : : struct device *parent)
1166 : : {
1167 : 3 : __device_driver_lock(dev, parent);
1168 : :
1169 : 3 : if (!drv || drv == dev->driver)
1170 : 3 : __device_release_driver(dev, parent);
1171 : :
1172 : 3 : __device_driver_unlock(dev, parent);
1173 : 3 : }
1174 : :
1175 : : /**
1176 : : * device_release_driver - manually detach device from driver.
1177 : : * @dev: device.
1178 : : *
1179 : : * Manually detach device from driver.
1180 : : * When called for a USB interface, @dev->parent lock must be held.
1181 : : *
1182 : : * If this function is to be called with @dev->parent lock held, ensure that
1183 : : * the device's consumers are unbound in advance or that their locks can be
1184 : : * acquired under the @dev->parent lock.
1185 : : */
1186 : 3 : void device_release_driver(struct device *dev)
1187 : : {
1188 : : /*
1189 : : * If anyone calls device_release_driver() recursively from
1190 : : * within their ->remove callback for the same device, they
1191 : : * will deadlock right here.
1192 : : */
1193 : 3 : device_release_driver_internal(dev, NULL, NULL);
1194 : 3 : }
1195 : : EXPORT_SYMBOL_GPL(device_release_driver);
1196 : :
1197 : : /**
1198 : : * device_driver_detach - detach driver from a specific device
1199 : : * @dev: device to detach driver from
1200 : : *
1201 : : * Detach driver from device. Will acquire both @dev lock and @dev->parent
1202 : : * lock if needed.
1203 : : */
1204 : 0 : void device_driver_detach(struct device *dev)
1205 : : {
1206 : 0 : device_release_driver_internal(dev, NULL, dev->parent);
1207 : 0 : }
1208 : :
1209 : : /**
1210 : : * driver_detach - detach driver from all devices it controls.
1211 : : * @drv: driver.
1212 : : */
1213 : 0 : void driver_detach(struct device_driver *drv)
1214 : : {
1215 : : struct device_private *dev_prv;
1216 : : struct device *dev;
1217 : :
1218 : 0 : if (driver_allows_async_probing(drv))
1219 : 0 : async_synchronize_full();
1220 : :
1221 : : for (;;) {
1222 : 0 : spin_lock(&drv->p->klist_devices.k_lock);
1223 : 0 : if (list_empty(&drv->p->klist_devices.k_list)) {
1224 : 0 : spin_unlock(&drv->p->klist_devices.k_lock);
1225 : : break;
1226 : : }
1227 : 0 : dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
1228 : : struct device_private,
1229 : : knode_driver.n_node);
1230 : 0 : dev = dev_prv->device;
1231 : 0 : get_device(dev);
1232 : 0 : spin_unlock(&drv->p->klist_devices.k_lock);
1233 : 0 : device_release_driver_internal(dev, drv, dev->parent);
1234 : 0 : put_device(dev);
1235 : 0 : }
1236 : 0 : }
|
