driver core: move the deferred probe pointer into the private area
[linux-2.6.git] / drivers / base / dd.c
index 503c262..9fa888e 100644 (file)
 #include "base.h"
 #include "power/power.h"
 
+/*
+ * Deferred Probe infrastructure.
+ *
+ * Sometimes driver probe order matters, but the kernel doesn't always have
+ * dependency information which means some drivers will get probed before a
+ * resource it depends on is available.  For example, an SDHCI driver may
+ * first need a GPIO line from an i2c GPIO controller before it can be
+ * initialized.  If a required resource is not available yet, a driver can
+ * request probing to be deferred by returning -EPROBE_DEFER from its probe hook
+ *
+ * Deferred probe maintains two lists of devices, a pending list and an active
+ * list.  A driver returning -EPROBE_DEFER causes the device to be added to the
+ * pending list.  A successful driver probe will trigger moving all devices
+ * from the pending to the active list so that the workqueue will eventually
+ * retry them.
+ *
+ * The deferred_probe_mutex must be held any time the deferred_probe_*_list
+ * of the (struct device*)->p->deferred_probe pointers are manipulated
+ */
+static DEFINE_MUTEX(deferred_probe_mutex);
+static LIST_HEAD(deferred_probe_pending_list);
+static LIST_HEAD(deferred_probe_active_list);
+static struct workqueue_struct *deferred_wq;
+
+/**
+ * deferred_probe_work_func() - Retry probing devices in the active list.
+ */
+static void deferred_probe_work_func(struct work_struct *work)
+{
+       struct device *dev;
+       struct device_private *private;
+       /*
+        * This block processes every device in the deferred 'active' list.
+        * Each device is removed from the active list and passed to
+        * bus_probe_device() to re-attempt the probe.  The loop continues
+        * until every device in the active list is removed and retried.
+        *
+        * Note: Once the device is removed from the list and the mutex is
+        * released, it is possible for the device get freed by another thread
+        * and cause a illegal pointer dereference.  This code uses
+        * get/put_device() to ensure the device structure cannot disappear
+        * from under our feet.
+        */
+       mutex_lock(&deferred_probe_mutex);
+       while (!list_empty(&deferred_probe_active_list)) {
+               private = list_first_entry(&deferred_probe_active_list,
+                                       typeof(*dev->p), deferred_probe);
+               dev = private->device;
+               list_del_init(&private->deferred_probe);
+
+               get_device(dev);
+
+               /* Drop the mutex while probing each device; the probe path
+                * may manipulate the deferred list */
+               mutex_unlock(&deferred_probe_mutex);
+               dev_dbg(dev, "Retrying from deferred list\n");
+               bus_probe_device(dev);
+               mutex_lock(&deferred_probe_mutex);
+
+               put_device(dev);
+       }
+       mutex_unlock(&deferred_probe_mutex);
+}
+static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
+
+static void driver_deferred_probe_add(struct device *dev)
+{
+       mutex_lock(&deferred_probe_mutex);
+       if (list_empty(&dev->p->deferred_probe)) {
+               dev_dbg(dev, "Added to deferred list\n");
+               list_add(&dev->p->deferred_probe, &deferred_probe_pending_list);
+       }
+       mutex_unlock(&deferred_probe_mutex);
+}
+
+void driver_deferred_probe_del(struct device *dev)
+{
+       mutex_lock(&deferred_probe_mutex);
+       if (!list_empty(&dev->p->deferred_probe)) {
+               dev_dbg(dev, "Removed from deferred list\n");
+               list_del_init(&dev->p->deferred_probe);
+       }
+       mutex_unlock(&deferred_probe_mutex);
+}
+
+static bool driver_deferred_probe_enable = false;
+/**
+ * driver_deferred_probe_trigger() - Kick off re-probing deferred devices
+ *
+ * This functions moves all devices from the pending list to the active
+ * list and schedules the deferred probe workqueue to process them.  It
+ * should be called anytime a driver is successfully bound to a device.
+ */
+static void driver_deferred_probe_trigger(void)
+{
+       if (!driver_deferred_probe_enable)
+               return;
+
+       /* A successful probe means that all the devices in the pending list
+        * should be triggered to be reprobed.  Move all the deferred devices
+        * into the active list so they can be retried by the workqueue */
+       mutex_lock(&deferred_probe_mutex);
+       list_splice_tail_init(&deferred_probe_pending_list,
+                             &deferred_probe_active_list);
+       mutex_unlock(&deferred_probe_mutex);
+
+       /* Kick the re-probe thread.  It may already be scheduled, but
+        * it is safe to kick it again. */
+       queue_work(deferred_wq, &deferred_probe_work);
+}
+
+/**
+ * deferred_probe_initcall() - Enable probing of deferred devices
+ *
+ * We don't want to get in the way when the bulk of drivers are getting probed.
+ * Instead, this initcall makes sure that deferred probing is delayed until
+ * late_initcall time.
+ */
+static int deferred_probe_initcall(void)
+{
+       deferred_wq = create_singlethread_workqueue("deferwq");
+       if (WARN_ON(!deferred_wq))
+               return -ENOMEM;
+
+       driver_deferred_probe_enable = true;
+       driver_deferred_probe_trigger();
+       return 0;
+}
+late_initcall(deferred_probe_initcall);
 
 static void driver_bound(struct device *dev)
 {
@@ -42,6 +171,11 @@ static void driver_bound(struct device *dev)
 
        klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
 
+       /* Make sure the device is no longer in one of the deferred lists
+        * and kick off retrying all pending devices */
+       driver_deferred_probe_del(dev);
+       driver_deferred_probe_trigger();
+
        if (dev->bus)
                blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                             BUS_NOTIFY_BOUND_DRIVER, dev);
@@ -51,6 +185,10 @@ static int driver_sysfs_add(struct device *dev)
 {
        int ret;
 
+       if (dev->bus)
+               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
+                                            BUS_NOTIFY_BIND_DRIVER, dev);
+
        ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
                          kobject_name(&dev->kobj));
        if (ret == 0) {
@@ -138,11 +276,18 @@ probe_failed:
        driver_sysfs_remove(dev);
        dev->driver = NULL;
 
-       if (ret != -ENODEV && ret != -ENXIO) {
+       if (ret == -EPROBE_DEFER) {
+               /* Driver requested deferred probing */
+               dev_info(dev, "Driver %s requests probe deferral\n", drv->name);
+               driver_deferred_probe_add(dev);
+       } else if (ret != -ENODEV && ret != -ENXIO) {
                /* driver matched but the probe failed */
                printk(KERN_WARNING
                       "%s: probe of %s failed with error %d\n",
                       drv->name, dev_name(dev), ret);
+       } else {
+               pr_debug("%s: probe of %s rejects match %d\n",
+                      drv->name, dev_name(dev), ret);
        }
        /*
         * Ignore errors returned by ->probe so that the next driver can try
@@ -241,6 +386,10 @@ int device_attach(struct device *dev)
 
        device_lock(dev);
        if (dev->driver) {
+               if (klist_node_attached(&dev->p->knode_driver)) {
+                       ret = 1;
+                       goto out_unlock;
+               }
                ret = device_bind_driver(dev);
                if (ret == 0)
                        ret = 1;
@@ -253,6 +402,7 @@ int device_attach(struct device *dev)
                ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
                pm_runtime_put_sync(dev);
        }
+out_unlock:
        device_unlock(dev);
        return ret;
 }
@@ -312,8 +462,7 @@ static void __device_release_driver(struct device *dev)
 
        drv = dev->driver;
        if (drv) {
-               pm_runtime_get_noresume(dev);
-               pm_runtime_barrier(dev);
+               pm_runtime_get_sync(dev);
 
                driver_sysfs_remove(dev);
 
@@ -322,6 +471,8 @@ static void __device_release_driver(struct device *dev)
                                                     BUS_NOTIFY_UNBIND_DRIVER,
                                                     dev);
 
+               pm_runtime_put_sync(dev);
+
                if (dev->bus && dev->bus->remove)
                        dev->bus->remove(dev);
                else if (drv->remove)
@@ -334,7 +485,6 @@ static void __device_release_driver(struct device *dev)
                                                     BUS_NOTIFY_UNBOUND_DRIVER,
                                                     dev);
 
-               pm_runtime_put_sync(dev);
        }
 }
 
@@ -404,17 +554,16 @@ void *dev_get_drvdata(const struct device *dev)
 }
 EXPORT_SYMBOL(dev_get_drvdata);
 
-void dev_set_drvdata(struct device *dev, void *data)
+int dev_set_drvdata(struct device *dev, void *data)
 {
        int error;
 
-       if (!dev)
-               return;
        if (!dev->p) {
                error = device_private_init(dev);
                if (error)
-                       return;
+                       return error;
        }
        dev->p->driver_data = data;
+       return 0;
 }
 EXPORT_SYMBOL(dev_set_drvdata);