Power Management: use mutexes instead of semaphores

The Power Management code uses semaphores as mutexes.  Use the mutex API
instead of the (binary) semaphores.

Signed-off-by: Matthias Kaehlcke <matthias.kaehlcke@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 05dc8764e7650170ceabfd9c7f0fc8223afd33ce..7b3cc3c15b9d82eecfaf3ca7c9e66f7c1afcbc61 100644 (file)
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -20,14 +20,16 @@
  */
 
 #include <linux/device.h>
+#include <linux/mutex.h>
+
 #include "power.h"
 
 LIST_HEAD(dpm_active);
 LIST_HEAD(dpm_off);
 LIST_HEAD(dpm_off_irq);
 
-DECLARE_MUTEX(dpm_sem);
-DECLARE_MUTEX(dpm_list_sem);
+DEFINE_MUTEX(dpm_mtx);
+DEFINE_MUTEX(dpm_list_mtx);
 
 int (*platform_enable_wakeup)(struct device *dev, int is_on);
 
@@ -59,12 +61,12 @@ int device_pm_add(struct device * dev)
        pr_debug("PM: Adding info for %s:%s\n",
                 dev->bus ? dev->bus->name : "No Bus",
                 kobject_name(&dev->kobj));
-       down(&dpm_list_sem);
+       mutex_lock(&dpm_list_mtx);
        list_add_tail(&dev->power.entry, &dpm_active);
        device_pm_set_parent(dev, dev->parent);
        if ((error = dpm_sysfs_add(dev)))
                list_del(&dev->power.entry);
-       up(&dpm_list_sem);
+       mutex_unlock(&dpm_list_mtx);
        return error;
 }
 
@@ -73,11 +75,11 @@ void device_pm_remove(struct device * dev)
        pr_debug("PM: Removing info for %s:%s\n",
                 dev->bus ? dev->bus->name : "No Bus",
                 kobject_name(&dev->kobj));
-       down(&dpm_list_sem);
+       mutex_lock(&dpm_list_mtx);
        dpm_sysfs_remove(dev);
        put_device(dev->power.pm_parent);
        list_del_init(&dev->power.entry);
-       up(&dpm_list_sem);
+       mutex_unlock(&dpm_list_mtx);
 }
 
 

diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index fb3d35a9e101582563b357848617cd7539e65e3a..2760f25b3ac5794a3e4557b28266c8354af740f6 100644 (file)
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -14,12 +14,12 @@ extern void device_shutdown(void);
 /*
  * Used to synchronize global power management operations.
  */
-extern struct semaphore dpm_sem;
+extern struct mutex dpm_mtx;
 
 /*
  * Used to serialize changes to the dpm_* lists.
  */
-extern struct semaphore dpm_list_sem;
+extern struct mutex dpm_list_mtx;
 
 /*
  * The PM lists.

diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
index a2c64188d7133fc95c31343592039f7ace18a64b..f6cfea496ea0838653b113259071a9dfc7b23e7b 100644 (file)
--- a/drivers/base/power/resume.c
+++ b/drivers/base/power/resume.c
@@ -80,7 +80,7 @@ static int resume_device_early(struct device * dev)
  */
 void dpm_resume(void)
 {
-       down(&dpm_list_sem);
+       mutex_lock(&dpm_list_mtx);
        while(!list_empty(&dpm_off)) {
                struct list_head * entry = dpm_off.next;
                struct device * dev = to_device(entry);
@@ -88,13 +88,13 @@ void dpm_resume(void)
                get_device(dev);
                list_move_tail(entry, &dpm_active);
 
-               up(&dpm_list_sem);
+               mutex_unlock(&dpm_list_mtx);
                if (!dev->power.prev_state.event)
                        resume_device(dev);
-               down(&dpm_list_sem);
+               mutex_lock(&dpm_list_mtx);
                put_device(dev);
        }
-       up(&dpm_list_sem);
+       mutex_unlock(&dpm_list_mtx);
 }
 
 
@@ -108,9 +108,9 @@ void dpm_resume(void)
 void device_resume(void)
 {
        might_sleep();
-       down(&dpm_sem);
+       mutex_lock(&dpm_mtx);
        dpm_resume();
-       up(&dpm_sem);
+       mutex_unlock(&dpm_mtx);
 }
 
 EXPORT_SYMBOL_GPL(device_resume);

diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 96370ec1d673fc3d07a2a03b496980517891c304..df6174d858664288dc93fb34c36c23bfe8faed29 100644 (file)
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -32,9 +32,9 @@ static void runtime_resume(struct device * dev)
 
 void dpm_runtime_resume(struct device * dev)
 {
-       down(&dpm_sem);
+       mutex_lock(&dpm_mtx);
        runtime_resume(dev);
-       up(&dpm_sem);
+       mutex_unlock(&dpm_mtx);
 }
 EXPORT_SYMBOL(dpm_runtime_resume);
 
@@ -49,7 +49,7 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state)
 {
        int error = 0;
 
-       down(&dpm_sem);
+       mutex_lock(&dpm_mtx);
        if (dev->power.power_state.event == state.event)
                goto Done;
 
@@ -59,7 +59,7 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state)
        if (!(error = suspend_device(dev, state)))
                dev->power.power_state = state;
  Done:
-       up(&dpm_sem);
+       mutex_unlock(&dpm_mtx);
        return error;
 }
 EXPORT_SYMBOL(dpm_runtime_suspend);
@@ -78,8 +78,8 @@ EXPORT_SYMBOL(dpm_runtime_suspend);
  */
 void dpm_set_power_state(struct device * dev, pm_message_t state)
 {
-       down(&dpm_sem);
+       mutex_lock(&dpm_mtx);
        dev->power.power_state = state;
-       up(&dpm_sem);
+       mutex_unlock(&dpm_mtx);
 }
 #endif  /*  0  */

diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
index 42d2b86ba7652944917a2b40a31d70e485a60622..9d6701cd7f109fd39bba3538c00212f6ab38961e 100644 (file)
--- a/drivers/base/power/suspend.c
+++ b/drivers/base/power/suspend.c
@@ -108,7 +108,7 @@ int suspend_device(struct device * dev, pm_message_t state)
 
 /*
  * This is called with interrupts off, only a single CPU
- * running. We can't do down() on a semaphore (and we don't
+ * running. We can't acquire a mutex or semaphore (and we don't
  * need the protection)
  */
 static int suspend_device_late(struct device *dev, pm_message_t state)
@@ -153,18 +153,18 @@ int device_suspend(pm_message_t state)
        int error = 0;
 
        might_sleep();
-       down(&dpm_sem);
-       down(&dpm_list_sem);
+       mutex_lock(&dpm_mtx);
+       mutex_lock(&dpm_list_mtx);
        while (!list_empty(&dpm_active) && error == 0) {
                struct list_head * entry = dpm_active.prev;
                struct device * dev = to_device(entry);
 
                get_device(dev);
-               up(&dpm_list_sem);
+               mutex_unlock(&dpm_list_mtx);
 
                error = suspend_device(dev, state);
 
-               down(&dpm_list_sem);
+               mutex_lock(&dpm_list_mtx);
 
                /* Check if the device got removed */
                if (!list_empty(&dev->power.entry)) {
@@ -179,11 +179,11 @@ int device_suspend(pm_message_t state)
                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
                put_device(dev);
        }
-       up(&dpm_list_sem);
+       mutex_unlock(&dpm_list_mtx);
        if (error)
                dpm_resume();
 
-       up(&dpm_sem);
+       mutex_unlock(&dpm_mtx);
        return error;
 }