driver core: move the deferred probe pointer into the private area
[linux-2.6.git] / drivers / base / dd.c
index 3c503e1..9fa888e 100644 (file)
 /*
- *     drivers/base/dd.c - The core device/driver interactions.
+ * drivers/base/dd.c - The core device/driver interactions.
  *
- *     This file contains the (sometimes tricky) code that controls the
- *     interactions between devices and drivers, which primarily includes
- *     driver binding and unbinding.
+ * This file contains the (sometimes tricky) code that controls the
+ * interactions between devices and drivers, which primarily includes
+ * driver binding and unbinding.
  *
- *     All of this code used to exist in drivers/base/bus.c, but was
- *     relocated to here in the name of compartmentalization (since it wasn't
- *     strictly code just for the 'struct bus_type'.
+ * All of this code used to exist in drivers/base/bus.c, but was
+ * relocated to here in the name of compartmentalization (since it wasn't
+ * strictly code just for the 'struct bus_type'.
  *
- *     Copyright (c) 2002-5 Patrick Mochel
- *     Copyright (c) 2002-3 Open Source Development Labs
+ * Copyright (c) 2002-5 Patrick Mochel
+ * Copyright (c) 2002-3 Open Source Development Labs
+ * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de>
+ * Copyright (c) 2007-2009 Novell Inc.
  *
- *     This file is released under the GPLv2
+ * This file is released under the GPLv2
  */
 
 #include <linux/device.h>
+#include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/kthread.h>
 #include <linux/wait.h>
+#include <linux/async.h>
+#include <linux/pm_runtime.h>
 
 #include "base.h"
 #include "power/power.h"
 
-#define to_drv(node) container_of(node, struct device_driver, kobj.entry)
+/*
+ * 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)
 {
-       if (klist_node_attached(&dev->knode_driver)) {
+       if (klist_node_attached(&dev->p->knode_driver)) {
                printk(KERN_WARNING "%s: device %s already bound\n",
-                       __FUNCTION__, kobject_name(&dev->kobj));
+                       __func__, kobject_name(&dev->kobj));
                return;
        }
 
-       pr_debug("bound device '%s' to driver '%s'\n",
-                dev->bus_id, dev->driver->name);
+       pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
+                __func__, dev->driver->name);
+
+       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->bus_notifier,
+               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                             BUS_NOTIFY_BOUND_DRIVER, dev);
-
-       klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices);
 }
 
 static int driver_sysfs_add(struct device *dev)
 {
        int ret;
 
-       ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj,
+       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) {
-               ret = sysfs_create_link(&dev->kobj, &dev->driver->kobj,
+               ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
                                        "driver");
                if (ret)
-                       sysfs_remove_link(&dev->driver->kobj,
+                       sysfs_remove_link(&dev->driver->p->kobj,
                                        kobject_name(&dev->kobj));
        }
        return ret;
@@ -65,24 +206,24 @@ static void driver_sysfs_remove(struct device *dev)
        struct device_driver *drv = dev->driver;
 
        if (drv) {
-               sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj));
+               sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
                sysfs_remove_link(&dev->kobj, "driver");
        }
 }
 
 /**
- *     device_bind_driver - bind a driver to one device.
- *     @dev:   device.
+ * device_bind_driver - bind a driver to one device.
+ * @dev: device.
  *
- *     Allow manual attachment of a driver to a device.
- *     Caller must have already set @dev->driver.
+ * Allow manual attachment of a driver to a device.
+ * Caller must have already set @dev->driver.
  *
- *     Note that this does not modify the bus reference count
- *     nor take the bus's rwsem. Please verify those are accounted
- *     for before calling this. (It is ok to call with no other effort
- *     from a driver's probe() method.)
+ * Note that this does not modify the bus reference count
+ * nor take the bus's rwsem. Please verify those are accounted
+ * for before calling this. (It is ok to call with no other effort
+ * from a driver's probe() method.)
  *
- *     This function must be called with @dev->sem held.
+ * This function must be called with the device lock held.
  */
 int device_bind_driver(struct device *dev)
 {
@@ -93,6 +234,7 @@ int device_bind_driver(struct device *dev)
                driver_bound(dev);
        return ret;
 }
+EXPORT_SYMBOL_GPL(device_bind_driver);
 
 static atomic_t probe_count = ATOMIC_INIT(0);
 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
@@ -102,14 +244,14 @@ static int really_probe(struct device *dev, struct device_driver *drv)
        int ret = 0;
 
        atomic_inc(&probe_count);
-       pr_debug("%s: Probing driver %s with device %s\n",
-                drv->bus->name, drv->name, dev->bus_id);
+       pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
+                drv->bus->name, __func__, drv->name, dev_name(dev));
        WARN_ON(!list_empty(&dev->devres_head));
 
        dev->driver = drv;
        if (driver_sysfs_add(dev)) {
                printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
-                       __FUNCTION__, dev->bus_id);
+                       __func__, dev_name(dev));
                goto probe_failed;
        }
 
@@ -125,8 +267,8 @@ static int really_probe(struct device *dev, struct device_driver *drv)
 
        driver_bound(dev);
        ret = 1;
-       pr_debug("%s: Bound Device %s to Driver %s\n",
-                drv->bus->name, dev->bus_id, drv->name);
+       pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
+                drv->bus->name, __func__, dev_name(dev), drv->name);
        goto done;
 
 probe_failed:
@@ -134,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->bus_id, ret);
+                      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
@@ -159,7 +308,7 @@ done:
  */
 int driver_probe_done(void)
 {
-       pr_debug("%s: probe_count = %d\n", __FUNCTION__,
+       pr_debug("%s: probe_count = %d\n", __func__,
                 atomic_read(&probe_count));
        if (atomic_read(&probe_count))
                return -EBUSY;
@@ -167,66 +316,80 @@ int driver_probe_done(void)
 }
 
 /**
+ * wait_for_device_probe
+ * Wait for device probing to be completed.
+ */
+void wait_for_device_probe(void)
+{
+       /* wait for the known devices to complete their probing */
+       wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
+       async_synchronize_full();
+}
+EXPORT_SYMBOL_GPL(wait_for_device_probe);
+
+/**
  * driver_probe_device - attempt to bind device & driver together
  * @drv: driver to bind a device to
  * @dev: device to try to bind to the driver
  *
- * First, we call the bus's match function, if one present, which should
- * compare the device IDs the driver supports with the device IDs of the
- * device. Note we don't do this ourselves because we don't know the
- * format of the ID structures, nor what is to be considered a match and
- * what is not.
- *
- * This function returns 1 if a match is found, -ENODEV if the device is
- * not registered, and 0 otherwise.
+ * This function returns -ENODEV if the device is not registered,
+ * 1 if the device is bound successfully and 0 otherwise.
  *
- * This function must be called with @dev->sem held.  When called for a
- * USB interface, @dev->parent->sem must be held as well.
+ * This function must be called with @dev lock held.  When called for a
+ * USB interface, @dev->parent lock must be held as well.
  */
-int driver_probe_device(struct device_driver * drv, struct device * dev)
+int driver_probe_device(struct device_driver *drv, struct device *dev)
 {
        int ret = 0;
 
        if (!device_is_registered(dev))
                return -ENODEV;
-       if (drv->bus->match && !drv->bus->match(dev, drv))
-               goto done;
 
-       pr_debug("%s: Matched Device %s with Driver %s\n",
-                drv->bus->name, dev->bus_id, drv->name);
+       pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
+                drv->bus->name, __func__, dev_name(dev), drv->name);
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_barrier(dev);
        ret = really_probe(dev, drv);
+       pm_runtime_put_sync(dev);
 
-done:
        return ret;
 }
 
-static int __device_attach(struct device_driver * drv, void * data)
+static int __device_attach(struct device_driver *drv, void *data)
 {
-       struct device * dev = data;
+       struct device *dev = data;
+
+       if (!driver_match_device(drv, dev))
+               return 0;
+
        return driver_probe_device(drv, dev);
 }
 
 /**
- *     device_attach - try to attach device to a driver.
- *     @dev:   device.
+ * device_attach - try to attach device to a driver.
+ * @dev: device.
  *
- *     Walk the list of drivers that the bus has and call
- *     driver_probe_device() for each pair. If a compatible
- *     pair is found, break out and return.
+ * Walk the list of drivers that the bus has and call
+ * driver_probe_device() for each pair. If a compatible
+ * pair is found, break out and return.
  *
- *     Returns 1 if the device was bound to a driver;
- *     0 if no matching device was found;
- *     -ENODEV if the device is not registered.
+ * Returns 1 if the device was bound to a driver;
+ * 0 if no matching driver was found;
+ * -ENODEV if the device is not registered.
  *
- *     When called for a USB interface, @dev->parent->sem must be held.
+ * When called for a USB interface, @dev->parent lock must be held.
  */
-int device_attach(struct device * dev)
+int device_attach(struct device *dev)
 {
        int ret = 0;
 
-       down(&dev->sem);
+       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;
@@ -235,15 +398,19 @@ int device_attach(struct device * dev)
                        ret = 0;
                }
        } else {
+               pm_runtime_get_noresume(dev);
                ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
+               pm_runtime_put_sync(dev);
        }
-       up(&dev->sem);
+out_unlock:
+       device_unlock(dev);
        return ret;
 }
+EXPORT_SYMBOL_GPL(device_attach);
 
-static int __driver_attach(struct device * dev, void * data)
+static int __driver_attach(struct device *dev, void *data)
 {
-       struct device_driver * drv = data;
+       struct device_driver *drv = data;
 
        /*
         * Lock device and try to bind to it. We drop the error
@@ -255,114 +422,148 @@ static int __driver_attach(struct device * dev, void * data)
         * is an error.
         */
 
+       if (!driver_match_device(drv, dev))
+               return 0;
+
        if (dev->parent)        /* Needed for USB */
-               down(&dev->parent->sem);
-       down(&dev->sem);
+               device_lock(dev->parent);
+       device_lock(dev);
        if (!dev->driver)
                driver_probe_device(drv, dev);
-       up(&dev->sem);
+       device_unlock(dev);
        if (dev->parent)
-               up(&dev->parent->sem);
+               device_unlock(dev->parent);
 
        return 0;
 }
 
 /**
- *     driver_attach - try to bind driver to devices.
- *     @drv:   driver.
+ * driver_attach - try to bind driver to devices.
+ * @drv: driver.
  *
- *     Walk the list of devices that the bus has on it and try to
- *     match the driver with each one.  If driver_probe_device()
- *     returns 0 and the @dev->driver is set, we've found a
- *     compatible pair.
+ * Walk the list of devices that the bus has on it and try to
+ * match the driver with each one.  If driver_probe_device()
+ * returns 0 and the @dev->driver is set, we've found a
+ * compatible pair.
  */
-int driver_attach(struct device_driver * drv)
+int driver_attach(struct device_driver *drv)
 {
        return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
 }
+EXPORT_SYMBOL_GPL(driver_attach);
 
-/**
- *     device_release_driver - manually detach device from driver.
- *     @dev:   device.
- *
- *     Manually detach device from driver.
- *
- *     __device_release_driver() must be called with @dev->sem held.
- *     When called for a USB interface, @dev->parent->sem must be held
- *     as well.
+/*
+ * __device_release_driver() must be called with @dev lock held.
+ * When called for a USB interface, @dev->parent lock must be held as well.
  */
-
-static void __device_release_driver(struct device * dev)
+static void __device_release_driver(struct device *dev)
 {
-       struct device_driver * drv;
+       struct device_driver *drv;
 
-       drv = get_driver(dev->driver);
+       drv = dev->driver;
        if (drv) {
+               pm_runtime_get_sync(dev);
+
                driver_sysfs_remove(dev);
-               sysfs_remove_link(&dev->kobj, "driver");
-               klist_remove(&dev->knode_driver);
 
                if (dev->bus)
-                       blocking_notifier_call_chain(&dev->bus->bus_notifier,
+                       blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                                     BUS_NOTIFY_UNBIND_DRIVER,
                                                     dev);
 
+               pm_runtime_put_sync(dev);
+
                if (dev->bus && dev->bus->remove)
                        dev->bus->remove(dev);
                else if (drv->remove)
                        drv->remove(dev);
                devres_release_all(dev);
                dev->driver = NULL;
-               put_driver(drv);
+               klist_remove(&dev->p->knode_driver);
+               if (dev->bus)
+                       blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
+                                                    BUS_NOTIFY_UNBOUND_DRIVER,
+                                                    dev);
+
        }
 }
 
-void device_release_driver(struct device * dev)
+/**
+ * device_release_driver - manually detach device from driver.
+ * @dev: device.
+ *
+ * Manually detach device from driver.
+ * When called for a USB interface, @dev->parent lock must be held.
+ */
+void device_release_driver(struct device *dev)
 {
        /*
         * If anyone calls device_release_driver() recursively from
         * within their ->remove callback for the same device, they
         * will deadlock right here.
         */
-       down(&dev->sem);
+       device_lock(dev);
        __device_release_driver(dev);
-       up(&dev->sem);
+       device_unlock(dev);
 }
-
+EXPORT_SYMBOL_GPL(device_release_driver);
 
 /**
  * driver_detach - detach driver from all devices it controls.
  * @drv: driver.
  */
-void driver_detach(struct device_driver * drv)
+void driver_detach(struct device_driver *drv)
 {
-       struct device * dev;
+       struct device_private *dev_prv;
+       struct device *dev;
 
        for (;;) {
-               spin_lock(&drv->klist_devices.k_lock);
-               if (list_empty(&drv->klist_devices.k_list)) {
-                       spin_unlock(&drv->klist_devices.k_lock);
+               spin_lock(&drv->p->klist_devices.k_lock);
+               if (list_empty(&drv->p->klist_devices.k_list)) {
+                       spin_unlock(&drv->p->klist_devices.k_lock);
                        break;
                }
-               dev = list_entry(drv->klist_devices.k_list.prev,
-                               struct device, knode_driver.n_node);
+               dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
+                                    struct device_private,
+                                    knode_driver.n_node);
+               dev = dev_prv->device;
                get_device(dev);
-               spin_unlock(&drv->klist_devices.k_lock);
+               spin_unlock(&drv->p->klist_devices.k_lock);
 
                if (dev->parent)        /* Needed for USB */
-                       down(&dev->parent->sem);
-               down(&dev->sem);
+                       device_lock(dev->parent);
+               device_lock(dev);
                if (dev->driver == drv)
                        __device_release_driver(dev);
-               up(&dev->sem);
+               device_unlock(dev);
                if (dev->parent)
-                       up(&dev->parent->sem);
+                       device_unlock(dev->parent);
                put_device(dev);
        }
 }
 
-EXPORT_SYMBOL_GPL(device_bind_driver);
-EXPORT_SYMBOL_GPL(device_release_driver);
-EXPORT_SYMBOL_GPL(device_attach);
-EXPORT_SYMBOL_GPL(driver_attach);
+/*
+ * These exports can't be _GPL due to .h files using this within them, and it
+ * might break something that was previously working...
+ */
+void *dev_get_drvdata(const struct device *dev)
+{
+       if (dev && dev->p)
+               return dev->p->driver_data;
+       return NULL;
+}
+EXPORT_SYMBOL(dev_get_drvdata);
 
+int dev_set_drvdata(struct device *dev, void *data)
+{
+       int error;
+
+       if (!dev->p) {
+               error = device_private_init(dev);
+               if (error)
+                       return error;
+       }
+       dev->p->driver_data = data;
+       return 0;
+}
+EXPORT_SYMBOL(dev_set_drvdata);