[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>

1 files changed, 44 insertions, 42 deletions

diff --git a/sound/pci/ice1712/pontis.c b/sound/pci/ice1712/pontis.c
index 0dccd7707a4b..d23fb3fc2133 100644
--- a/sound/pci/ice1712/pontis.c
+++ b/sound/pci/ice1712/pontis.c
@@ -27,6 +27,8 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include <sound/info.h>
 
@@ -124,13 +126,13 @@ static int wm_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         unsigned short val;
         int i;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (i = 0; i < 2; i++) {
                 val = wm_get(ice, WM_DAC_ATTEN_L + i) & 0xff;
                 val = val > DAC_MIN ? (val - DAC_MIN) : 0;
                 ucontrol->value.integer.value[i] = val;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -140,7 +142,7 @@ static int wm_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         unsigned short oval, nval;
         int i, idx, change = 0;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (i = 0; i < 2; i++) {
                 nval = ucontrol->value.integer.value[i];
                 nval = (nval ? (nval + DAC_MIN) : 0) & 0xff;
@@ -152,7 +154,7 @@ static int wm_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
                         change = 1;
                 }
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return change;
 }
 
@@ -179,13 +181,13 @@ static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         unsigned short val;
         int i;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (i = 0; i < 2; i++) {
                 val = wm_get(ice, WM_ADC_ATTEN_L + i) & 0xff;
                 val = val > ADC_MIN ? (val - ADC_MIN) : 0;
                 ucontrol->value.integer.value[i] = val;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -195,7 +197,7 @@ static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         unsigned short ovol, nvol;
         int i, idx, change = 0;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (i = 0; i < 2; i++) {
                 nvol = ucontrol->value.integer.value[i];
                 nvol = nvol ? (nvol + ADC_MIN) : 0;
@@ -206,7 +208,7 @@ static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
                         change = 1;
                 }
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return change;
 }
 
@@ -227,9 +229,9 @@ static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
         int bit = kcontrol->private_value;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         ucontrol->value.integer.value[0] = (wm_get(ice, WM_ADC_MUX) & (1 << bit)) ? 1 : 0;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -240,7 +242,7 @@ static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         unsigned short oval, nval;
         int change;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         nval = oval = wm_get(ice, WM_ADC_MUX);
         if (ucontrol->value.integer.value[0])
                 nval |= (1 << bit);
@@ -250,7 +252,7 @@ static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val
         if (change) {
                 wm_put(ice, WM_ADC_MUX, nval);
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -270,9 +272,9 @@ static int wm_bypass_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         ucontrol->value.integer.value[0] = (wm_get(ice, WM_OUT_MUX) & 0x04) ? 1 : 0;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -282,7 +284,7 @@ static int wm_bypass_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
         unsigned short val, oval;
         int change = 0;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         val = oval = wm_get(ice, WM_OUT_MUX);
         if (ucontrol->value.integer.value[0])
                 val |= 0x04;
@@ -292,7 +294,7 @@ static int wm_bypass_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
                 wm_put(ice, WM_OUT_MUX, val);
                 change = 1;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return change;
 }
 
@@ -312,9 +314,9 @@ static int wm_chswap_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL1) & 0xf0) != 0x90;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -324,7 +326,7 @@ static int wm_chswap_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
         unsigned short val, oval;
         int change = 0;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         oval = wm_get(ice, WM_DAC_CTRL1);
         val = oval & 0x0f;
         if (ucontrol->value.integer.value[0])
@@ -336,7 +338,7 @@ static int wm_chswap_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
                 wm_put_nocache(ice, WM_DAC_CTRL1, val);
                 change = 1;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return change;
 }
 
@@ -449,9 +451,9 @@ static int cs_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         ucontrol->value.enumerated.item[0] = ice->gpio.saved[0];
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -461,14 +463,14 @@ static int cs_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu
         unsigned char val;
         int change = 0;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         if (ucontrol->value.enumerated.item[0] != ice->gpio.saved[0]) {
                 ice->gpio.saved[0] = ucontrol->value.enumerated.item[0] & 3;
                 val = 0x80 | (ice->gpio.saved[0] << 3);
                 spi_write(ice, CS_DEV, 0x04, val);
                 change = 1;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -488,10 +490,10 @@ static int pontis_gpio_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e
 static int pontis_gpio_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         /* 4-7 reserved */
         ucontrol->value.integer.value[0] = (~ice->gpio.write_mask & 0xffff) | 0x00f0;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
         
@@ -500,22 +502,22 @@ static int pontis_gpio_mask_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
         unsigned int val;
         int changed;
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         /* 4-7 reserved */
         val = (~ucontrol->value.integer.value[0] & 0xffff) | 0x00f0;
         changed = val != ice->gpio.write_mask;
         ice->gpio.write_mask = val;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return changed;
 }
 
 static int pontis_gpio_dir_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         /* 4-7 reserved */
         ucontrol->value.integer.value[0] = ice->gpio.direction & 0xff0f;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
         
@@ -524,23 +526,23 @@ static int pontis_gpio_dir_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
         unsigned int val;
         int changed;
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         /* 4-7 reserved */
         val = ucontrol->value.integer.value[0] & 0xff0f;
         changed = (val != ice->gpio.direction);
         ice->gpio.direction = val;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return changed;
 }
 
 static int pontis_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
         snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask);
         ucontrol->value.integer.value[0] = snd_ice1712_gpio_read(ice) & 0xffff;
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return 0;
 }
 
@@ -549,7 +551,7 @@ static int pontis_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
         unsigned int val, nval;
         int changed = 0;
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
         snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask);
         val = snd_ice1712_gpio_read(ice) & 0xffff;
@@ -558,7 +560,7 @@ static int pontis_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el
                 snd_ice1712_gpio_write(ice, nval);
                 changed = 1;
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
         return changed;
 }
 
@@ -651,14 +653,14 @@ static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buf
         struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
         char line[64];
         unsigned int reg, val;
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x", &reg, &val) != 2)
                         continue;
                 if (reg <= 0x17 && val <= 0xffff)
                         wm_put(ice, reg, val);
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
 }
 
 static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
@@ -666,12 +668,12 @@ static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff
         struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
         int reg, val;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (reg = 0; reg <= 0x17; reg++) {
                 val = wm_get(ice, reg);
                 snd_iprintf(buffer, "%02x = %04x\n", reg, val);
         }
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
 }
 
 static void wm_proc_init(struct snd_ice1712 *ice)
@@ -690,14 +692,14 @@ static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff
         struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
         int reg, val;
 
-        down(&ice->gpio_mutex);
+        mutex_lock(&ice->gpio_mutex);
         for (reg = 0; reg <= 0x26; reg++) {
                 val = spi_read(ice, CS_DEV, reg);
                 snd_iprintf(buffer, "%02x = %02x\n", reg, val);
         }
         val = spi_read(ice, CS_DEV, 0x7f);
         snd_iprintf(buffer, "%02x = %02x\n", 0x7f, val);
-        up(&ice->gpio_mutex);
+        mutex_unlock(&ice->gpio_mutex);
 }
 
 static void cs_proc_init(struct snd_ice1712 *ice)