Logo Search packages:      
Sourcecode: linux version File versions  Download package

dd.c

/*
 *    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.
 *
 *    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
 *
 *    This file is released under the GPLv2
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/wait.h>

#include "base.h"
#include "power/power.h"

#define to_drv(node) container_of(node, struct device_driver, kobj.entry)


static void driver_bound(struct device *dev)
{
      if (klist_node_attached(&dev->knode_driver)) {
            printk(KERN_WARNING "%s: device %s already bound\n",
                  __FUNCTION__, kobject_name(&dev->kobj));
            return;
      }

      pr_debug("bound device '%s' to driver '%s'\n",
             dev->bus_id, dev->driver->name);

      if (dev->bus)
            blocking_notifier_call_chain(&dev->bus->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,
                    kobject_name(&dev->kobj));
      if (ret == 0) {
            ret = sysfs_create_link(&dev->kobj, &dev->driver->kobj,
                              "driver");
            if (ret)
                  sysfs_remove_link(&dev->driver->kobj,
                              kobject_name(&dev->kobj));
      }
      return ret;
}

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(&dev->kobj, "driver");
      }
}

/**
 *    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.
 *
 *    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.
 */
int device_bind_driver(struct device *dev)
{
      int ret;

      ret = driver_sysfs_add(dev);
      if (!ret)
            driver_bound(dev);
      return ret;
}

static atomic_t probe_count = ATOMIC_INIT(0);
static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);

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);
      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);
            goto probe_failed;
      }

      if (dev->bus->probe) {
            ret = dev->bus->probe(dev);
            if (ret)
                  goto probe_failed;
      } else if (drv->probe) {
            ret = drv->probe(dev);
            if (ret)
                  goto probe_failed;
      }

      driver_bound(dev);
      ret = 1;
      pr_debug("%s: Bound Device %s to Driver %s\n",
             drv->bus->name, dev->bus_id, drv->name);
      goto done;

probe_failed:
      devres_release_all(dev);
      driver_sysfs_remove(dev);
      dev->driver = NULL;

      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);
      }
      /*
       * Ignore errors returned by ->probe so that the next driver can try
       * its luck.
       */
      ret = 0;
done:
      atomic_dec(&probe_count);
      wake_up(&probe_waitqueue);
      return ret;
}

/**
 * driver_probe_done
 * Determine if the probe sequence is finished or not.
 *
 * Should somehow figure out how to use a semaphore, not an atomic variable...
 */
int driver_probe_done(void)
{
      pr_debug("%s: probe_count = %d\n", __FUNCTION__,
             atomic_read(&probe_count));
      if (atomic_read(&probe_count))
            return -EBUSY;
      return 0;
}

/**
 * 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 must be called with @dev->sem held.  When called for a
 * USB interface, @dev->parent->sem must be held as well.
 */
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);

      ret = really_probe(dev, drv);

done:
      return ret;
}

static int __device_attach(struct device_driver * drv, void * data)
{
      struct device * dev = data;
      return driver_probe_device(drv, dev);
}

/**
 *    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.
 *
 *    Returns 1 if the device was bound to a driver;
 *    0 if no matching device was found;
 *    -ENODEV if the device is not registered.
 *
 *    When called for a USB interface, @dev->parent->sem must be held.
 */
int device_attach(struct device * dev)
{
      int ret = 0;

      down(&dev->sem);
      if (dev->driver) {
            ret = device_bind_driver(dev);
            if (ret == 0)
                  ret = 1;
            else {
                  dev->driver = NULL;
                  ret = 0;
            }
      } else {
            ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
      }
      up(&dev->sem);
      return ret;
}

static int __driver_attach(struct device * dev, void * data)
{
      struct device_driver * drv = data;

      /*
       * Lock device and try to bind to it. We drop the error
       * here and always return 0, because we need to keep trying
       * to bind to devices and some drivers will return an error
       * simply if it didn't support the device.
       *
       * driver_probe_device() will spit a warning if there
       * is an error.
       */

      if (dev->parent)  /* Needed for USB */
            down(&dev->parent->sem);
      down(&dev->sem);
      if (!dev->driver)
            driver_probe_device(drv, dev);
      up(&dev->sem);
      if (dev->parent)
            up(&dev->parent->sem);

      return 0;
}

/**
 *    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.
 */
int driver_attach(struct device_driver * drv)
{
      return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}

/*
 *    __device_release_driver() must be called with @dev->sem held.
 *    When called for a USB interface, @dev->parent->sem must be held as well.
 */
static void __device_release_driver(struct device * dev)
{
      struct device_driver * drv;

      drv = get_driver(dev->driver);
      if (drv) {
            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,
                                         BUS_NOTIFY_UNBIND_DRIVER,
                                         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);
      }
}

/**
 *    device_release_driver - manually detach device from driver.
 *    @dev: device.
 *
 *    Manually detach device from driver.
 *    When called for a USB interface, @dev->parent->sem 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_release_driver(dev);
      up(&dev->sem);
}


/**
 * driver_detach - detach driver from all devices it controls.
 * @drv: driver.
 */
void driver_detach(struct device_driver * drv)
{
      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);
                  break;
            }
            dev = list_entry(drv->klist_devices.k_list.prev,
                        struct device, knode_driver.n_node);
            get_device(dev);
            spin_unlock(&drv->klist_devices.k_lock);

            if (dev->parent)  /* Needed for USB */
                  down(&dev->parent->sem);
            down(&dev->sem);
            if (dev->driver == drv)
                  __device_release_driver(dev);
            up(&dev->sem);
            if (dev->parent)
                  up(&dev->parent->sem);
            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);


Generated by  Doxygen 1.6.0   Back to index