10 files changed, 255 insertions, 185 deletions
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 841475cc13b6..393a3043a46e 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -4795,6 +4795,59 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
+/**
+ * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
+ *
+ * Guess the suitable VREF pin bits to be set as the pin-control value.
+ * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
+ */
+unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
+{
+        unsigned int pincap;
+        unsigned int oldval;
+        oldval = snd_hda_codec_read(codec, pin, 0,
+                                    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+        pincap = snd_hda_query_pin_caps(codec, pin);
+        pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
+        /* Exception: if the default pin setup is vref50, we give it priority */
+        if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
+                return AC_PINCTL_VREF_80;
+        else if (pincap & AC_PINCAP_VREF_50)
+                return AC_PINCTL_VREF_50;
+        else if (pincap & AC_PINCAP_VREF_100)
+                return AC_PINCTL_VREF_100;
+        else if (pincap & AC_PINCAP_VREF_GRD)
+                return AC_PINCTL_VREF_GRD;
+        return AC_PINCTL_VREF_HIZ;
+}
+EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
+int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
+                         unsigned int val, bool cached)
+{
+        if (val) {
+                unsigned int cap = snd_hda_query_pin_caps(codec, pin);
+                if (cap && (val & AC_PINCTL_OUT_EN)) {
+                        if (!(cap & AC_PINCAP_OUT))
+                                val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
+                        else if ((val & AC_PINCTL_HP_EN) &&
+                                 !(cap & AC_PINCAP_HP_DRV))
+                                val &= ~AC_PINCTL_HP_EN;
+                }
+                if (cap && (val & AC_PINCTL_IN_EN)) {
+                        if (!(cap & AC_PINCAP_IN))
+                                val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
+                }
+        }
+        if (cached)
+                return snd_hda_codec_update_cache(codec, pin, 0,
+                                AC_VERB_SET_PIN_WIDGET_CONTROL, val);
+        else
+                return snd_hda_codec_write(codec, pin, 0,
+                                           AC_VERB_SET_PIN_WIDGET_CONTROL, val);
+}
+EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
 /*
 * Helper for automatic pin configuration
 */
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 0ec9248165bc..a5cee952547d 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -502,6 +502,46 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
 #define PIN_HP                  (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN)
 #define PIN_HP_AMP              (AC_PINCTL_HP_EN)
+unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin);
+int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
+                         unsigned int val, bool cached);
+/**
+ * _snd_hda_set_pin_ctl - Set a pin-control value safely
+ * @codec: the codec instance
+ * @pin: the pin NID to set the control
+ * @val: the pin-control value (AC_PINCTL_* bits)
+ *
+ * This function sets the pin-control value to the given pin, but
+ * filters out the invalid pin-control bits when the pin has no such
+ * capabilities.  For example, when PIN_HP is passed but the pin has no
+ * HP-drive capability, the HP bit is omitted.
+ *
+ * The function doesn't check the input VREF capability bits, though.
+ * Use snd_hda_get_default_vref() to guess the right value.
+ * Also, this function is only for analog pins, not for HDMI pins.
+ */
+static inline int
+snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val)
+{
+        return _snd_hda_set_pin_ctl(codec, pin, val, false);
+}
+/**
+ * snd_hda_set_pin_ctl_cache - Set a pin-control value safely
+ * @codec: the codec instance
+ * @pin: the pin NID to set the control
+ * @val: the pin-control value (AC_PINCTL_* bits)
+ *
+ * Just like snd_hda_set_pin_ctl() but write to cache as well.
+ */
+static inline int
+snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin,
+                          unsigned int val)
+{
+        return _snd_hda_set_pin_ctl(codec, pin, val, true);
+}
 /*
 * get widget capabilities
 */
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 7143393927da..723bb9cb5f09 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -1742,9 +1742,7 @@ static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
        if (! ad198x_eapd_put(kcontrol, ucontrol))
                return 0;
        /* change speaker pin appropriately */
-        snd_hda_codec_write(codec, 0x05, 0,
+        snd_hda_set_pin_ctl(codec, 0x05, spec->cur_eapd ? PIN_OUT : 0);
-                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            spec->cur_eapd ? PIN_OUT : 0);
        /* toggle HP mute appropriately */
        snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
                                 HDA_AMP_MUTE,
@@ -3103,7 +3101,7 @@ static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
                                              int dac_idx)
 {
        /* set as output */
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
+        snd_hda_set_pin_ctl(codec, nid, pin_type);
        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
        switch (nid) {
        case 0x11: /* port-A - DAC 03 */
@@ -3157,6 +3155,7 @@ static void ad1988_auto_init_analog_input(struct hda_codec *codec)
        for (i = 0; i < cfg->num_inputs; i++) {
                hda_nid_t nid = cfg->inputs[i].pin;
                int type = cfg->inputs[i].type;
+                int val;
                switch (nid) {
                case 0x15: /* port-C */
                        snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
@@ -3165,8 +3164,10 @@ static void ad1988_auto_init_analog_input(struct hda_codec *codec)
                        snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
                        break;
                }
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                val = PIN_IN;
-                                    type == AUTO_PIN_MIC ? PIN_VREF80 : PIN_IN);
+                if (type == AUTO_PIN_MIC)
+                        val |= snd_hda_get_default_vref(codec, nid);
+                snd_hda_set_pin_ctl(codec, nid, val);
                if (nid != AD1988_PIN_CD_NID)
                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
                                            AMP_OUT_MUTE);
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c
index 09ccfabb4a17..a3b70a8f6df8 100644
--- a/sound/pci/hda/patch_ca0110.c
+++ b/sound/pci/hda/patch_ca0110.c
@@ -341,8 +341,7 @@ static int ca0110_build_pcms(struct hda_codec *codec)
 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
 {
        if (pin) {
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_HP);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
                if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
                        snd_hda_codec_write(codec, pin, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
@@ -356,8 +355,8 @@ static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)
 {
        if (pin) {
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_IN |
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80);
+                                    snd_hda_get_default_vref(codec, pin));
                if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)
                        snd_hda_codec_write(codec, pin, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c
index 21d91d580da8..d290a8ff0108 100644
--- a/sound/pci/hda/patch_ca0132.c
+++ b/sound/pci/hda/patch_ca0132.c
@@ -239,8 +239,7 @@ enum get_set {
 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
 {
        if (pin) {
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_HP);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
                if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
                        snd_hda_codec_write(codec, pin, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
@@ -254,9 +253,8 @@ static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)
 {
        if (pin) {
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_IN |
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    snd_hda_get_default_vref(codec, pin));
-                                    PIN_VREF80);
                if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)
                        snd_hda_codec_write(codec, pin, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index c83ccdba1e5a..48c6d8186e90 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -933,8 +933,7 @@ static void cs_automute(struct hda_codec *codec)
                        pin_ctl = 0;
                nid = cfg->speaker_pins[i];
-                snd_hda_codec_write(codec, nid, 0,
+                snd_hda_set_pin_ctl(codec, nid, pin_ctl);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, pin_ctl);
        }
        if (spec->gpio_eapd_hp) {
                unsigned int gpio = hp_present ?
@@ -948,16 +947,14 @@ static void cs_automute(struct hda_codec *codec)
                /* mute HPs if spdif jack (SENSE_B) is present */
                for (i = 0; i < cfg->hp_outs; i++) {
                        nid = cfg->hp_pins[i];
-                        snd_hda_codec_write(codec, nid, 0,
+                        snd_hda_set_pin_ctl(codec, nid,
-                                AC_VERB_SET_PIN_WIDGET_CONTROL,
                                (spdif_present && spec->sense_b) ? 0 : PIN_HP);
                }
                /* SPDIF TX on/off */
                if (cfg->dig_outs) {
                        nid = cfg->dig_out_pins[0];
-                        snd_hda_codec_write(codec, nid, 0,
+                        snd_hda_set_pin_ctl(codec, nid,
-                                AC_VERB_SET_PIN_WIDGET_CONTROL,
                                spdif_present ? PIN_OUT : 0);
                }
@@ -1024,13 +1021,11 @@ static void init_output(struct hda_codec *codec)
        /* set appropriate pin controls */
        for (i = 0; i < cfg->line_outs; i++)
-                snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
+                snd_hda_set_pin_ctl(codec, cfg->line_out_pins[i], PIN_OUT);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
        /* HP */
        for (i = 0; i < cfg->hp_outs; i++) {
                hda_nid_t nid = cfg->hp_pins[i];
-                snd_hda_codec_write(codec, nid, 0,
+                snd_hda_set_pin_ctl(codec, nid, PIN_HP);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
                if (!cfg->speaker_outs)
                        continue;
                if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
@@ -1041,8 +1036,7 @@ static void init_output(struct hda_codec *codec)
        /* Speaker */
        for (i = 0; i < cfg->speaker_outs; i++)
-                snd_hda_codec_write(codec, cfg->speaker_pins[i], 0,
+                snd_hda_set_pin_ctl(codec, cfg->speaker_pins[i], PIN_OUT);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
        /* SPDIF is enabled on presence detect for CS421x */
        if (spec->hp_detect || spec->spdif_detect)
@@ -1063,14 +1057,9 @@ static void init_input(struct hda_codec *codec)
                        continue;
                /* set appropriate pin control and mute first */
                ctl = PIN_IN;
-                if (cfg->inputs[i].type == AUTO_PIN_MIC) {
+                if (cfg->inputs[i].type == AUTO_PIN_MIC)
-                        unsigned int caps = snd_hda_query_pin_caps(codec, pin);
+                        ctl |= snd_hda_get_default_vref(codec, pin);
-                        caps >>= AC_PINCAP_VREF_SHIFT;
+                snd_hda_set_pin_ctl(codec, pin, ctl);
-                        if (caps & AC_PINCAP_VREF_80)
-                                ctl = PIN_VREF80;
-                }
-                snd_hda_codec_write(codec, pin, 0,
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
                snd_hda_codec_write(codec, spec->adc_nid[i], 0,
                                    AC_VERB_SET_AMP_GAIN_MUTE,
                                    AMP_IN_MUTE(spec->adc_idx[i]));
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index d906c5b74cf0..aabdb9e9a484 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -141,6 +141,7 @@ struct conexant_spec {
        unsigned int hp_laptop:1;
        unsigned int asus:1;
        unsigned int pin_eapd_ctrls:1;
+        unsigned int fixup_stereo_dmic:1;
        unsigned int adc_switching:1;
@@ -1601,17 +1602,13 @@ static void cxt5051_update_speaker(struct hda_codec *codec)
        unsigned int pinctl;
        /* headphone pin */
        pinctl = (spec->hp_present && spec->cur_eapd) ? PIN_HP : 0;
-        snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x16, pinctl);
-                            pinctl);
        /* speaker pin */
        pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
-        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x1a, pinctl);
-                            pinctl);
        /* on ideapad there is an additional speaker (subwoofer) to mute */
        if (spec->ideapad)
-                snd_hda_codec_write(codec, 0x1b, 0,
+                snd_hda_set_pin_ctl(codec, 0x1b, pinctl);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    pinctl);
 }
 /* turn on/off EAPD (+ mute HP) as a master switch */
@@ -1996,8 +1993,7 @@ static void cxt5066_update_speaker(struct hda_codec *codec)
        /* Port A (HP) */
        pinctl = (hp_port_a_present(spec) && spec->cur_eapd) ? PIN_HP : 0;
-        snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x19, pinctl);
-                        pinctl);
        /* Port D (HP/LO) */
        pinctl = spec->cur_eapd ? spec->port_d_mode : 0;
@@ -2010,13 +2006,11 @@ static void cxt5066_update_speaker(struct hda_codec *codec)
                if (!hp_port_d_present(spec))
                        pinctl = 0;
        }
-        snd_hda_codec_write(codec, 0x1c, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x1c, pinctl);
-                        pinctl);
        /* CLASS_D AMP */
        pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
-        snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x1f, pinctl);
-                        pinctl);
 }
 /* turn on/off EAPD (+ mute HP) as a master switch */
@@ -2047,8 +2041,7 @@ static int cxt5066_set_olpc_dc_bias(struct hda_codec *codec)
        /* Even though port F is the DC input, the bias is controlled on port B.
         * we also leave that port as an active input (but unselected) in DC mode
         * just in case that is necessary to make the bias setting take effect. */
-        return snd_hda_codec_write_cache(codec, 0x1a, 0,
+        return snd_hda_set_pin_ctl_cache(codec, 0x1a,
-                AC_VERB_SET_PIN_WIDGET_CONTROL,
                cxt5066_olpc_dc_bias.items[spec->dc_input_bias].index);
 }
@@ -2081,14 +2074,14 @@ static void cxt5066_olpc_select_mic(struct hda_codec *codec)
        }
        /* disable DC (port F) */
-        snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+        snd_hda_set_pin_ctl(codec, 0x1e, 0);
        /* external mic, port B */
-        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x1a,
                spec->ext_mic_present ? CXT5066_OLPC_EXT_MIC_BIAS : 0);
        /* internal mic, port C */
-        snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, 0x1b,
                spec->ext_mic_present ? 0 : PIN_VREF80);
 }
@@ -3357,9 +3350,7 @@ static void do_automute(struct hda_codec *codec, int num_pins,
        struct conexant_spec *spec = codec->spec;
        int i;
        for (i = 0; i < num_pins; i++)
-                snd_hda_codec_write(codec, pins[i], 0,
+                snd_hda_set_pin_ctl(codec, pins[i], on ? PIN_OUT : 0);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    on ? PIN_OUT : 0);
        if (spec->pin_eapd_ctrls)
                cx_auto_turn_eapd(codec, num_pins, pins, on);
 }
@@ -3976,8 +3967,7 @@ static void cx_auto_init_output(struct hda_codec *codec)
                if (snd_hda_query_pin_caps(codec, cfg->hp_pins[i]) &
                    AC_PINCAP_HP_DRV)
                        val |= AC_PINCTL_HP_EN;
-                snd_hda_codec_write(codec, cfg->hp_pins[i], 0,
+                snd_hda_set_pin_ctl(codec, cfg->hp_pins[i], val);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, val);
        }
        mute_outputs(codec, cfg->hp_outs, cfg->hp_pins);
        mute_outputs(codec, cfg->line_outs, cfg->line_out_pins);
@@ -4030,13 +4020,11 @@ static void cx_auto_init_input(struct hda_codec *codec)
        }
        for (i = 0; i < cfg->num_inputs; i++) {
-                unsigned int type;
+                hda_nid_t pin = cfg->inputs[i].pin;
+                unsigned int type = PIN_IN;
                if (cfg->inputs[i].type == AUTO_PIN_MIC)
-                        type = PIN_VREF80;
+                        type |= snd_hda_get_default_vref(codec, pin);
-                else
+                snd_hda_set_pin_ctl(codec, pin, type);
-                        type = PIN_IN;
-                snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, type);
        }
        if (spec->auto_mic) {
@@ -4063,11 +4051,9 @@ static void cx_auto_init_digital(struct hda_codec *codec)
        struct auto_pin_cfg *cfg = &spec->autocfg;
        if (spec->multiout.dig_out_nid)
-                snd_hda_codec_write(codec, cfg->dig_out_pins[0], 0,
+                snd_hda_set_pin_ctl(codec, cfg->dig_out_pins[0], PIN_OUT);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
        if (spec->dig_in_nid)
-                snd_hda_codec_write(codec, cfg->dig_in_pin, 0,
+                snd_hda_set_pin_ctl(codec, cfg->dig_in_pin, PIN_IN);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
 }
 static int cx_auto_init(struct hda_codec *codec)
@@ -4084,9 +4070,9 @@ static int cx_auto_init(struct hda_codec *codec)
 static int cx_auto_add_volume_idx(struct hda_codec *codec, const char *basename,
                              const char *dir, int cidx,
-                              hda_nid_t nid, int hda_dir, int amp_idx)
+                              hda_nid_t nid, int hda_dir, int amp_idx, int chs)
 {
-        static char name[32];
+        static char name[44];
        static struct snd_kcontrol_new knew[] = {
                HDA_CODEC_VOLUME(name, 0, 0, 0),
                HDA_CODEC_MUTE(name, 0, 0, 0),
@@ -4096,7 +4082,7 @@ static int cx_auto_add_volume_idx(struct hda_codec *codec, const char *basename,
        for (i = 0; i < 2; i++) {
                struct snd_kcontrol *kctl;
-                knew[i].private_value = HDA_COMPOSE_AMP_VAL(nid, 3, amp_idx,
+                knew[i].private_value = HDA_COMPOSE_AMP_VAL(nid, chs, amp_idx,
                                                            hda_dir);
                knew[i].subdevice = HDA_SUBDEV_AMP_FLAG;
                knew[i].index = cidx;
@@ -4115,7 +4101,7 @@ static int cx_auto_add_volume_idx(struct hda_codec *codec, const char *basename,
 }
 #define cx_auto_add_volume(codec, str, dir, cidx, nid, hda_dir)         \
-        cx_auto_add_volume_idx(codec, str, dir, cidx, nid, hda_dir, 0)
+        cx_auto_add_volume_idx(codec, str, dir, cidx, nid, hda_dir, 0, 3)
 #define cx_auto_add_pb_volume(codec, nid, str, idx)                     \
        cx_auto_add_volume(codec, str, " Playback", idx, nid, HDA_OUTPUT)
@@ -4185,6 +4171,36 @@ static int cx_auto_build_output_controls(struct hda_codec *codec)
        return 0;
 }
+/* Returns zero if this is a normal stereo channel, and non-zero if it should
+   be split in two independent channels.
+   dest_label must be at least 44 characters. */
+static int cx_auto_get_rightch_label(struct hda_codec *codec, const char *label,
+                                     char *dest_label, int nid)
+{
+        struct conexant_spec *spec = codec->spec;
+        int i;
+        if (!spec->fixup_stereo_dmic)
+                return 0;
+        for (i = 0; i < AUTO_CFG_MAX_INS; i++) {
+                int def_conf;
+                if (spec->autocfg.inputs[i].pin != nid)
+                        continue;
+                if (spec->autocfg.inputs[i].type != AUTO_PIN_MIC)
+                        return 0;
+                def_conf = snd_hda_codec_get_pincfg(codec, nid);
+                if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT)
+                        return 0;
+                /* Finally found the inverted internal mic! */
+                snprintf(dest_label, 44, "Inverted %s", label);
+                return 1;
+        }
+        return 0;
+}
 static int cx_auto_add_capture_volume(struct hda_codec *codec, hda_nid_t nid,
                                      const char *label, const char *pfx,
                                      int cidx)
@@ -4193,14 +4209,25 @@ static int cx_auto_add_capture_volume(struct hda_codec *codec, hda_nid_t nid,
        int i;
        for (i = 0; i < spec->num_adc_nids; i++) {
+                char rightch_label[44];
                hda_nid_t adc_nid = spec->adc_nids[i];
                int idx = get_input_connection(codec, adc_nid, nid);
                if (idx < 0)
                        continue;
                if (codec->single_adc_amp)
                        idx = 0;
+                if (cx_auto_get_rightch_label(codec, label, rightch_label, nid)) {
+                        /* Make two independent kcontrols for left and right */
+                        int err = cx_auto_add_volume_idx(codec, label, pfx,
+                                              cidx, adc_nid, HDA_INPUT, idx, 1);
+                        if (err < 0)
+                                return err;
+                        return cx_auto_add_volume_idx(codec, rightch_label, pfx,
+                                                      cidx, adc_nid, HDA_INPUT, idx, 2);
+                }
                return cx_auto_add_volume_idx(codec, label, pfx,
-                                              cidx, adc_nid, HDA_INPUT, idx);
+                                              cidx, adc_nid, HDA_INPUT, idx, 3);
        }
        return 0;
 }
@@ -4213,9 +4240,19 @@ static int cx_auto_add_boost_volume(struct hda_codec *codec, int idx,
        int i, con;
        nid = spec->imux_info[idx].pin;
-        if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
+        if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
+                char rightch_label[44];
+                if (cx_auto_get_rightch_label(codec, label, rightch_label, nid)) {
+                        int err = cx_auto_add_volume_idx(codec, label, " Boost",
+                                                         cidx, nid, HDA_INPUT, 0, 1);
+                        if (err < 0)
+                                return err;
+                        return cx_auto_add_volume_idx(codec, rightch_label, " Boost",
+                                                      cidx, nid, HDA_INPUT, 0, 2);
+                }
                return cx_auto_add_volume(codec, label, " Boost", cidx,
                                          nid, HDA_INPUT);
+        }
        con = __select_input_connection(codec, spec->imux_info[idx].adc, nid,
                                        &mux, false, 0);
        if (con < 0)
@@ -4382,23 +4419,33 @@ static void apply_pincfg(struct hda_codec *codec, const struct cxt_pincfg *cfg)
 }
-static void apply_pin_fixup(struct hda_codec *codec,
+enum {
+        CXT_PINCFG_LENOVO_X200,
+        CXT_PINCFG_LENOVO_TP410,
+        CXT_FIXUP_STEREO_DMIC,
+};
+static void apply_fixup(struct hda_codec *codec,
                            const struct snd_pci_quirk *quirk,
                            const struct cxt_pincfg **table)
 {
+        struct conexant_spec *spec = codec->spec;
        quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
-        if (quirk) {
+        if (!quirk)
+                return;
+        if (table[quirk->value]) {
                snd_printdd(KERN_INFO "hda_codec: applying pincfg for %s\n",
                            quirk->name);
                apply_pincfg(codec, table[quirk->value]);
        }
+        if (quirk->value == CXT_FIXUP_STEREO_DMIC) {
+                snd_printdd(KERN_INFO "hda_codec: applying internal mic workaround for %s\n",
+                            quirk->name);
+                spec->fixup_stereo_dmic = 1;
+        }
 }
-enum {
-        CXT_PINCFG_LENOVO_X200,
-        CXT_PINCFG_LENOVO_TP410,
-};
 /* ThinkPad X200 & co with cxt5051 */
 static const struct cxt_pincfg cxt_pincfg_lenovo_x200[] = {
        { 0x16, 0x042140ff }, /* HP (seq# overridden) */
@@ -4419,6 +4466,7 @@ static const struct cxt_pincfg cxt_pincfg_lenovo_tp410[] = {
 static const struct cxt_pincfg *cxt_pincfg_tbl[] = {
        [CXT_PINCFG_LENOVO_X200] = cxt_pincfg_lenovo_x200,
        [CXT_PINCFG_LENOVO_TP410] = cxt_pincfg_lenovo_tp410,
+        [CXT_FIXUP_STEREO_DMIC] = NULL,
 };
 static const struct snd_pci_quirk cxt5051_fixups[] = {
@@ -4432,6 +4480,7 @@ static const struct snd_pci_quirk cxt5066_fixups[] = {
        SND_PCI_QUIRK(0x17aa, 0x215f, "Lenovo T510", CXT_PINCFG_LENOVO_TP410),
        SND_PCI_QUIRK(0x17aa, 0x21ce, "Lenovo T420", CXT_PINCFG_LENOVO_TP410),
        SND_PCI_QUIRK(0x17aa, 0x21cf, "Lenovo T520", CXT_PINCFG_LENOVO_TP410),
+        SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
        {}
 };
@@ -4471,11 +4520,11 @@ static int patch_conexant_auto(struct hda_codec *codec)
        case 0x14f15051:
                add_cx5051_fake_mutes(codec);
                codec->pin_amp_workaround = 1;
-                apply_pin_fixup(codec, cxt5051_fixups, cxt_pincfg_tbl);
+                apply_fixup(codec, cxt5051_fixups, cxt_pincfg_tbl);
                break;
        default:
                codec->pin_amp_workaround = 1;
-                apply_pin_fixup(codec, cxt5066_fixups, cxt_pincfg_tbl);
+                apply_fixup(codec, cxt5066_fixups, cxt_pincfg_tbl);
        }
        /* Show mute-led control only on HP laptops
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 7810913d07a0..6dd1b74e9f68 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -319,13 +319,16 @@ static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
        /* for shared I/O, change the pin-control accordingly */
        if (spec->shared_mic_hp) {
+                unsigned int val;
+                hda_nid_t pin = spec->autocfg.inputs[1].pin;
                /* NOTE: this assumes that there are only two inputs, the
                 * first is the real internal mic and the second is HP jack.
                 */
-                snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0,
+                if (spec->cur_mux[adc_idx])
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                        val = snd_hda_get_default_vref(codec, pin) | PIN_IN;
-                                    spec->cur_mux[adc_idx] ?
+                else
-                                    PIN_VREF80 : PIN_HP);
+                        val = PIN_HP;
+                snd_hda_set_pin_ctl(codec, pin, val);
                spec->automute_speaker = !spec->cur_mux[adc_idx];
                call_update_outputs(codec);
        }
@@ -376,25 +379,9 @@ static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
                              int auto_pin_type)
 {
        unsigned int val = PIN_IN;
+        if (auto_pin_type == AUTO_PIN_MIC)
-        if (auto_pin_type == AUTO_PIN_MIC) {
+                val |= snd_hda_get_default_vref(codec, nid);
-                unsigned int pincap;
+        snd_hda_set_pin_ctl(codec, nid, val);
-                unsigned int oldval;
-                oldval = snd_hda_codec_read(codec, nid, 0,
-                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-                pincap = snd_hda_query_pin_caps(codec, nid);
-                pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
-                /* if the default pin setup is vref50, we give it priority */
-                if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
-                        val = PIN_VREF80;
-                else if (pincap & AC_PINCAP_VREF_50)
-                        val = PIN_VREF50;
-                else if (pincap & AC_PINCAP_VREF_100)
-                        val = PIN_VREF100;
-                else if (pincap & AC_PINCAP_VREF_GRD)
-                        val = PIN_VREFGRD;
-        }
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 }
 /*
@@ -517,9 +504,7 @@ static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
                        } else
                                val = 0;
                        val |= pin_bits;
-                        snd_hda_codec_write(codec, nid, 0,
+                        snd_hda_set_pin_ctl(codec, nid, val);
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            val);
                        break;
                case ALC_AUTOMUTE_AMP:
                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
@@ -1621,8 +1606,7 @@ static void alc_auto_init_digital(struct hda_codec *codec)
                pin = spec->autocfg.dig_out_pins[i];
                if (!pin)
                        continue;
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_OUT);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
                if (!i)
                        dac = spec->multiout.dig_out_nid;
                else
@@ -1635,9 +1619,7 @@ static void alc_auto_init_digital(struct hda_codec *codec)
        }
        pin = spec->autocfg.dig_in_pin;
        if (pin)
-                snd_hda_codec_write(codec, pin, 0,
+                snd_hda_set_pin_ctl(codec, pin, PIN_IN);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    PIN_IN);
 }
 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
@@ -2856,8 +2838,7 @@ static int alc_auto_create_shared_input(struct hda_codec *codec)
 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
                               unsigned int pin_type)
 {
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, nid, pin_type);
-                            pin_type);
        /* unmute pin */
        if (nid_has_mute(codec, nid, HDA_OUTPUT))
                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
@@ -3998,9 +3979,7 @@ static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
                        snd_hda_codec_read(codec, nid, 0,
                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
        if (output) {
-                snd_hda_codec_update_cache(codec, nid, 0,
+                snd_hda_set_pin_ctl_cache(codec, nid, PIN_OUT);
-                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                           PIN_OUT);
                if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
                                                 HDA_AMP_MUTE, 0);
@@ -4009,9 +3988,8 @@ static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
                if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
                                                 HDA_AMP_MUTE, HDA_AMP_MUTE);
-                snd_hda_codec_update_cache(codec, nid, 0,
+                snd_hda_set_pin_ctl_cache(codec, nid,
-                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                          spec->multi_io[idx].ctl_in);
-                                           spec->multi_io[idx].ctl_in);
        }
        return 0;
 }
@@ -5171,8 +5149,7 @@ static void alc889_fixup_mbp_vref(struct hda_codec *codec,
                val = snd_hda_codec_read(codec, nids[i], 0,
                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                val |= AC_PINCTL_VREF_80;
-                snd_hda_codec_write(codec, nids[i], 0,
+                snd_hda_set_pin_ctl(codec, nids[i], val);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, val);
                spec->keep_vref_in_automute = 1;
                break;
        }
@@ -5193,8 +5170,7 @@ static void alc889_fixup_imac91_vref(struct hda_codec *codec,
                val = snd_hda_codec_read(codec, nids[i], 0,
                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                val |= AC_PINCTL_VREF_50;
-                snd_hda_codec_write(codec, nids[i], 0,
+                snd_hda_set_pin_ctl(codec, nids[i], val);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, val);
        }
        spec->keep_vref_in_automute = 1;
 }
@@ -5946,9 +5922,7 @@ static void alc269_fixup_mic2_mute_hook(void *private_data, int enabled)
 {
        struct hda_codec *codec = private_data;
        unsigned int pinval = enabled ? 0x20 : 0x24;
-        snd_hda_codec_update_cache(codec, 0x19, 0,
+        snd_hda_set_pin_ctl_cache(codec, 0x19, pinval);
-                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                   pinval);
 }
 static void alc269_fixup_mic2_mute(struct hda_codec *codec,
@@ -6346,8 +6320,7 @@ static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
        if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
                val |= AC_PINCTL_IN_EN;
        val |= AC_PINCTL_VREF_50;
-        snd_hda_codec_write(codec, 0x0f, 0,
+        snd_hda_set_pin_ctl(codec, 0x0f, val);
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, val);
        spec->keep_vref_in_automute = 1;
 }
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 4742cac26aa9..884f8ad351fd 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -681,8 +681,7 @@ static int stac_vrefout_set(struct hda_codec *codec,
        pinctl &= ~AC_PINCTL_VREFEN;
        pinctl |= (new_vref & AC_PINCTL_VREFEN);
-        error = snd_hda_codec_write_cache(codec, nid, 0,
+        error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
-                                        AC_VERB_SET_PIN_WIDGET_CONTROL, pinctl);
        if (error < 0)
                return error;
@@ -706,8 +705,7 @@ static unsigned int stac92xx_vref_set(struct hda_codec *codec,
        else
                pincfg |= AC_PINCTL_IN_EN;
-        error = snd_hda_codec_write_cache(codec, nid, 0,
+        error = snd_hda_set_pin_ctl_cache(codec, nid, pincfg);
-                                        AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
        if (error < 0)
                return error;
        else
@@ -2505,27 +2503,10 @@ static int stac92xx_build_pcms(struct hda_codec *codec)
        return 0;
 }
-static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
-                                        hda_nid_t nid)
-{
-        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
-        pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
-        if (pincap & AC_PINCAP_VREF_100)
-                return AC_PINCTL_VREF_100;
-        if (pincap & AC_PINCAP_VREF_80)
-                return AC_PINCTL_VREF_80;
-        if (pincap & AC_PINCAP_VREF_50)
-                return AC_PINCTL_VREF_50;
-        if (pincap & AC_PINCAP_VREF_GRD)
-                return AC_PINCTL_VREF_GRD;
-        return 0;
-}
 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
 {
-        snd_hda_codec_write_cache(codec, nid, 0,
+        snd_hda_set_pin_ctl_cache(codec, nid, pin_type);
-                                  AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
 }
 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
@@ -2594,7 +2575,7 @@ static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
        hda_nid_t nid = kcontrol->private_value;
        unsigned int vref = stac92xx_vref_get(codec, nid);
-        if (vref == stac92xx_get_default_vref(codec, nid))
+        if (vref == snd_hda_get_default_vref(codec, nid))
                ucontrol->value.enumerated.item[0] = 0;
        else if (vref == AC_PINCTL_VREF_GRD)
                ucontrol->value.enumerated.item[0] = 1;
@@ -2613,7 +2594,7 @@ static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
        hda_nid_t nid = kcontrol->private_value;
        if (ucontrol->value.enumerated.item[0] == 0)
-                new_vref = stac92xx_get_default_vref(codec, nid);
+                new_vref = snd_hda_get_default_vref(codec, nid);
        else if (ucontrol->value.enumerated.item[0] == 1)
                new_vref = AC_PINCTL_VREF_GRD;
        else if (ucontrol->value.enumerated.item[0] == 2)
@@ -2679,7 +2660,7 @@ static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
        else {
                unsigned int pinctl = AC_PINCTL_IN_EN;
                if (io_idx) /* set VREF for mic */
-                        pinctl |= stac92xx_get_default_vref(codec, nid);
+                        pinctl |= snd_hda_get_default_vref(codec, nid);
                stac92xx_auto_set_pinctl(codec, nid, pinctl);
        }
@@ -2847,7 +2828,7 @@ static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
        char name[22];
        if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
-                if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
+                if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
                        && nid == spec->line_switch)
                        control = STAC_CTL_WIDGET_IO_SWITCH;
                else if (snd_hda_query_pin_caps(codec, nid)
@@ -4354,7 +4335,7 @@ static int stac92xx_init(struct hda_codec *codec)
                unsigned int pinctl, conf;
                if (type == AUTO_PIN_MIC) {
                        /* for mic pins, force to initialize */
-                        pinctl = stac92xx_get_default_vref(codec, nid);
+                        pinctl = snd_hda_get_default_vref(codec, nid);
                        pinctl |= AC_PINCTL_IN_EN;
                        stac92xx_auto_set_pinctl(codec, nid, pinctl);
                } else {
@@ -4460,8 +4441,7 @@ static void stac92xx_shutup_pins(struct hda_codec *codec)
                struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
                def_conf = snd_hda_codec_get_pincfg(codec, pin->nid);
                if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
-                        snd_hda_codec_write(codec, pin->nid, 0,
+                        snd_hda_set_pin_ctl(codec, pin->nid, 0);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
        }
 }
@@ -4517,9 +4497,7 @@ static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
        
        pin_ctl |= flag;
        if (old_ctl != pin_ctl)
-                snd_hda_codec_write_cache(codec, nid, 0,
+                snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl);
-                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                          pin_ctl);
 }
 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
@@ -4528,9 +4506,7 @@ static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
        unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
                        0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
        if (pin_ctl & flag)
-                snd_hda_codec_write_cache(codec, nid, 0,
+                snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag);
-                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                          pin_ctl & ~flag);
 }
 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 06214fdc9486..92e11672b91c 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -532,8 +532,7 @@ static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
 {
        if (!pin)
                return;
-        snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+        snd_hda_set_pin_ctl(codec, pin, pin_type);
-                            pin_type);
        if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
                snd_hda_codec_write(codec, pin, 0,
                                    AC_VERB_SET_EAPD_BTLENABLE, 0x02);
@@ -662,12 +661,12 @@ static void via_auto_init_analog_input(struct hda_codec *codec)
                hda_nid_t nid = cfg->inputs[i].pin;
                if (spec->smart51_enabled && is_smart51_pins(codec, nid))
                        ctl = PIN_OUT;
-                else if (cfg->inputs[i].type == AUTO_PIN_MIC)
+                else {
-                        ctl = PIN_VREF50;
-                else
                        ctl = PIN_IN;
-                snd_hda_codec_write(codec, nid, 0,
+                        if (cfg->inputs[i].type == AUTO_PIN_MIC)
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
+                                ctl |= snd_hda_get_default_vref(codec, nid);
+                }
+                snd_hda_set_pin_ctl(codec, nid, ctl);
        }
        /* init input-src */
@@ -1006,9 +1005,7 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol,
                                          AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
                parm |= out_in;
-                snd_hda_codec_write(codec, nid, 0,
+                snd_hda_set_pin_ctl(codec, nid, parm);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    parm);
                if (out_in == AC_PINCTL_OUT_EN) {
                        mute_aa_path(codec, 1);
                        notify_aa_path_ctls(codec);
@@ -1647,8 +1644,7 @@ static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
                        parm &= ~AC_PINCTL_OUT_EN;
                else
                        parm |= AC_PINCTL_OUT_EN;
-                snd_hda_codec_write(codec, pins[i], 0,
+                snd_hda_set_pin_ctl(codec, pins[i], parm);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, parm);
        }
 }
@@ -1709,8 +1705,7 @@ static void via_gpio_control(struct hda_codec *codec)
        if (gpio_data == 0x02) {
                /* unmute line out */
-                snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
+                snd_hda_set_pin_ctl(codec, spec->autocfg.line_out_pins[0],
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
                                    PIN_OUT);
                if (vol_counter & 0x20) {
                        /* decrease volume */
@@ -1728,9 +1723,7 @@ static void via_gpio_control(struct hda_codec *codec)
                }
        } else if (!(gpio_data & 0x02)) {
                /* mute line out */
-                snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
+                snd_hda_set_pin_ctl(codec, spec->autocfg.line_out_pins[0], 0);
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    0);
        }
 }
@@ -2757,8 +2750,7 @@ static void via_auto_init_dig_in(struct hda_codec *codec)
        struct via_spec *spec = codec->spec;
        if (!spec->dig_in_nid)
                return;
-        snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
+        snd_hda_set_pin_ctl(codec, spec->autocfg.dig_in_pin, PIN_IN);
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
 }
 /* initialize the unsolicited events */