[PATCH] drivers/base/firmware_class.c: cleanups

[safe/jmp/linux-2.6] / drivers / base / dd.c

diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 8510918..889c711 100644 (file)
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -40,9 +40,12 @@
  */
 void device_bind_driver(struct device * dev)
 {
+       if (klist_node_attached(&dev->knode_driver))
+               return;
+
        pr_debug("bound device '%s' to driver '%s'\n",
                 dev->bus_id, dev->driver->name);
-       klist_add_tail(&dev->driver->klist_devices, &dev->knode_driver);
+       klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices);
        sysfs_create_link(&dev->driver->kobj, &dev->kobj,
                          kobject_name(&dev->kobj));
        sysfs_create_link(&dev->kobj, &dev->driver->kobj, "driver");
@@ -59,13 +62,13 @@ void device_bind_driver(struct device * dev)
  *     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, an error if one
  *     occurs (that is not -ENODEV or -ENXIO), and 0 otherwise.
  *
- *     This function must be called with @dev->sem held.
+ *     This function must be called with @dev->sem held.  When called
+ *     for a USB interface, @dev->parent->sem must be held as well.
  */
-static 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;
 
@@ -75,7 +78,13 @@ static int driver_probe_device(struct device_driver * drv, struct device * dev)
        pr_debug("%s: Matched Device %s with Driver %s\n",
                 drv->bus->name, dev->bus_id, drv->name);
        dev->driver = drv;
-       if (drv->probe) {
+       if (dev->bus->probe) {
+               ret = dev->bus->probe(dev);
+               if (ret) {
+                       dev->driver = NULL;
+                       goto ProbeFailed;
+               }
+       } else if (drv->probe) {
                ret = drv->probe(dev);
                if (ret) {
                        dev->driver = NULL;
@@ -119,7 +128,10 @@ static int __device_attach(struct device_driver * drv, void * data)
  *     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 otherwise.
+ *     Returns 1 if the device was bound to a driver;
+ *     0 if no matching device was found; error code otherwise.
+ *
+ *     When called for a USB interface, @dev->parent->sem must be held.
  */
 int device_attach(struct device * dev)
 {
@@ -149,11 +161,14 @@ static int __driver_attach(struct device * dev, void * data)
         * 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;
 }
@@ -177,41 +192,74 @@ void driver_attach(struct device_driver * drv)
  *     @dev:   device.
  *
  *     Manually detach device from driver.
- *     Note that this is called without incrementing the bus
- *     reference count nor taking the bus's rwsem. Be sure that
- *     those are accounted for before calling this function.
+ *
+ *     __device_release_driver() must be called with @dev->sem held.
+ *     When called for a USB interface, @dev->parent->sem must be held
+ *     as well.
  */
-void device_release_driver(struct device * dev)
+
+static void __device_release_driver(struct device * dev)
 {
        struct device_driver * drv;
 
-       down(&dev->sem);
-       if (dev->driver) {
-               drv = dev->driver;
+       drv = dev->driver;
+       if (drv) {
+               get_driver(drv);
                sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj));
                sysfs_remove_link(&dev->kobj, "driver");
-               klist_del(&dev->knode_driver);
+               klist_remove(&dev->knode_driver);
 
-               if (drv->remove)
+               if (dev->bus && dev->bus->remove)
+                       dev->bus->remove(dev);
+               else if (drv->remove)
                        drv->remove(dev);
                dev->driver = NULL;
+               put_driver(drv);
        }
-       up(&dev->sem);
 }
 
-static int __remove_driver(struct device * dev, void * unused)
+void device_release_driver(struct device * dev)
 {
-       device_release_driver(dev);
-       return 0;
+       /*
+        * 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)
 {
-       driver_for_each_device(drv, NULL, NULL, __remove_driver);
+       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);
+       }
 }