Input: serio - semaphore to mutex conversion

The conversion was generated via scripts, and the result was validated
automatically via a script as well.

Signed-off-by: Arjan van de Ven <arjan@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

5 files changed, 46 insertions, 43 deletions

diff --git a/drivers/input/serio/libps2.c b/drivers/input/serio/libps2.c
index d4c990f7c85e..79c97f94bcbd 100644
--- a/drivers/input/serio/libps2.c
+++ b/drivers/input/serio/libps2.c
@@ -84,7 +84,7 @@ void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
                 maxbytes = sizeof(ps2dev->cmdbuf);
         }
 
-        down(&ps2dev->cmd_sem);
+        mutex_lock(&ps2dev->cmd_mutex);
 
         serio_pause_rx(ps2dev->serio);
         ps2dev->flags = PS2_FLAG_CMD;
@@ -94,7 +94,7 @@ void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout)
         wait_event_timeout(ps2dev->wait,
                            !(ps2dev->flags & PS2_FLAG_CMD),
                            msecs_to_jiffies(timeout));
-        up(&ps2dev->cmd_sem);
+        mutex_unlock(&ps2dev->cmd_mutex);
 }
 
 /*
@@ -177,7 +177,7 @@ int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
                 return -1;
         }
 
-        down(&ps2dev->cmd_sem);
+        mutex_lock(&ps2dev->cmd_mutex);
 
         serio_pause_rx(ps2dev->serio);
         ps2dev->flags = command == PS2_CMD_GETID ? PS2_FLAG_WAITID : 0;
@@ -229,7 +229,7 @@ int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
         ps2dev->flags = 0;
         serio_continue_rx(ps2dev->serio);
 
-        up(&ps2dev->cmd_sem);
+        mutex_unlock(&ps2dev->cmd_mutex);
         return rc;
 }
 
@@ -281,7 +281,7 @@ int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int comman
 
 void ps2_init(struct ps2dev *ps2dev, struct serio *serio)
 {
-        init_MUTEX(&ps2dev->cmd_sem);
+        mutex_init(&ps2dev->cmd_mutex);
         init_waitqueue_head(&ps2dev->wait);
         ps2dev->serio = serio;
 }
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 2f76813c3a64..79e5e77ce03e 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -34,6 +34,7 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/kthread.h>
+#include <linux/mutex.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Serio abstraction core");
@@ -52,10 +53,10 @@ EXPORT_SYMBOL(serio_rescan);
 EXPORT_SYMBOL(serio_reconnect);
 
 /*
- * serio_sem protects entire serio subsystem and is taken every time
+ * serio_mutex protects entire serio subsystem and is taken every time
  * serio port or driver registrered or unregistered.
  */
-static DECLARE_MUTEX(serio_sem);
+static DEFINE_MUTEX(serio_mutex);
 
 static LIST_HEAD(serio_list);
 
@@ -70,9 +71,9 @@ static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
 {
         int retval;
 
-        down(&serio->drv_sem);
+        mutex_lock(&serio->drv_mutex);
         retval = drv->connect(serio, drv);
-        up(&serio->drv_sem);
+        mutex_unlock(&serio->drv_mutex);
 
         return retval;
 }
@@ -81,20 +82,20 @@ static int serio_reconnect_driver(struct serio *serio)
 {
         int retval = -1;
 
-        down(&serio->drv_sem);
+        mutex_lock(&serio->drv_mutex);
         if (serio->drv && serio->drv->reconnect)
                 retval = serio->drv->reconnect(serio);
-        up(&serio->drv_sem);
+        mutex_unlock(&serio->drv_mutex);
 
         return retval;
 }
 
 static void serio_disconnect_driver(struct serio *serio)
 {
-        down(&serio->drv_sem);
+        mutex_lock(&serio->drv_mutex);
         if (serio->drv)
                 serio->drv->disconnect(serio);
-        up(&serio->drv_sem);
+        mutex_unlock(&serio->drv_mutex);
 }
 
 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
@@ -272,7 +273,7 @@ static void serio_handle_event(void)
         struct serio_event *event;
         struct serio_driver *serio_drv;
 
-        down(&serio_sem);
+        mutex_lock(&serio_mutex);
 
         /*
          * Note that we handle only one event here to give swsusp
@@ -314,7 +315,7 @@ static void serio_handle_event(void)
                 serio_free_event(event);
         }
 
-        up(&serio_sem);
+        mutex_unlock(&serio_mutex);
 }
 
 /*
@@ -449,7 +450,7 @@ static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *
         struct device_driver *drv;
         int retval;
 
-        retval = down_interruptible(&serio_sem);
+        retval = mutex_lock_interruptible(&serio_mutex);
         if (retval)
                 return retval;
 
@@ -469,7 +470,7 @@ static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *
                 retval = -EINVAL;
         }
 
-        up(&serio_sem);
+        mutex_unlock(&serio_mutex);
 
         return retval;
 }
@@ -524,7 +525,7 @@ static void serio_init_port(struct serio *serio)
         __module_get(THIS_MODULE);
 
         spin_lock_init(&serio->lock);
-        init_MUTEX(&serio->drv_sem);
+        mutex_init(&serio->drv_mutex);
         device_initialize(&serio->dev);
         snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),
                  "serio%ld", (long)atomic_inc_return(&serio_no) - 1);
@@ -661,10 +662,10 @@ void __serio_register_port(struct serio *serio, struct module *owner)
  */
 void serio_unregister_port(struct serio *serio)
 {
-        down(&serio_sem);
+        mutex_lock(&serio_mutex);
         serio_disconnect_port(serio);
         serio_destroy_port(serio);
-        up(&serio_sem);
+        mutex_unlock(&serio_mutex);
 }
 
 /*
@@ -672,17 +673,17 @@ void serio_unregister_port(struct serio *serio)
  */
 void serio_unregister_child_port(struct serio *serio)
 {
-        down(&serio_sem);
+        mutex_lock(&serio_mutex);
         if (serio->child) {
                 serio_disconnect_port(serio->child);
                 serio_destroy_port(serio->child);
         }
-        up(&serio_sem);
+        mutex_unlock(&serio_mutex);
 }
 
 /*
  * Submits register request to kseriod for subsequent execution.
- * Can be used when it is not obvious whether the serio_sem is
+ * Can be used when it is not obvious whether the serio_mutex is
  * taken or not and when delayed execution is feasible.
  */
 void __serio_unregister_port_delayed(struct serio *serio, struct module *owner)
@@ -765,7 +766,7 @@ void serio_unregister_driver(struct serio_driver *drv)
 {
         struct serio *serio;
 
-        down(&serio_sem);
+        mutex_lock(&serio_mutex);
         drv->manual_bind = 1;   /* so serio_find_driver ignores it */
 
 start_over:
@@ -779,7 +780,7 @@ start_over:
         }
 
         driver_unregister(&drv->driver);
-        up(&serio_sem);
+        mutex_unlock(&serio_mutex);
 }
 
 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
@@ -858,7 +859,7 @@ static int serio_resume(struct device *dev)
         return 0;
 }
 
-/* called from serio_driver->connect/disconnect methods under serio_sem */
+/* called from serio_driver->connect/disconnect methods under serio_mutex */
 int serio_open(struct serio *serio, struct serio_driver *drv)
 {
         serio_set_drv(serio, drv);
@@ -870,7 +871,7 @@ int serio_open(struct serio *serio, struct serio_driver *drv)
         return 0;
 }
 
-/* called from serio_driver->connect/disconnect methods under serio_sem */
+/* called from serio_driver->connect/disconnect methods under serio_mutex */
 void serio_close(struct serio *serio)
 {
         if (serio->close)
diff --git a/drivers/input/serio/serio_raw.c b/drivers/input/serio/serio_raw.c
index 47e08de18d07..8734e7f75b7d 100644
--- a/drivers/input/serio/serio_raw.c
+++ b/drivers/input/serio/serio_raw.c
@@ -19,6 +19,7 @@
 #include <linux/devfs_fs_kernel.h>
 #include <linux/miscdevice.h>
 #include <linux/wait.h>
+#include <linux/mutex.h>
 
 #define DRIVER_DESC     "Raw serio driver"
 
@@ -46,7 +47,7 @@ struct serio_raw_list {
         struct list_head node;
 };
 
-static DECLARE_MUTEX(serio_raw_sem);
+static DEFINE_MUTEX(serio_raw_mutex);
 static LIST_HEAD(serio_raw_list);
 static unsigned int serio_raw_no;
 
@@ -81,7 +82,7 @@ static int serio_raw_open(struct inode *inode, struct file *file)
         struct serio_raw_list *list;
         int retval = 0;
 
-        retval = down_interruptible(&serio_raw_sem);
+        retval = mutex_lock_interruptible(&serio_raw_mutex);
         if (retval)
                 return retval;
 
@@ -108,7 +109,7 @@ static int serio_raw_open(struct inode *inode, struct file *file)
         list_add_tail(&list->node, &serio_raw->list);
 
 out:
-        up(&serio_raw_sem);
+        mutex_unlock(&serio_raw_mutex);
         return retval;
 }
 
@@ -130,12 +131,12 @@ static int serio_raw_release(struct inode *inode, struct file *file)
         struct serio_raw_list *list = file->private_data;
         struct serio_raw *serio_raw = list->serio_raw;
 
-        down(&serio_raw_sem);
+        mutex_lock(&serio_raw_mutex);
 
         serio_raw_fasync(-1, file, 0);
         serio_raw_cleanup(serio_raw);
 
-        up(&serio_raw_sem);
+        mutex_unlock(&serio_raw_mutex);
         return 0;
 }
 
@@ -194,7 +195,7 @@ static ssize_t serio_raw_write(struct file *file, const char __user *buffer, siz
         int retval;
         unsigned char c;
 
-        retval = down_interruptible(&serio_raw_sem);
+        retval = mutex_lock_interruptible(&serio_raw_mutex);
         if (retval)
                 return retval;
 
@@ -219,7 +220,7 @@ static ssize_t serio_raw_write(struct file *file, const char __user *buffer, siz
         };
 
 out:
-        up(&serio_raw_sem);
+        mutex_unlock(&serio_raw_mutex);
         return written;
 }
 
@@ -280,7 +281,7 @@ static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
                 return -ENOMEM;
         }
 
-        down(&serio_raw_sem);
+        mutex_lock(&serio_raw_mutex);
 
         memset(serio_raw, 0, sizeof(struct serio_raw));
         snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);
@@ -325,7 +326,7 @@ out_free:
         serio_set_drvdata(serio, NULL);
         kfree(serio_raw);
 out:
-        up(&serio_raw_sem);
+        mutex_unlock(&serio_raw_mutex);
         return err;
 }
 
@@ -350,7 +351,7 @@ static void serio_raw_disconnect(struct serio *serio)
 {
         struct serio_raw *serio_raw;
 
-        down(&serio_raw_sem);
+        mutex_lock(&serio_raw_mutex);
 
         serio_raw = serio_get_drvdata(serio);
 
@@ -361,7 +362,7 @@ static void serio_raw_disconnect(struct serio *serio)
         if (!serio_raw_cleanup(serio_raw))
                 wake_up_interruptible(&serio_raw->wait);
 
-        up(&serio_raw_sem);
+        mutex_unlock(&serio_raw_mutex);
 }
 
 static struct serio_device_id serio_raw_serio_ids[] = {
diff --git a/include/linux/libps2.h b/include/linux/libps2.h
index a710bddda4eb..08a450a9dbf7 100644
--- a/include/linux/libps2.h
+++ b/include/linux/libps2.h
@@ -28,7 +28,7 @@ struct ps2dev {
         struct serio *serio;
 
         /* Ensures that only one command is executing at a time */
-        struct semaphore cmd_sem;
+        struct mutex cmd_mutex;
 
         /* Used to signal completion from interrupt handler */
         wait_queue_head_t wait;
diff --git a/include/linux/serio.h b/include/linux/serio.h
index aa4d6493a034..582db2392d94 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -18,6 +18,7 @@
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
 
@@ -42,7 +43,7 @@ struct serio {
         struct serio *parent, *child;
 
         struct serio_driver *drv;       /* accessed from interrupt, must be protected by serio->lock and serio->sem */
-        struct semaphore drv_sem;       /* protects serio->drv so attributes can pin driver */
+        struct mutex drv_mutex;         /* protects serio->drv so attributes can pin driver */
 
         struct device dev;
         unsigned int registered;        /* port has been fully registered with driver core */
@@ -151,17 +152,17 @@ static inline void serio_continue_rx(struct serio *serio)
  */
 static inline int serio_pin_driver(struct serio *serio)
 {
-        return down_interruptible(&serio->drv_sem);
+        return mutex_lock_interruptible(&serio->drv_mutex);
 }
 
 static inline void serio_pin_driver_uninterruptible(struct serio *serio)
 {
-        down(&serio->drv_sem);
+        mutex_lock(&serio->drv_mutex);
 }
 
 static inline void serio_unpin_driver(struct serio *serio)
 {
-        up(&serio->drv_sem);
+        mutex_unlock(&serio->drv_mutex);
 }