This adds a per-device semaphore that is taken before every call from the core to a
driver method. This prevents e.g. simultaneous calls to the ->suspend() or ->resume()
and ->probe() or ->release(), potentially saving a whole lot of headaches.
It also moves us a step closer to removing the bus rwsem, since it protects the fields
in struct device that are modified by the core.
Signed-off-by: Patrick Mochel <mochel@digitalimplant.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  */
 int driver_probe_device(struct device_driver * drv, struct device * dev)
 {
+       int error = 0;
+
        if (drv->bus->match && !drv->bus->match(dev, drv))
                return -ENODEV;
 
+       down(&dev->sem);
        dev->driver = drv;
        if (drv->probe) {
-               int error = drv->probe(dev);
+               error = drv->probe(dev);
                if (error) {
                        dev->driver = NULL;
+                       up(&dev->sem);
                        return error;
                }
        }
-
+       up(&dev->sem);
        device_bind_driver(dev);
        return 0;
 }
 
 void device_release_driver(struct device * dev)
 {
-       struct device_driver * drv = dev->driver;
+       struct device_driver * drv;
+
+       down(&dev->sem);
+       drv = dev->driver;
        if (drv) {
                sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj));
                sysfs_remove_link(&dev->kobj, "driver");
                        drv->remove(dev);
                dev->driver = NULL;
        }
+       up(&dev->sem);
 }
 
 
 
        INIT_LIST_HEAD(&dev->driver_list);
        INIT_LIST_HEAD(&dev->bus_list);
        INIT_LIST_HEAD(&dev->dma_pools);
+       init_MUTEX(&dev->sem);
 }
 
 /**
 
 
 int resume_device(struct device * dev)
 {
+       int error = 0;
+
+       down(&dev->sem);
        if (dev->power.pm_parent
                        && dev->power.pm_parent->power.power_state) {
                dev_err(dev, "PM: resume from %d, parent %s still %d\n",
        }
        if (dev->bus && dev->bus->resume) {
                dev_dbg(dev,"resuming\n");
-               return dev->bus->resume(dev);
+               error = dev->bus->resume(dev);
        }
-       return 0;
+       up(&dev->sem);
+       return error;
 }
 
 
 
 {
        int error = 0;
 
+       down(&dev->sem);
        if (dev->power.power_state) {
                dev_dbg(dev, "PM: suspend %d-->%d\n",
                        dev->power.power_state, state);
                dev_dbg(dev, "suspending\n");
                error = dev->bus->suspend(dev, state);
        }
-
+       up(&dev->sem);
        return error;
 }
 
 
        struct kobject kobj;
        char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
 
+       struct semaphore        sem;    /* semaphore to synchronize calls to
+                                        * its driver.
+                                        */
+
        struct bus_type * bus;          /* type of bus device is on */
        struct device_driver *driver;   /* which driver has allocated this
                                           device */