[ALSA] semaphore -> mutex (PCI part)

Semaphore to mutex conversion.

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

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

5 files changed, 56 insertions, 47 deletions

diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index 3020ca2b602b..6108cdc5efb6 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -28,6 +28,7 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/moduleparam.h>
+#include <linux/mutex.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/ac97_codec.h>
@@ -296,11 +297,11 @@ void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned sh
 {
         if (!snd_ac97_valid_reg(ac97, reg))
                 return;
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         ac97->regs[reg] = value;
         ac97->bus->ops->write(ac97, reg, value);
         set_bit(reg, ac97->reg_accessed);
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
 }
 
 /**
@@ -321,14 +322,14 @@ int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short va
 
         if (!snd_ac97_valid_reg(ac97, reg))
                 return -EINVAL;
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         change = ac97->regs[reg] != value;
         if (change) {
                 ac97->regs[reg] = value;
                 ac97->bus->ops->write(ac97, reg, value);
         }
         set_bit(reg, ac97->reg_accessed);
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
         return change;
 }
 
@@ -351,9 +352,9 @@ int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned sho
 
         if (!snd_ac97_valid_reg(ac97, reg))
                 return -EINVAL;
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
         return change;
 }
 
@@ -380,12 +381,12 @@ static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, uns
         int change;
         unsigned short old, new, cfg;
 
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         old = ac97->spec.ad18xx.pcmreg[codec];
         new = (old & ~mask) | value;
         change = old != new;
         if (change) {
-                down(&ac97->reg_mutex);
+                mutex_lock(&ac97->reg_mutex);
                 cfg = snd_ac97_read_cache(ac97, AC97_AD_SERIAL_CFG);
                 ac97->spec.ad18xx.pcmreg[codec] = new;
                 /* select single codec */
@@ -397,9 +398,9 @@ static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, uns
                 /* select all codecs */
                 ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
                                  cfg | 0x7000);
-                up(&ac97->reg_mutex);
+                mutex_unlock(&ac97->reg_mutex);
         }
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
         return change;
 }
 
@@ -467,7 +468,7 @@ static int snd_ac97_page_save(struct snd_ac97 *ac97, int reg, struct snd_kcontro
             (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23 &&
             (reg >= 0x60 && reg < 0x70)) {
                 unsigned short page = (kcontrol->private_value >> 26) & 0x0f;
-                down(&ac97->page_mutex); /* lock paging */
+                mutex_lock(&ac97->page_mutex); /* lock paging */
                 page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
                 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
         }
@@ -478,7 +479,7 @@ static void snd_ac97_page_restore(struct snd_ac97 *ac97, int page_save)
 {
         if (page_save >= 0) {
                 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
-                up(&ac97->page_mutex); /* unlock paging */
+                mutex_unlock(&ac97->page_mutex); /* unlock paging */
         }
 }
 
@@ -674,12 +675,12 @@ static int snd_ac97_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_
 {
         struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
         ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
         ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
         ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
         return 0;
 }
                         
@@ -718,7 +719,7 @@ static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_
                 }
         }
 
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         change = ac97->spdif_status != new;
         ac97->spdif_status = new;
 
@@ -746,7 +747,7 @@ static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_
                         snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
                 }
         }
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
 
         return change;
 }
@@ -763,7 +764,7 @@ static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_
 
         value = (ucontrol->value.integer.value[0] & mask);
 
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         mask <<= shift;
         value <<= shift;
         old = snd_ac97_read_cache(ac97, reg);
@@ -777,7 +778,7 @@ static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_
                 if (extst & AC97_EA_SPDIF)
                         snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
         }
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
         return change;
 }
 
@@ -888,10 +889,10 @@ static int snd_ac97_ad18xx_pcm_get_volume(struct snd_kcontrol *kcontrol, struct
         struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
         int codec = kcontrol->private_value & 3;
         
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
         ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
         return 0;
 }
 
@@ -1856,8 +1857,8 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
         ac97->limited_regs = template->limited_regs;
         memcpy(ac97->reg_accessed, template->reg_accessed, sizeof(ac97->reg_accessed));
         bus->codec[ac97->num] = ac97;
-        init_MUTEX(&ac97->reg_mutex);
-        init_MUTEX(&ac97->page_mutex);
+        mutex_init(&ac97->reg_mutex);
+        mutex_init(&ac97->page_mutex);
 
 #ifdef CONFIG_PCI
         if (ac97->pci) {
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
index a444a78c7c94..8bc79cbe3215 100644
--- a/sound/pci/ac97/ac97_patch.c
+++ b/sound/pci/ac97/ac97_patch.c
@@ -27,6 +27,8 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/control.h>
@@ -55,12 +57,12 @@ static int ac97_update_bits_page(struct snd_ac97 *ac97, unsigned short reg, unsi
         unsigned short page_save;
         int ret;
 
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
         snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
         ret = snd_ac97_update_bits(ac97, reg, mask, value);
         snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
-        up(&ac97->page_mutex); /* unlock paging */
+        mutex_unlock(&ac97->page_mutex); /* unlock paging */
         return ret;
 }
 
@@ -897,12 +899,12 @@ static int snd_ac97_stac9708_put_bias(struct snd_kcontrol *kcontrol, struct snd_
         struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
         int err;
 
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
         err = snd_ac97_update_bits(ac97, AC97_SIGMATEL_BIAS2, 0x0010,
                                    (ucontrol->value.integer.value[0] & 1) << 4);
         snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0);
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
         return err;
 }
 
diff --git a/sound/pci/ac97/ac97_pcm.c b/sound/pci/ac97/ac97_pcm.c
index c3e590bf7a02..512a3583b0ce 100644
--- a/sound/pci/ac97/ac97_pcm.c
+++ b/sound/pci/ac97/ac97_pcm.c
@@ -27,6 +27,8 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/control.h>
@@ -206,7 +208,7 @@ static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate)
                 mask = AC97_SC_SPSR_MASK;
         }
 
-        down(&ac97->reg_mutex);
+        mutex_lock(&ac97->reg_mutex);
         old = snd_ac97_read(ac97, reg) & mask;
         if (old != bits) {
                 snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
@@ -231,7 +233,7 @@ static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate)
                 ac97->spdif_status = sbits;
         }
         snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF);
-        up(&ac97->reg_mutex);
+        mutex_unlock(&ac97->reg_mutex);
         return 0;
 }
 
diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
index 7134b3f55fb5..4d523df79cc7 100644
--- a/sound/pci/ac97/ac97_proc.c
+++ b/sound/pci/ac97/ac97_proc.c
@@ -24,6 +24,8 @@
 
 #include <sound/driver.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include <sound/ac97_codec.h>
 #include <sound/asoundef.h>
@@ -338,7 +340,7 @@ static void snd_ac97_proc_read(struct snd_info_entry *entry, struct snd_info_buf
 {
         struct snd_ac97 *ac97 = entry->private_data;
         
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) {        // Analog Devices AD1881/85/86
                 int idx;
                 for (idx = 0; idx < 3; idx++)
@@ -364,7 +366,7 @@ static void snd_ac97_proc_read(struct snd_info_entry *entry, struct snd_info_buf
         } else {
                 snd_ac97_proc_read_main(ac97, buffer, 0);
         }
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
 }
 
 #ifdef CONFIG_SND_DEBUG
@@ -374,7 +376,7 @@ static void snd_ac97_proc_regs_write(struct snd_info_entry *entry, struct snd_in
         struct snd_ac97 *ac97 = entry->private_data;
         char line[64];
         unsigned int reg, val;
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x", &reg, &val) != 2)
                         continue;
@@ -382,7 +384,7 @@ static void snd_ac97_proc_regs_write(struct snd_info_entry *entry, struct snd_in
                 if (reg < 0x80 && (reg & 1) == 0 && val <= 0xffff)
                         snd_ac97_write_cache(ac97, reg, val);
         }
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
 }
 #endif
 
@@ -401,7 +403,7 @@ static void snd_ac97_proc_regs_read(struct snd_info_entry *entry,
 {
         struct snd_ac97 *ac97 = entry->private_data;
 
-        down(&ac97->page_mutex);
+        mutex_lock(&ac97->page_mutex);
         if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) {        // Analog Devices AD1881/85/86
 
                 int idx;
@@ -417,7 +419,7 @@ static void snd_ac97_proc_regs_read(struct snd_info_entry *entry,
         } else {
                 snd_ac97_proc_regs_read_main(ac97, buffer, 0);
         }       
-        up(&ac97->page_mutex);
+        mutex_unlock(&ac97->page_mutex);
 }
 
 void snd_ac97_proc_init(struct snd_ac97 * ac97)
diff --git a/sound/pci/ac97/ak4531_codec.c b/sound/pci/ac97/ak4531_codec.c
index dcfb5036ff8b..0fb7b3407312 100644
--- a/sound/pci/ac97/ak4531_codec.c
+++ b/sound/pci/ac97/ak4531_codec.c
@@ -23,6 +23,8 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include <sound/ak4531_codec.h>
 
@@ -82,9 +84,9 @@ static int snd_ak4531_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         int invert = (kcontrol->private_value >> 22) & 1;
         int val;
 
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         val = (ak4531->regs[reg] >> shift) & mask;
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         if (invert) {
                 val = mask - val;
         }
@@ -107,11 +109,11 @@ static int snd_ak4531_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e
                 val = mask - val;
         }
         val <<= shift;
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         val = (ak4531->regs[reg] & ~(mask << shift)) | val;
         change = val != ak4531->regs[reg];
         ak4531->write(ak4531, reg, ak4531->regs[reg] = val);
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         return change;
 }
 
@@ -143,10 +145,10 @@ static int snd_ak4531_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         int invert = (kcontrol->private_value >> 22) & 1;
         int left, right;
 
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         left = (ak4531->regs[left_reg] >> left_shift) & mask;
         right = (ak4531->regs[right_reg] >> right_shift) & mask;
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         if (invert) {
                 left = mask - left;
                 right = mask - right;
@@ -176,7 +178,7 @@ static int snd_ak4531_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         }
         left <<= left_shift;
         right <<= right_shift;
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         if (left_reg == right_reg) {
                 left = (ak4531->regs[left_reg] & ~((mask << left_shift) | (mask << right_shift))) | left | right;
                 change = left != ak4531->regs[left_reg];
@@ -188,7 +190,7 @@ static int snd_ak4531_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e
                 ak4531->write(ak4531, left_reg, ak4531->regs[left_reg] = left);
                 ak4531->write(ak4531, right_reg, ak4531->regs[right_reg] = right);
         }
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         return change;
 }
 
@@ -215,12 +217,12 @@ static int snd_ak4531_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl
         int left_shift = (kcontrol->private_value >> 16) & 0x0f;
         int right_shift = (kcontrol->private_value >> 24) & 0x0f;
 
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         ucontrol->value.integer.value[0] = (ak4531->regs[reg1] >> left_shift) & 1;
         ucontrol->value.integer.value[1] = (ak4531->regs[reg2] >> left_shift) & 1;
         ucontrol->value.integer.value[2] = (ak4531->regs[reg1] >> right_shift) & 1;
         ucontrol->value.integer.value[3] = (ak4531->regs[reg2] >> right_shift) & 1;
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         return 0;
 }
 
@@ -234,7 +236,7 @@ static int snd_ak4531_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl
         int change;
         int val1, val2;
 
-        down(&ak4531->reg_mutex);
+        mutex_lock(&ak4531->reg_mutex);
         val1 = ak4531->regs[reg1] & ~((1 << left_shift) | (1 << right_shift));
         val2 = ak4531->regs[reg2] & ~((1 << left_shift) | (1 << right_shift));
         val1 |= (ucontrol->value.integer.value[0] & 1) << left_shift;
@@ -244,7 +246,7 @@ static int snd_ak4531_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl
         change = val1 != ak4531->regs[reg1] || val2 != ak4531->regs[reg2];
         ak4531->write(ak4531, reg1, ak4531->regs[reg1] = val1);
         ak4531->write(ak4531, reg2, ak4531->regs[reg2] = val2);
-        up(&ak4531->reg_mutex);
+        mutex_unlock(&ak4531->reg_mutex);
         return change;
 }
 
@@ -366,7 +368,7 @@ int snd_ak4531_mixer(struct snd_card *card, struct snd_ak4531 *_ak4531,
         if (ak4531 == NULL)
                 return -ENOMEM;
         *ak4531 = *_ak4531;
-        init_MUTEX(&ak4531->reg_mutex);
+        mutex_init(&ak4531->reg_mutex);
         if ((err = snd_component_add(card, "AK4531")) < 0) {
                 snd_ak4531_free(ak4531);
                 return err;