6 files changed, 101 insertions, 56 deletions

diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index 3020ca2b602b..278319bbdea1 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>
@@ -149,7 +150,7 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = {
 { 0x49544561, 0xffffffff, "IT2646E",            patch_it2646,   NULL },
 { 0x4e534300, 0xffffffff, "LM4540,43,45,46,48", NULL,           NULL }, // only guess --jk
 { 0x4e534331, 0xffffffff, "LM4549",             NULL,           NULL },
-{ 0x4e534350, 0xffffffff, "LM4550",             NULL,           NULL },
+{ 0x4e534350, 0xffffffff, "LM4550",             patch_lm4550,   NULL }, // volume wrap fix 
 { 0x50534304, 0xffffffff, "UCB1400",            NULL,           NULL },
 { 0x53494c20, 0xffffffe0, "Si3036,8",           mpatch_si3036,  mpatch_si3036, AC97_MODEM_PATCH },
 { 0x54524102, 0xffffffff, "TR28022",            NULL,           NULL },
@@ -191,9 +192,6 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = {
 
 static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg)
 {
-        if (ac97->limited_regs && ! test_bit(reg, ac97->reg_accessed))
-                return 0;
-
         /* filter some registers for buggy codecs */
         switch (ac97->id) {
         case AC97_ID_AK4540:
@@ -296,11 +294,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 +319,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 +349,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 +378,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 +395,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 +465,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 +476,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 +672,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 +716,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 +744,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 +761,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 +775,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 +886,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;
 }
 
@@ -1007,9 +1005,6 @@ static int snd_ac97_try_volume_mix(struct snd_ac97 * ac97, int reg)
                 break;
         }
 
-        if (ac97->limited_regs && test_bit(reg, ac97->reg_accessed))
-                return 1; /* allow without check */
-
         val = snd_ac97_read(ac97, reg);
         if (!(val & mask)) {
                 /* nothing seems to be here - mute flag is not set */
@@ -1029,6 +1024,18 @@ static void check_volume_resolution(struct snd_ac97 *ac97, int reg, unsigned cha
         unsigned char max[3] = { 63, 31, 15 };
         int i;
 
+        /* first look up the static resolution table */
+        if (ac97->res_table) {
+                const struct snd_ac97_res_table *tbl;
+                for (tbl = ac97->res_table; tbl->reg; tbl++) {
+                        if (tbl->reg == reg) {
+                                *lo_max = tbl->bits & 0xff;
+                                *hi_max = (tbl->bits >> 8) & 0xff;
+                                return;
+                        }
+                }
+        }
+
         *lo_max = *hi_max = 0;
         for (i = 0 ; i < ARRAY_SIZE(cbit); i++) {
                 unsigned short val;
@@ -1853,11 +1860,10 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
         ac97->num = template->num;
         ac97->addr = template->addr;
         ac97->scaps = template->scaps;
-        ac97->limited_regs = template->limited_regs;
-        memcpy(ac97->reg_accessed, template->reg_accessed, sizeof(ac97->reg_accessed));
+        ac97->res_table = template->res_table;
         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..4d9cf37300f7 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;
 }
 
@@ -2823,3 +2825,33 @@ int mpatch_si3036(struct snd_ac97 * ac97)
         snd_ac97_write_cache(ac97, 0x68, 0);
         return 0;
 }
+
+/*
+ * LM 4550 Codec
+ *
+ * We use a static resolution table since LM4550 codec cannot be
+ * properly autoprobed to determine the resolution via
+ * check_volume_resolution().
+ */
+
+static struct snd_ac97_res_table lm4550_restbl[] = {
+        { AC97_MASTER, 0x1f1f },
+        { AC97_HEADPHONE, 0x1f1f },
+        { AC97_MASTER_MONO, 0x001f },
+        { AC97_PC_BEEP, 0x001f },       /* LSB is ignored */
+        { AC97_PHONE, 0x001f },
+        { AC97_MIC, 0x001f },
+        { AC97_LINE, 0x1f1f },
+        { AC97_CD, 0x1f1f },
+        { AC97_VIDEO, 0x1f1f },
+        { AC97_AUX, 0x1f1f },
+        { AC97_PCM, 0x1f1f },
+        { AC97_REC_GAIN, 0x0f0f },
+        { } /* terminator */
+};
+
+int patch_lm4550(struct snd_ac97 *ac97)
+{
+        ac97->res_table = lm4550_restbl;
+        return 0;
+}
diff --git a/sound/pci/ac97/ac97_patch.h b/sound/pci/ac97/ac97_patch.h
index 5060cb6f2ec3..adcaa04586cb 100644
--- a/sound/pci/ac97/ac97_patch.h
+++ b/sound/pci/ac97/ac97_patch.h
@@ -59,3 +59,4 @@ int patch_vt1616(struct snd_ac97 * ac97);
 int patch_vt1617a(struct snd_ac97 * ac97);
 int patch_it2646(struct snd_ac97 * ac97);
 int mpatch_si3036(struct snd_ac97 * ac97);
+int patch_lm4550(struct snd_ac97 * ac97);
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;