1 files changed, 27 insertions, 26 deletions

diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index 9ece443fba55..d9a3e5a18d6a 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -45,6 +45,7 @@
 #include <sound/initval.h>
 #include <linux/kmod.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
 
 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
 MODULE_DESCRIPTION("ALSA sequencer device management");
@@ -69,7 +70,7 @@ struct ops_list {
         struct list_head dev_list;      /* list of devices */
         int num_devices;        /* number of associated devices */
         int num_init_devices;   /* number of initialized devices */
-        struct semaphore reg_mutex;
+        struct mutex reg_mutex;
 
         struct list_head list;  /* next driver */
 };
@@ -77,7 +78,7 @@ struct ops_list {
 
 static LIST_HEAD(opslist);
 static int num_ops;
-static DECLARE_MUTEX(ops_mutex);
+static DEFINE_MUTEX(ops_mutex);
 #ifdef CONFIG_PROC_FS
 static struct snd_info_entry *info_entry = NULL;
 #endif
@@ -108,7 +109,7 @@ static void snd_seq_device_info(struct snd_info_entry *entry,
 {
         struct list_head *head;
 
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         list_for_each(head, &opslist) {
                 struct ops_list *ops = list_entry(head, struct ops_list, list);
                 snd_iprintf(buffer, "snd-%s%s%s%s,%d\n",
@@ -118,7 +119,7 @@ static void snd_seq_device_info(struct snd_info_entry *entry,
                                 ops->driver & DRIVER_LOCKED ? ",locked" : "",
                                 ops->num_devices);
         }
-        up(&ops_mutex); 
+        mutex_unlock(&ops_mutex);
 }
 #endif
  
@@ -154,20 +155,20 @@ void snd_seq_device_load_drivers(void)
         if (! current->fs->root)
                 return;
 
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         list_for_each(head, &opslist) {
                 struct ops_list *ops = list_entry(head, struct ops_list, list);
                 if (! (ops->driver & DRIVER_LOADED) &&
                     ! (ops->driver & DRIVER_REQUESTED)) {
                         ops->used++;
-                        up(&ops_mutex);
+                        mutex_unlock(&ops_mutex);
                         ops->driver |= DRIVER_REQUESTED;
                         request_module("snd-%s", ops->id);
-                        down(&ops_mutex);
+                        mutex_lock(&ops_mutex);
                         ops->used--;
                 }
         }
-        up(&ops_mutex);
+        mutex_unlock(&ops_mutex);
 #endif
 }
 
@@ -214,10 +215,10 @@ int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
         dev->status = SNDRV_SEQ_DEVICE_FREE;
 
         /* add this device to the list */
-        down(&ops->reg_mutex);
+        mutex_lock(&ops->reg_mutex);
         list_add_tail(&dev->list, &ops->dev_list);
         ops->num_devices++;
-        up(&ops->reg_mutex);
+        mutex_unlock(&ops->reg_mutex);
 
         unlock_driver(ops);
         
@@ -246,10 +247,10 @@ static int snd_seq_device_free(struct snd_seq_device *dev)
                 return -ENXIO;
 
         /* remove the device from the list */
-        down(&ops->reg_mutex);
+        mutex_lock(&ops->reg_mutex);
         list_del(&dev->list);
         ops->num_devices--;
-        up(&ops->reg_mutex);
+        mutex_unlock(&ops->reg_mutex);
 
         free_device(dev, ops);
         if (dev->private_free)
@@ -344,7 +345,7 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
                 return -EBUSY;
         }
 
-        down(&ops->reg_mutex);
+        mutex_lock(&ops->reg_mutex);
         /* copy driver operators */
         ops->ops = *entry;
         ops->driver |= DRIVER_LOADED;
@@ -355,7 +356,7 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
                 struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
                 init_device(dev, ops);
         }
-        up(&ops->reg_mutex);
+        mutex_unlock(&ops->reg_mutex);
 
         unlock_driver(ops);
         snd_seq_autoload_unlock();
@@ -378,17 +379,17 @@ static struct ops_list * create_driver(char *id)
 
         /* set up driver entry */
         strlcpy(ops->id, id, sizeof(ops->id));
-        init_MUTEX(&ops->reg_mutex);
+        mutex_init(&ops->reg_mutex);
         ops->driver = DRIVER_EMPTY;
         INIT_LIST_HEAD(&ops->dev_list);
         /* lock this instance */
         ops->used = 1;
 
         /* register driver entry */
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         list_add_tail(&ops->list, &opslist);
         num_ops++;
-        up(&ops_mutex);
+        mutex_unlock(&ops_mutex);
 
         return ops;
 }
@@ -414,7 +415,7 @@ int snd_seq_device_unregister_driver(char *id)
         }
 
         /* close and release all devices associated with this driver */
-        down(&ops->reg_mutex);
+        mutex_lock(&ops->reg_mutex);
         ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */
         list_for_each(head, &ops->dev_list) {
                 struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
@@ -425,7 +426,7 @@ int snd_seq_device_unregister_driver(char *id)
         if (ops->num_init_devices > 0)
                 snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
                            ops->num_init_devices);
-        up(&ops->reg_mutex);
+        mutex_unlock(&ops->reg_mutex);
 
         unlock_driver(ops);
 
@@ -443,7 +444,7 @@ static void remove_drivers(void)
 {
         struct list_head *head;
 
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         head = opslist.next;
         while (head != &opslist) {
                 struct ops_list *ops = list_entry(head, struct ops_list, list);
@@ -456,7 +457,7 @@ static void remove_drivers(void)
                 } else
                         head = head->next;
         }
-        up(&ops_mutex);
+        mutex_unlock(&ops_mutex);
 }
 
 /*
@@ -519,16 +520,16 @@ static struct ops_list * find_driver(char *id, int create_if_empty)
 {
         struct list_head *head;
 
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         list_for_each(head, &opslist) {
                 struct ops_list *ops = list_entry(head, struct ops_list, list);
                 if (strcmp(ops->id, id) == 0) {
                         ops->used++;
-                        up(&ops_mutex);
+                        mutex_unlock(&ops_mutex);
                         return ops;
                 }
         }
-        up(&ops_mutex);
+        mutex_unlock(&ops_mutex);
         if (create_if_empty)
                 return create_driver(id);
         return NULL;
@@ -536,9 +537,9 @@ static struct ops_list * find_driver(char *id, int create_if_empty)
 
 static void unlock_driver(struct ops_list *ops)
 {
-        down(&ops_mutex);
+        mutex_lock(&ops_mutex);
         ops->used--;
-        up(&ops_mutex);
+        mutex_unlock(&ops_mutex);
 }