Branch data Line data Source code
1 : : /*
2 : : * drivers/base/dd.c - The core device/driver interactions.
3 : : *
4 : : * This file contains the (sometimes tricky) code that controls the
5 : : * interactions between devices and drivers, which primarily includes
6 : : * driver binding and unbinding.
7 : : *
8 : : * All of this code used to exist in drivers/base/bus.c, but was
9 : : * relocated to here in the name of compartmentalization (since it wasn't
10 : : * strictly code just for the 'struct bus_type'.
11 : : *
12 : : * Copyright (c) 2002-5 Patrick Mochel
13 : : * Copyright (c) 2002-3 Open Source Development Labs
14 : : * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de>
15 : : * Copyright (c) 2007-2009 Novell Inc.
16 : : *
17 : : * This file is released under the GPLv2
18 : : */
19 : :
20 : : #include <linux/device.h>
21 : : #include <linux/delay.h>
22 : : #include <linux/module.h>
23 : : #include <linux/kthread.h>
24 : : #include <linux/wait.h>
25 : : #include <linux/async.h>
26 : : #include <linux/pm_runtime.h>
27 : : #include <linux/pinctrl/devinfo.h>
28 : :
29 : : #include "base.h"
30 : : #include "power/power.h"
31 : :
32 : : /*
33 : : * Deferred Probe infrastructure.
34 : : *
35 : : * Sometimes driver probe order matters, but the kernel doesn't always have
36 : : * dependency information which means some drivers will get probed before a
37 : : * resource it depends on is available. For example, an SDHCI driver may
38 : : * first need a GPIO line from an i2c GPIO controller before it can be
39 : : * initialized. If a required resource is not available yet, a driver can
40 : : * request probing to be deferred by returning -EPROBE_DEFER from its probe hook
41 : : *
42 : : * Deferred probe maintains two lists of devices, a pending list and an active
43 : : * list. A driver returning -EPROBE_DEFER causes the device to be added to the
44 : : * pending list. A successful driver probe will trigger moving all devices
45 : : * from the pending to the active list so that the workqueue will eventually
46 : : * retry them.
47 : : *
48 : : * The deferred_probe_mutex must be held any time the deferred_probe_*_list
49 : : * of the (struct device*)->p->deferred_probe pointers are manipulated
50 : : */
51 : : static DEFINE_MUTEX(deferred_probe_mutex);
52 : : static LIST_HEAD(deferred_probe_pending_list);
53 : : static LIST_HEAD(deferred_probe_active_list);
54 : : static struct workqueue_struct *deferred_wq;
55 : :
56 : : /**
57 : : * deferred_probe_work_func() - Retry probing devices in the active list.
58 : : */
59 : 0 : static void deferred_probe_work_func(struct work_struct *work)
60 : : {
61 : : struct device *dev;
62 : : struct device_private *private;
63 : : /*
64 : : * This block processes every device in the deferred 'active' list.
65 : : * Each device is removed from the active list and passed to
66 : : * bus_probe_device() to re-attempt the probe. The loop continues
67 : : * until every device in the active list is removed and retried.
68 : : *
69 : : * Note: Once the device is removed from the list and the mutex is
70 : : * released, it is possible for the device get freed by another thread
71 : : * and cause a illegal pointer dereference. This code uses
72 : : * get/put_device() to ensure the device structure cannot disappear
73 : : * from under our feet.
74 : : */
75 : 0 : mutex_lock(&deferred_probe_mutex);
76 [ # # ]: 0 : while (!list_empty(&deferred_probe_active_list)) {
77 : : private = list_first_entry(&deferred_probe_active_list,
78 : : typeof(*dev->p), deferred_probe);
79 : 0 : dev = private->device;
80 : 0 : list_del_init(&private->deferred_probe);
81 : :
82 : 0 : get_device(dev);
83 : :
84 : : /*
85 : : * Drop the mutex while probing each device; the probe path may
86 : : * manipulate the deferred list
87 : : */
88 : 0 : mutex_unlock(&deferred_probe_mutex);
89 : :
90 : : /*
91 : : * Force the device to the end of the dpm_list since
92 : : * the PM code assumes that the order we add things to
93 : : * the list is a good order for suspend but deferred
94 : : * probe makes that very unsafe.
95 : : */
96 : 0 : device_pm_lock();
97 : 0 : device_pm_move_last(dev);
98 : 0 : device_pm_unlock();
99 : :
100 : : dev_dbg(dev, "Retrying from deferred list\n");
101 : 0 : bus_probe_device(dev);
102 : :
103 : 0 : mutex_lock(&deferred_probe_mutex);
104 : :
105 : 0 : put_device(dev);
106 : : }
107 : 0 : mutex_unlock(&deferred_probe_mutex);
108 : 0 : }
109 : : static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
110 : :
111 : 0 : static void driver_deferred_probe_add(struct device *dev)
112 : : {
113 : 0 : mutex_lock(&deferred_probe_mutex);
114 [ # # ]: 0 : if (list_empty(&dev->p->deferred_probe)) {
115 : : dev_dbg(dev, "Added to deferred list\n");
116 : : list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);
117 : : }
118 : 0 : mutex_unlock(&deferred_probe_mutex);
119 : 0 : }
120 : :
121 : 0 : void driver_deferred_probe_del(struct device *dev)
122 : : {
123 : 0 : mutex_lock(&deferred_probe_mutex);
124 [ # # ]: 0 : if (!list_empty(&dev->p->deferred_probe)) {
125 : : dev_dbg(dev, "Removed from deferred list\n");
126 : : list_del_init(&dev->p->deferred_probe);
127 : : }
128 : 0 : mutex_unlock(&deferred_probe_mutex);
129 : 0 : }
130 : :
131 : : static bool driver_deferred_probe_enable = false;
132 : : /**
133 : : * driver_deferred_probe_trigger() - Kick off re-probing deferred devices
134 : : *
135 : : * This functions moves all devices from the pending list to the active
136 : : * list and schedules the deferred probe workqueue to process them. It
137 : : * should be called anytime a driver is successfully bound to a device.
138 : : */
139 : 0 : static void driver_deferred_probe_trigger(void)
140 : : {
141 [ # # ]: 0 : if (!driver_deferred_probe_enable)
142 : 0 : return;
143 : :
144 : : /*
145 : : * A successful probe means that all the devices in the pending list
146 : : * should be triggered to be reprobed. Move all the deferred devices
147 : : * into the active list so they can be retried by the workqueue
148 : : */
149 : 0 : mutex_lock(&deferred_probe_mutex);
150 : : list_splice_tail_init(&deferred_probe_pending_list,
151 : : &deferred_probe_active_list);
152 : 0 : mutex_unlock(&deferred_probe_mutex);
153 : :
154 : : /*
155 : : * Kick the re-probe thread. It may already be scheduled, but it is
156 : : * safe to kick it again.
157 : : */
158 : 0 : queue_work(deferred_wq, &deferred_probe_work);
159 : : }
160 : :
161 : : /**
162 : : * deferred_probe_initcall() - Enable probing of deferred devices
163 : : *
164 : : * We don't want to get in the way when the bulk of drivers are getting probed.
165 : : * Instead, this initcall makes sure that deferred probing is delayed until
166 : : * late_initcall time.
167 : : */
168 : 0 : static int deferred_probe_initcall(void)
169 : : {
170 : 0 : deferred_wq = create_singlethread_workqueue("deferwq");
171 [ # # ][ # # ]: 0 : if (WARN_ON(!deferred_wq))
172 : : return -ENOMEM;
173 : :
174 : 0 : driver_deferred_probe_enable = true;
175 : 0 : driver_deferred_probe_trigger();
176 : : /* Sort as many dependencies as possible before exiting initcalls */
177 : 0 : flush_workqueue(deferred_wq);
178 : 0 : return 0;
179 : : }
180 : : late_initcall(deferred_probe_initcall);
181 : :
182 : 0 : static void driver_bound(struct device *dev)
183 : : {
184 [ # # ]: 0 : if (klist_node_attached(&dev->p->knode_driver)) {
185 : 0 : printk(KERN_WARNING "%s: device %s already bound\n",
186 : : __func__, kobject_name(&dev->kobj));
187 : 0 : return;
188 : : }
189 : :
190 : : pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
191 : : __func__, dev->driver->name);
192 : :
193 : 0 : klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
194 : :
195 : : /*
196 : : * Make sure the device is no longer in one of the deferred lists and
197 : : * kick off retrying all pending devices
198 : : */
199 : 0 : driver_deferred_probe_del(dev);
200 : 0 : driver_deferred_probe_trigger();
201 : :
202 [ # # ]: 0 : if (dev->bus)
203 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
204 : : BUS_NOTIFY_BOUND_DRIVER, dev);
205 : : }
206 : :
207 : 0 : static int driver_sysfs_add(struct device *dev)
208 : : {
209 : : int ret;
210 : :
211 [ # # ]: 0 : if (dev->bus)
212 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
213 : : BUS_NOTIFY_BIND_DRIVER, dev);
214 : :
215 : 0 : ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
216 : 0 : kobject_name(&dev->kobj));
217 [ # # ]: 0 : if (ret == 0) {
218 : 0 : ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
219 : : "driver");
220 [ # # ]: 0 : if (ret)
221 : 0 : sysfs_remove_link(&dev->driver->p->kobj,
222 : : kobject_name(&dev->kobj));
223 : : }
224 : 0 : return ret;
225 : : }
226 : :
227 : 0 : static void driver_sysfs_remove(struct device *dev)
228 : : {
229 : 0 : struct device_driver *drv = dev->driver;
230 : :
231 [ # # ]: 0 : if (drv) {
232 : 0 : sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
233 : 0 : sysfs_remove_link(&dev->kobj, "driver");
234 : : }
235 : 0 : }
236 : :
237 : : /**
238 : : * device_bind_driver - bind a driver to one device.
239 : : * @dev: device.
240 : : *
241 : : * Allow manual attachment of a driver to a device.
242 : : * Caller must have already set @dev->driver.
243 : : *
244 : : * Note that this does not modify the bus reference count
245 : : * nor take the bus's rwsem. Please verify those are accounted
246 : : * for before calling this. (It is ok to call with no other effort
247 : : * from a driver's probe() method.)
248 : : *
249 : : * This function must be called with the device lock held.
250 : : */
251 : 0 : int device_bind_driver(struct device *dev)
252 : : {
253 : : int ret;
254 : :
255 : 0 : ret = driver_sysfs_add(dev);
256 [ # # ]: 0 : if (!ret)
257 : 0 : driver_bound(dev);
258 : 0 : return ret;
259 : : }
260 : : EXPORT_SYMBOL_GPL(device_bind_driver);
261 : :
262 : : static atomic_t probe_count = ATOMIC_INIT(0);
263 : : static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
264 : :
265 : 0 : static int really_probe(struct device *dev, struct device_driver *drv)
266 : : {
267 : : int ret = 0;
268 : :
269 : : atomic_inc(&probe_count);
270 : : pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
271 : : drv->bus->name, __func__, drv->name, dev_name(dev));
272 [ # # ]: 0 : WARN_ON(!list_empty(&dev->devres_head));
273 : :
274 : 0 : dev->driver = drv;
275 : :
276 : : /* If using pinctrl, bind pins now before probing */
277 : : ret = pinctrl_bind_pins(dev);
278 : : if (ret)
279 : : goto probe_failed;
280 : :
281 [ # # ]: 0 : if (driver_sysfs_add(dev)) {
282 : 0 : printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
283 : : __func__, dev_name(dev));
284 : 0 : goto probe_failed;
285 : : }
286 : :
287 [ # # ]: 0 : if (dev->bus->probe) {
288 : 0 : ret = dev->bus->probe(dev);
289 [ # # ]: 0 : if (ret)
290 : : goto probe_failed;
291 [ # # ]: 0 : } else if (drv->probe) {
292 : 0 : ret = drv->probe(dev);
293 [ # # ]: 0 : if (ret)
294 : : goto probe_failed;
295 : : }
296 : :
297 : 0 : driver_bound(dev);
298 : : ret = 1;
299 : : pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
300 : : drv->bus->name, __func__, dev_name(dev), drv->name);
301 : : goto done;
302 : :
303 : : probe_failed:
304 : 0 : devres_release_all(dev);
305 : 0 : driver_sysfs_remove(dev);
306 : 0 : dev->driver = NULL;
307 : 0 : dev_set_drvdata(dev, NULL);
308 : :
309 [ # # ]: 0 : if (ret == -EPROBE_DEFER) {
310 : : /* Driver requested deferred probing */
311 : 0 : dev_info(dev, "Driver %s requests probe deferral\n", drv->name);
312 : 0 : driver_deferred_probe_add(dev);
313 [ # # ]: 0 : } else if (ret != -ENODEV && ret != -ENXIO) {
314 : : /* driver matched but the probe failed */
315 : 0 : printk(KERN_WARNING
316 : : "%s: probe of %s failed with error %d\n",
317 : : drv->name, dev_name(dev), ret);
318 : : } else {
319 : : pr_debug("%s: probe of %s rejects match %d\n",
320 : : drv->name, dev_name(dev), ret);
321 : : }
322 : : /*
323 : : * Ignore errors returned by ->probe so that the next driver can try
324 : : * its luck.
325 : : */
326 : : ret = 0;
327 : : done:
328 : : atomic_dec(&probe_count);
329 : 0 : wake_up(&probe_waitqueue);
330 : 0 : return ret;
331 : : }
332 : :
333 : : /**
334 : : * driver_probe_done
335 : : * Determine if the probe sequence is finished or not.
336 : : *
337 : : * Should somehow figure out how to use a semaphore, not an atomic variable...
338 : : */
339 : 0 : int driver_probe_done(void)
340 : : {
341 : 0 : pr_debug("%s: probe_count = %d\n", __func__,
342 : : atomic_read(&probe_count));
343 [ # # ]: 0 : if (atomic_read(&probe_count))
344 : : return -EBUSY;
345 : 0 : return 0;
346 : : }
347 : :
348 : : /**
349 : : * wait_for_device_probe
350 : : * Wait for device probing to be completed.
351 : : */
352 : 0 : void wait_for_device_probe(void)
353 : : {
354 : : /* wait for the known devices to complete their probing */
355 [ # # ][ # # ]: 0 : wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
356 : 0 : async_synchronize_full();
357 : 0 : }
358 : : EXPORT_SYMBOL_GPL(wait_for_device_probe);
359 : :
360 : : /**
361 : : * driver_probe_device - attempt to bind device & driver together
362 : : * @drv: driver to bind a device to
363 : : * @dev: device to try to bind to the driver
364 : : *
365 : : * This function returns -ENODEV if the device is not registered,
366 : : * 1 if the device is bound successfully and 0 otherwise.
367 : : *
368 : : * This function must be called with @dev lock held. When called for a
369 : : * USB interface, @dev->parent lock must be held as well.
370 : : */
371 : 0 : int driver_probe_device(struct device_driver *drv, struct device *dev)
372 : : {
373 : : int ret = 0;
374 : :
375 [ # # ][ # # ]: 0 : if (!device_is_registered(dev))
[ # # ]
376 : : return -ENODEV;
377 : :
378 : : pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
379 : : drv->bus->name, __func__, dev_name(dev), drv->name);
380 : :
381 : : pm_runtime_barrier(dev);
382 : 0 : ret = really_probe(dev, drv);
383 : : pm_request_idle(dev);
384 : :
385 : 0 : return ret;
386 : : }
387 : :
388 : 0 : static int __device_attach(struct device_driver *drv, void *data)
389 : : {
390 : : struct device *dev = data;
391 : :
392 [ # # ]: 0 : if (!driver_match_device(drv, dev))
393 : : return 0;
394 : :
395 : 0 : return driver_probe_device(drv, dev);
396 : : }
397 : :
398 : : /**
399 : : * device_attach - try to attach device to a driver.
400 : : * @dev: device.
401 : : *
402 : : * Walk the list of drivers that the bus has and call
403 : : * driver_probe_device() for each pair. If a compatible
404 : : * pair is found, break out and return.
405 : : *
406 : : * Returns 1 if the device was bound to a driver;
407 : : * 0 if no matching driver was found;
408 : : * -ENODEV if the device is not registered.
409 : : *
410 : : * When called for a USB interface, @dev->parent lock must be held.
411 : : */
412 : 0 : int device_attach(struct device *dev)
413 : : {
414 : : int ret = 0;
415 : :
416 : : device_lock(dev);
417 [ # # ]: 0 : if (dev->driver) {
418 [ # # ]: 0 : if (klist_node_attached(&dev->p->knode_driver)) {
419 : : ret = 1;
420 : : goto out_unlock;
421 : : }
422 : 0 : ret = device_bind_driver(dev);
423 [ # # ]: 0 : if (ret == 0)
424 : : ret = 1;
425 : : else {
426 : 0 : dev->driver = NULL;
427 : : ret = 0;
428 : : }
429 : : } else {
430 : 0 : ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
431 : : pm_request_idle(dev);
432 : : }
433 : : out_unlock:
434 : : device_unlock(dev);
435 : 0 : return ret;
436 : : }
437 : : EXPORT_SYMBOL_GPL(device_attach);
438 : :
439 : 0 : static int __driver_attach(struct device *dev, void *data)
440 : : {
441 : : struct device_driver *drv = data;
442 : :
443 : : /*
444 : : * Lock device and try to bind to it. We drop the error
445 : : * here and always return 0, because we need to keep trying
446 : : * to bind to devices and some drivers will return an error
447 : : * simply if it didn't support the device.
448 : : *
449 : : * driver_probe_device() will spit a warning if there
450 : : * is an error.
451 : : */
452 : :
453 [ # # ]: 0 : if (!driver_match_device(drv, dev))
454 : : return 0;
455 : :
456 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
457 : : device_lock(dev->parent);
458 : : device_lock(dev);
459 [ # # ]: 0 : if (!dev->driver)
460 : : driver_probe_device(drv, dev);
461 : : device_unlock(dev);
462 [ # # ]: 0 : if (dev->parent)
463 : : device_unlock(dev->parent);
464 : :
465 : : return 0;
466 : : }
467 : :
468 : : /**
469 : : * driver_attach - try to bind driver to devices.
470 : : * @drv: driver.
471 : : *
472 : : * Walk the list of devices that the bus has on it and try to
473 : : * match the driver with each one. If driver_probe_device()
474 : : * returns 0 and the @dev->driver is set, we've found a
475 : : * compatible pair.
476 : : */
477 : 0 : int driver_attach(struct device_driver *drv)
478 : : {
479 : 0 : return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
480 : : }
481 : : EXPORT_SYMBOL_GPL(driver_attach);
482 : :
483 : : /*
484 : : * __device_release_driver() must be called with @dev lock held.
485 : : * When called for a USB interface, @dev->parent lock must be held as well.
486 : : */
487 : 0 : static void __device_release_driver(struct device *dev)
488 : : {
489 : : struct device_driver *drv;
490 : :
491 : 0 : drv = dev->driver;
492 [ # # ]: 0 : if (drv) {
493 : : pm_runtime_get_sync(dev);
494 : :
495 : 0 : driver_sysfs_remove(dev);
496 : :
497 [ # # ]: 0 : if (dev->bus)
498 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
499 : : BUS_NOTIFY_UNBIND_DRIVER,
500 : : dev);
501 : :
502 : : pm_runtime_put_sync(dev);
503 : :
504 [ # # ][ # # ]: 0 : if (dev->bus && dev->bus->remove)
505 : 0 : dev->bus->remove(dev);
506 [ # # ]: 0 : else if (drv->remove)
507 : 0 : drv->remove(dev);
508 : 0 : devres_release_all(dev);
509 : 0 : dev->driver = NULL;
510 : 0 : dev_set_drvdata(dev, NULL);
511 : 0 : klist_remove(&dev->p->knode_driver);
512 [ # # ]: 0 : if (dev->bus)
513 : 0 : blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
514 : : BUS_NOTIFY_UNBOUND_DRIVER,
515 : : dev);
516 : :
517 : : }
518 : 0 : }
519 : :
520 : : /**
521 : : * device_release_driver - manually detach device from driver.
522 : : * @dev: device.
523 : : *
524 : : * Manually detach device from driver.
525 : : * When called for a USB interface, @dev->parent lock must be held.
526 : : */
527 : 0 : void device_release_driver(struct device *dev)
528 : : {
529 : : /*
530 : : * If anyone calls device_release_driver() recursively from
531 : : * within their ->remove callback for the same device, they
532 : : * will deadlock right here.
533 : : */
534 : : device_lock(dev);
535 : 0 : __device_release_driver(dev);
536 : : device_unlock(dev);
537 : 0 : }
538 : : EXPORT_SYMBOL_GPL(device_release_driver);
539 : :
540 : : /**
541 : : * driver_detach - detach driver from all devices it controls.
542 : : * @drv: driver.
543 : : */
544 : 0 : void driver_detach(struct device_driver *drv)
545 : : {
546 : : struct device_private *dev_prv;
547 : : struct device *dev;
548 : :
549 : : for (;;) {
550 : 0 : spin_lock(&drv->p->klist_devices.k_lock);
551 [ # # ]: 0 : if (list_empty(&drv->p->klist_devices.k_list)) {
552 : : spin_unlock(&drv->p->klist_devices.k_lock);
553 : : break;
554 : : }
555 : 0 : dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
556 : : struct device_private,
557 : : knode_driver.n_node);
558 : 0 : dev = dev_prv->device;
559 : 0 : get_device(dev);
560 : 0 : spin_unlock(&drv->p->klist_devices.k_lock);
561 : :
562 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
563 : : device_lock(dev->parent);
564 : : device_lock(dev);
565 [ # # ]: 0 : if (dev->driver == drv)
566 : 0 : __device_release_driver(dev);
567 : : device_unlock(dev);
568 [ # # ]: 0 : if (dev->parent)
569 : : device_unlock(dev->parent);
570 : 0 : put_device(dev);
571 : 0 : }
572 : 0 : }
573 : :
574 : : /*
575 : : * These exports can't be _GPL due to .h files using this within them, and it
576 : : * might break something that was previously working...
577 : : */
578 : 0 : void *dev_get_drvdata(const struct device *dev)
579 : : {
580 [ + - ][ + - ]: 4 : if (dev && dev->p)
581 : 4 : return dev->p->driver_data;
582 : : return NULL;
583 : : }
584 : : EXPORT_SYMBOL(dev_get_drvdata);
585 : :
586 : 0 : int dev_set_drvdata(struct device *dev, void *data)
587 : : {
588 : : int error;
589 : :
590 [ + - ]: 112 : if (!dev->p) {
591 : 112 : error = device_private_init(dev);
592 [ + - ]: 112 : if (error)
593 : : return error;
594 : : }
595 : 112 : dev->p->driver_data = data;
596 : 112 : return 0;
597 : : }
598 : : EXPORT_SYMBOL(dev_set_drvdata);
|
