Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/base/dd.c

  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 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         mutex_lock(&deferred_probe_mutex);
 76         while (!list_empty(&deferred_probe_active_list)) {
 77                 private = list_first_entry(&deferred_probe_active_list,
 78                                         typeof(*dev->p), deferred_probe);
 79                 dev = private->device;
 80                 list_del_init(&private->deferred_probe);
 81 
 82                 get_device(dev);
 83 
 84                 /*
 85                  * Drop the mutex while probing each device; the probe path may
 86                  * manipulate the deferred list
 87                  */
 88                 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                 device_pm_lock();
 97                 device_pm_move_last(dev);
 98                 device_pm_unlock();
 99 
100                 dev_dbg(dev, "Retrying from deferred list\n");
101                 bus_probe_device(dev);
102 
103                 mutex_lock(&deferred_probe_mutex);
104 
105                 put_device(dev);
106         }
107         mutex_unlock(&deferred_probe_mutex);
108 }
109 static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
110 
111 static void driver_deferred_probe_add(struct device *dev)
112 {
113         mutex_lock(&deferred_probe_mutex);
114         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         mutex_unlock(&deferred_probe_mutex);
119 }
120 
121 void driver_deferred_probe_del(struct device *dev)
122 {
123         mutex_lock(&deferred_probe_mutex);
124         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         mutex_unlock(&deferred_probe_mutex);
129 }
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 static void driver_deferred_probe_trigger(void)
140 {
141         if (!driver_deferred_probe_enable)
142                 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         mutex_lock(&deferred_probe_mutex);
150         list_splice_tail_init(&deferred_probe_pending_list,
151                               &deferred_probe_active_list);
152         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         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 static int deferred_probe_initcall(void)
169 {
170         deferred_wq = create_singlethread_workqueue("deferwq");
171         if (WARN_ON(!deferred_wq))
172                 return -ENOMEM;
173 
174         driver_deferred_probe_enable = true;
175         driver_deferred_probe_trigger();
176         /* Sort as many dependencies as possible before exiting initcalls */
177         flush_workqueue(deferred_wq);
178         return 0;
179 }
180 late_initcall(deferred_probe_initcall);
181 
182 static void driver_bound(struct device *dev)
183 {
184         if (klist_node_attached(&dev->p->knode_driver)) {
185                 printk(KERN_WARNING "%s: device %s already bound\n",
186                         __func__, kobject_name(&dev->kobj));
187                 return;
188         }
189 
190         pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
191                  __func__, dev->driver->name);
192 
193         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         driver_deferred_probe_del(dev);
200         driver_deferred_probe_trigger();
201 
202         if (dev->bus)
203                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
204                                              BUS_NOTIFY_BOUND_DRIVER, dev);
205 }
206 
207 static int driver_sysfs_add(struct device *dev)
208 {
209         int ret;
210 
211         if (dev->bus)
212                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
213                                              BUS_NOTIFY_BIND_DRIVER, dev);
214 
215         ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
216                           kobject_name(&dev->kobj));
217         if (ret == 0) {
218                 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
219                                         "driver");
220                 if (ret)
221                         sysfs_remove_link(&dev->driver->p->kobj,
222                                         kobject_name(&dev->kobj));
223         }
224         return ret;
225 }
226 
227 static void driver_sysfs_remove(struct device *dev)
228 {
229         struct device_driver *drv = dev->driver;
230 
231         if (drv) {
232                 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
233                 sysfs_remove_link(&dev->kobj, "driver");
234         }
235 }
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 int device_bind_driver(struct device *dev)
252 {
253         int ret;
254 
255         ret = driver_sysfs_add(dev);
256         if (!ret)
257                 driver_bound(dev);
258         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 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         WARN_ON(!list_empty(&dev->devres_head));
273 
274         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         if (driver_sysfs_add(dev)) {
282                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
283                         __func__, dev_name(dev));
284                 goto probe_failed;
285         }
286 
287         if (dev->bus->probe) {
288                 ret = dev->bus->probe(dev);
289                 if (ret)
290                         goto probe_failed;
291         } else if (drv->probe) {
292                 ret = drv->probe(dev);
293                 if (ret)
294                         goto probe_failed;
295         }
296 
297         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         devres_release_all(dev);
305         driver_sysfs_remove(dev);
306         dev->driver = NULL;
307         dev_set_drvdata(dev, NULL);
308 
309         if (ret == -EPROBE_DEFER) {
310                 /* Driver requested deferred probing */
311                 dev_info(dev, "Driver %s requests probe deferral\n", drv->name);
312                 driver_deferred_probe_add(dev);
313         } else if (ret != -ENODEV && ret != -ENXIO) {
314                 /* driver matched but the probe failed */
315                 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         wake_up(&probe_waitqueue);
330         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 int driver_probe_done(void)
340 {
341         pr_debug("%s: probe_count = %d\n", __func__,
342                  atomic_read(&probe_count));
343         if (atomic_read(&probe_count))
344                 return -EBUSY;
345         return 0;
346 }
347 
348 /**
349  * wait_for_device_probe
350  * Wait for device probing to be completed.
351  */
352 void wait_for_device_probe(void)
353 {
354         /* wait for the known devices to complete their probing */
355         wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
356         async_synchronize_full();
357 }
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 int driver_probe_device(struct device_driver *drv, struct device *dev)
372 {
373         int ret = 0;
374 
375         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         ret = really_probe(dev, drv);
383         pm_request_idle(dev);
384 
385         return ret;
386 }
387 
388 static int __device_attach(struct device_driver *drv, void *data)
389 {
390         struct device *dev = data;
391 
392         if (!driver_match_device(drv, dev))
393                 return 0;
394 
395         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 int device_attach(struct device *dev)
413 {
414         int ret = 0;
415 
416         device_lock(dev);
417         if (dev->driver) {
418                 if (klist_node_attached(&dev->p->knode_driver)) {
419                         ret = 1;
420                         goto out_unlock;
421                 }
422                 ret = device_bind_driver(dev);
423                 if (ret == 0)
424                         ret = 1;
425                 else {
426                         dev->driver = NULL;
427                         ret = 0;
428                 }
429         } else {
430                 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         return ret;
436 }
437 EXPORT_SYMBOL_GPL(device_attach);
438 
439 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         if (!driver_match_device(drv, dev))
454                 return 0;
455 
456         if (dev->parent)        /* Needed for USB */
457                 device_lock(dev->parent);
458         device_lock(dev);
459         if (!dev->driver)
460                 driver_probe_device(drv, dev);
461         device_unlock(dev);
462         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 int driver_attach(struct device_driver *drv)
478 {
479         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 static void __device_release_driver(struct device *dev)
488 {
489         struct device_driver *drv;
490 
491         drv = dev->driver;
492         if (drv) {
493                 pm_runtime_get_sync(dev);
494 
495                 driver_sysfs_remove(dev);
496 
497                 if (dev->bus)
498                         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                 if (dev->bus && dev->bus->remove)
505                         dev->bus->remove(dev);
506                 else if (drv->remove)
507                         drv->remove(dev);
508                 devres_release_all(dev);
509                 dev->driver = NULL;
510                 dev_set_drvdata(dev, NULL);
511                 klist_remove(&dev->p->knode_driver);
512                 if (dev->bus)
513                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
514                                                      BUS_NOTIFY_UNBOUND_DRIVER,
515                                                      dev);
516 
517         }
518 }
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 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         __device_release_driver(dev);
536         device_unlock(dev);
537 }
538 EXPORT_SYMBOL_GPL(device_release_driver);
539 
540 /**
541  * driver_detach - detach driver from all devices it controls.
542  * @drv: driver.
543  */
544 void driver_detach(struct device_driver *drv)
545 {
546         struct device_private *dev_prv;
547         struct device *dev;
548 
549         for (;;) {
550                 spin_lock(&drv->p->klist_devices.k_lock);
551                 if (list_empty(&drv->p->klist_devices.k_list)) {
552                         spin_unlock(&drv->p->klist_devices.k_lock);
553                         break;
554                 }
555                 dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
556                                      struct device_private,
557                                      knode_driver.n_node);
558                 dev = dev_prv->device;
559                 get_device(dev);
560                 spin_unlock(&drv->p->klist_devices.k_lock);
561 
562                 if (dev->parent)        /* Needed for USB */
563                         device_lock(dev->parent);
564                 device_lock(dev);
565                 if (dev->driver == drv)
566                         __device_release_driver(dev);
567                 device_unlock(dev);
568                 if (dev->parent)
569                         device_unlock(dev->parent);
570                 put_device(dev);
571         }
572 }
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 void *dev_get_drvdata(const struct device *dev)
579 {
580         if (dev && dev->p)
581                 return dev->p->driver_data;
582         return NULL;
583 }
584 EXPORT_SYMBOL(dev_get_drvdata);
585 
586 int dev_set_drvdata(struct device *dev, void *data)
587 {
588         int error;
589 
590         if (!dev->p) {
591                 error = device_private_init(dev);
592                 if (error)
593                         return error;
594         }
595         dev->p->driver_data = data;
596         return 0;
597 }
598 EXPORT_SYMBOL(dev_set_drvdata);
599 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us