[PATCH] klist: fix klist to have the same klist_add semantics as list_head
[linux-2.6.git] / drivers / base / dd.c
index b709b1e..d5bbce3 100644 (file)
  *     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.
  */
 void device_bind_driver(struct device * dev)
 {
        pr_debug("bound device '%s' to driver '%s'\n",
                 dev->bus_id, dev->driver->name);
-       list_add_tail(&dev->driver_list, &dev->driver->devices);
+       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");
@@ -57,29 +59,56 @@ 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.
  *
- *     If we find a match, we call @drv->probe(@dev) if it exists, and
- *     call device_bind_driver() above.
+ *
+ *     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.
  */
 int driver_probe_device(struct device_driver * drv, struct device * dev)
 {
-       int error = 0;
+       int ret = 0;
 
        if (drv->bus->match && !drv->bus->match(dev, drv))
-               return -ENODEV;
+               goto Done;
 
-       down(&dev->sem);
+       pr_debug("%s: Matched Device %s with Driver %s\n",
+                drv->bus->name, dev->bus_id, drv->name);
        dev->driver = drv;
        if (drv->probe) {
-               error = drv->probe(dev);
-               if (error) {
+               ret = drv->probe(dev);
+               if (ret) {
                        dev->driver = NULL;
-                       up(&dev->sem);
-                       return error;
+                       goto ProbeFailed;
                }
        }
-       up(&dev->sem);
        device_bind_driver(dev);
-       return 0;
+       ret = 1;
+       pr_debug("%s: Bound Device %s to Driver %s\n",
+                drv->bus->name, dev->bus_id, drv->name);
+       goto Done;
+
+ ProbeFailed:
+       if (ret == -ENODEV || ret == -ENXIO) {
+               /* Driver matched, but didn't support device
+                * or device not found.
+                * Not an error; keep going.
+                */
+               ret = 0;
+       } else {
+               /* driver matched but the probe failed */
+               printk(KERN_WARNING
+                      "%s: probe of %s failed with error %d\n",
+                      drv->name, dev->bus_id, ret);
+       }
+ Done:
+       return ret;
+}
+
+static int __device_attach(struct device_driver * drv, void * data)
+{
+       struct device * dev = data;
+       return driver_probe_device(drv, dev);
 }
 
 /**
@@ -89,32 +118,43 @@ int driver_probe_device(struct device_driver * drv, struct device * dev)
  *     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; error code otherwise.
  */
 int device_attach(struct device * dev)
 {
-       struct bus_type * bus = dev->bus;
-       struct list_head * entry;
-       int error;
+       int ret = 0;
 
+       down(&dev->sem);
        if (dev->driver) {
                device_bind_driver(dev);
-               return 1;
-       }
+               ret = 1;
+       } 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.
+        */
+
+       down(&dev->sem);
+       if (!dev->driver)
+               driver_probe_device(drv, dev);
+       up(&dev->sem);
 
-       if (bus->match) {
-               list_for_each(entry, &bus->drivers.list) {
-                       struct device_driver * drv = to_drv(entry);
-                       error = driver_probe_device(drv, dev);
-                       if (!error)
-                               /* success, driver matched */
-                               return 1;
-                       if (error != -ENODEV && error != -ENXIO)
-                               /* driver matched but the probe failed */
-                               printk(KERN_WARNING
-                                   "%s: probe of %s failed with error %d\n",
-                                   drv->name, dev->bus_id, error);
-               }
-       }
 
        return 0;
 }
@@ -127,30 +167,10 @@ int device_attach(struct device * dev)
  *     match the driver with each one.  If driver_probe_device()
  *     returns 0 and the @dev->driver is set, we've found a
  *     compatible pair.
- *
- *     Note that we ignore the -ENODEV error from driver_probe_device(),
- *     since it's perfectly valid for a driver not to bind to any devices.
  */
 void driver_attach(struct device_driver * drv)
 {
-       struct bus_type * bus = drv->bus;
-       struct list_head * entry;
-       int error;
-
-       if (!bus->match)
-               return;
-
-       list_for_each(entry, &bus->devices.list) {
-               struct device * dev = container_of(entry, struct device, bus_list);
-               if (!dev->driver) {
-                       error = driver_probe_device(drv, dev);
-                       if (error && (error != -ENODEV))
-                               /* driver matched but the probe failed */
-                               printk(KERN_WARNING
-                                   "%s: probe of %s failed with error %d\n",
-                                   drv->name, dev->bus_id, error);
-               }
-       }
+       bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
 }
 
 /**
@@ -158,41 +178,69 @@ 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.
  */
-void device_release_driver(struct device * dev)
+
+static void __device_release_driver(struct device * dev)
 {
        struct device_driver * drv;
 
-       down(&dev->sem);
        drv = dev->driver;
        if (drv) {
+               get_driver(drv);
                sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj));
                sysfs_remove_link(&dev->kobj, "driver");
-               list_del_init(&dev->driver_list);
+               klist_remove(&dev->knode_driver);
+
                if (drv->remove)
                        drv->remove(dev);
                dev->driver = NULL;
+               put_driver(drv);
        }
+}
+
+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)
 {
-       while (!list_empty(&drv->devices)) {
-               struct device * dev = container_of(drv->devices.next, struct device, driver_list);
-               device_release_driver(dev);
+       struct device * dev;
+
+       for (;;) {
+               spin_lock_irq(&drv->klist_devices.k_lock);
+               if (list_empty(&drv->klist_devices.k_list)) {
+                       spin_unlock_irq(&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_irq(&drv->klist_devices.k_lock);
+
+               down(&dev->sem);
+               if (dev->driver == drv)
+                       __device_release_driver(dev);
+               up(&dev->sem);
+               put_device(dev);
        }
 }
 
 
-EXPORT_SYMBOL_GPL(driver_probe_device);
 EXPORT_SYMBOL_GPL(device_bind_driver);
 EXPORT_SYMBOL_GPL(device_release_driver);
 EXPORT_SYMBOL_GPL(device_attach);